/**/
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <sys/uio.h>
+
#include "internal.h"
adns_status adns__mkquery(adns_state ads, const char *owner, int ol, int id,
- adns_rrtype type, adns_queryflags flags) {
+ const typeinfo *typei, adns_queryflags flags) {
/* Assembles a query packet in ads->rqbuf. */
int ll, c, nlabs;
- unsigned char label[255], *rqp;
+ byte label[255], *rqp;
const char *p, *pe;
#define MKQUERY_ADDB(b) *rqp++= (b)
#define MKQUERY_ADDW(w) (MKQUERY_ADDB(((w)>>8)&0x0ff), MKQUERY_ADDB((w)&0x0ff))
- if (!vbuf_ensure(&ads->rqbuf,12+strlen(owner)+3)) return adns_s_nolocalmem;
+ if (!adns__vbuf_ensure(&ads->rqbuf,DNS_HDRSIZE+strlen(owner)+1+5))
+ return adns_s_nolocalmem;
rqp= ads->rqbuf.buf;
MKQUERY_ADDW(id);
ll= 0;
while (p!=pe && (c= *p++)!='.') {
if (c=='\\') {
- if (!(flags & adns_f_anyquote)) return adns_s_invaliddomain;
+ if (!(flags & adns_qf_anyquote)) return adns_s_invaliddomain;
if (ctype_digit(p[0])) {
if (ctype_digit(p[1]) && ctype_digit(p[2])) {
c= (*p++ - '0')*100 + (*p++ - '0')*10 + (*p++ - '0');
return adns_s_invaliddomain;
}
}
- if (!(flags & adns_f_anyquote)) {
+ if (!(flags & adns_qf_anyquote)) {
if (ctype_digit(c) || c == '-') {
if (!ll) return adns_s_invaliddomain;
- } else if ((c < 'a' || c > 'z') && (c < 'A' && c > 'Z')) {
+ } else if (!ctype_alpha(c)) {
return adns_s_invaliddomain;
}
}
} while (p!=pe);
MKQUERY_ADDB(0);
- MKQUERY_ADDW(type & adns__rrt_typemask); /* QTYPE */
- MKQUERY_ADDW(1); /* QCLASS=IN */
+ MKQUERY_ADDW(typei->type & adns__rrt_typemask); /* QTYPE */
+ MKQUERY_ADDW(DNS_CLASS_IN); /* QCLASS=IN */
- ads->rqbuf.used= rqp - ads->rqbuf.used;
- assert(ads->rqbuf.used < ads->rqbuf.avail);
+ ads->rqbuf.used= rqp - ads->rqbuf.buf;
+ assert(ads->rqbuf.used <= ads->rqbuf.avail);
return adns_s_ok;
}
-void adns__query_tcp(adns_state ads, adns_query qu) {
+void adns__query_tcp(adns_state ads, adns_query qu, struct timeval now) {
/* Query must be in state tcpwait/timew; it will be moved to a new state
* if possible and no further processing can be done on it for now.
* (Resulting state is one of tcpwait/timew (if server not connected),
* may break. If the conn list lost then the caller is responsible for any
* reestablishment and retry.
*/
- unsigned char length[2];
+ byte length[2];
struct iovec iov[2];
+ int wr, r;
if (ads->tcpstate != server_ok) return;
length[0]= (qu->querylen&0x0ff00U) >>8;
length[1]= (qu->querylen&0x0ff);
- if (!vbuf_ensure(&ads->tcpsend,ads->tcpsend.used+qu->querylen+2)) return;
+ if (!adns__vbuf_ensure(&ads->tcpsend,ads->tcpsend.used+qu->querylen+2)) return;
timevaladd(&now,TCPMS);
qu->timeout= now;
- qu->senttcpserver= ads->tcpserver;
- DLIST_LINKTAIL(ads->timew,qu);
+ qu->state= query_tcpsent;
+ LIST_LINK_TAIL(ads->timew,qu);
- if (ads->opbufused) {
+ if (ads->tcpsend.used) {
wr= 0;
} else {
- iov[0].iovbase= length;
+ iov[0].iov_base= length;
iov[0].iov_len= 2;
- iov[1].iovbase= qu->querymsg;
+ iov[1].iov_base= qu->querymsg;
iov[1].iov_len= qu->querylen;
wr= writev(ads->tcpsocket,iov,2);
if (wr < 0) {
}
if (wr<2) {
- r= vbuf_append(&ads->tcpsend,length,2-wr); assert(r);
+ r= adns__vbuf_append(&ads->tcpsend,length,2-wr); assert(r);
wr= 0;
- } esle {
+ } else {
wr-= 2;
}
if (wr<qu->querylen) {
- r= vbuf_append(&ads->tcpsend,qu->querymsg+wr,qu->querylen-wr); assert(r);
+ r= adns__vbuf_append(&ads->tcpsend,qu->querymsg+wr,qu->querylen-wr); assert(r);
}
}
timevaladd(&now,TCPMS);
qu->timeout= now;
qu->state= query_tcpwait;
- DLIST_LINKTAIL(ads->timew,qu);
- adns__query_tcp(ads,qu);
- adns__tcp_tryconnect(ads);
+ LIST_LINK_TAIL(ads->timew,qu);
+ adns__query_tcp(ads,qu,now);
+ adns__tcp_tryconnect(ads,now);
}
void adns__query_udp(adns_state ads, adns_query qu, struct timeval now) {
* tcpsent/timew, child/childw or done/output.)
*/
struct sockaddr_in servaddr;
- int serv;
+ int serv, r;
assert(qu->state == query_udp);
- if ((qu->flags & adns_f_usevc) ||
- (qu->querylen > UDPMAXDGRAM)) {
+ if ((qu->flags & adns_qf_usevc) || (qu->querylen > DNS_MAXUDP)) {
query_usetcp(ads,qu,now);
return;
}
if (qu->udpretries >= UDPMAXRETRIES) {
- query_fail(ads,qu,adns_s_notresponding);
+ adns__query_fail(ads,qu,adns_s_timeout);
return;
}
- serv= qu->nextudpserver;
+ serv= qu->udpnextserver;
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family= AF_INET;
servaddr.sin_addr= ads->servers[serv].addr;
- servaddr.sin_port= htons(NSPORT);
+ servaddr.sin_port= htons(DNS_PORT);
r= sendto(ads->udpsocket,qu->querymsg,qu->querylen,0,&servaddr,sizeof(servaddr));
if (r<0 && errno == EMSGSIZE) { query_usetcp(ads,qu,now); return; }
- if (r<0) warn("sendto %s failed: %s",inet_ntoa(servaddr.sin_addr),strerror(errno));
+ if (r<0) adns__warn(ads,serv,"sendto failed: %s",strerror(errno));
timevaladd(&now,UDPRETRYMS);
qu->timeout= now;
- qu->sentudp |= (1<<serv);
- qu->nextudpserver= (serv+1)%ads->nservers;
+ qu->udpsent |= (1<<serv);
+ qu->udpnextserver= (serv+1)%ads->nservers;
qu->udpretries++;
- DLIST_LINKTAIL(ads->timew,qu);
+ LIST_LINK_TAIL(ads->timew,qu);
}
-void adns__query_fail(adns_state ads, adns_query qu, adns_status stat) {
+static void adns__query_done(adns_state ads, adns_query qu) {
adns_answer *ans;
-
- ans= qu->answer;
- if (!ans) ans= malloc(sizeof(*qu->answer));
- if (ans) {
- ans->status= stat;
- ans->cname= 0;
- ans->type= qu->type;
- ans->nrrs= 0;
+ allocnode *an, *ann;
+
+ qu->answer= ans= realloc(qu->answer,
+ MEM_ROUND(MEM_ROUND(sizeof(*ans)) +
+ qu->interim_allocd));
+ qu->final_used= MEM_ROUND(sizeof(*ans));
+
+ adns__makefinal_str(qu,&ans->cname);
+ if (ans->nrrs) {
+ adns__makefinal_block(qu,&ans->rrs.untyped,ans->rrsz*ans->nrrs);
+ for (i=0; i<ans->nrrs; i++)
+ qu->typei->makefinal(ads,qu,ans->rrs.bytes+ans->rrsz*i);
}
- qu->answer= ans;
+
+ for (an= qu->allocations; an; an= ann) { ann= an->next; free(an); }
+
+ adns__vbuf_free(&qu->vb);
+
qu->id= -1;
LIST_LINK_TAIL(ads->output,qu);
}
+
+void adns__reset_cnameonly(adns_state ads, adns_query qu) {
+ qu->answer->nrrs= 0;
+ qu->answer->rrs= 0;
+ qu->permalloclen= qu->answer->cname ? MEM_ROUND(strlen(qu->answer->cname)+1) : 0;
+}
+
+void adns__query_fail(adns_state ads, adns_query qu, adns_status stat) {
+ adns__reset_cnameonly(ads,qu);
+ qu->answer->status= stat;
+ qu->answer->type= qu->type;
+ adns__query_done(ads,qu,stat);
+}