X-Git-Url: https://git.distorted.org.uk/~mdw/adns/blobdiff_plain/4bec51a44bf61bca32e7b947f20b1e7d0f971b94..8e5b0abb4e5416f4bd244500d9ba8dd45788093e:/src/query.c?ds=sidebyside

diff --git a/src/query.c b/src/query.c
index f12e1a3..ddd5064 100644
--- a/src/query.c
+++ b/src/query.c
@@ -1,24 +1,27 @@
 /**/
 
+#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, int *qml_r) {
-  int ll, c, nlabs, qbufreq;
-  unsigned char label[255], *nqbuf;
+			  const typeinfo *typei, adns_queryflags flags) {
+  /* Assembles a query packet in ads->rqbuf. */
+  int ll, c, nlabs;
+  byte label[255], *rqp;
   const char *p, *pe;
 
-#define MKQUERY_ADDB(b) *nqbuf++= (b)
+#define MKQUERY_ADDB(b) *rqp++= (b)
 #define MKQUERY_ADDW(w) (MKQUERY_ADDB(((w)>>8)&0x0ff), MKQUERY_ADDB((w)&0x0ff))
 
-  qbufreq= 12+strlen(owner)+3;
-  if (ads->qbufavail < qbufreq) {
-    nqbuf= realloc(ads->qbuf,qbufreq);
-    if (!nqbuf) return adns_s_nolocalmem;
-    ads->qbuf= nqbuf; ads->qbufavail= qbufreq;
-  }
-  nqbuf= ads->qbuf;
-  
+  if (!adns__vbuf_ensure(&ads->rqbuf,DNS_HDRSIZE+strlen(owner)+1+5))
+    return adns_s_nolocalmem;
+  rqp= ads->rqbuf.buf;
+
   MKQUERY_ADDW(id);
   MKQUERY_ADDB(0x01); /* QR=Q(0), OPCODE=QUERY(0000), !AA, !TC, RD */
   MKQUERY_ADDB(0x00); /* !RA, Z=000, RCODE=NOERROR(0000) */
@@ -33,7 +36,7 @@ adns_status adns__mkquery(adns_state ads, const char *owner, int ol, int 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');
@@ -45,10 +48,10 @@ adns_status adns__mkquery(adns_state ads, const char *owner, int ol, int id,
 	  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;
 	}
       }
@@ -58,132 +61,155 @@ adns_status adns__mkquery(adns_state ads, const char *owner, int ol, int id,
     if (!ll) return adns_s_invaliddomain;
     if (nlabs++ > 63) return adns_s_invaliddomain;
     MKQUERY_ADDB(ll);
-    memcpy(nqbuf,label,ll); nqbuf+= ll;
+    memcpy(rqp,label,ll); rqp+= ll;
   } 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 */
 
-  *qml_r= nqbuf - ads->qbuf;
+  ads->rqbuf.used= rqp - ads->rqbuf.buf;
+  assert(ads->rqbuf.used <= ads->rqbuf.avail);
   
   return adns_s_ok;
 }
 
-static void quproc_tosend_tcp(adns_state ads, adns_query qu, struct timeval now) {
-  unsigned char length[2];
+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),
+   *  tcpsent/timew, child/childw or done/output.)
+   *
+   * adns__tcp_tryconnect should already have been called - _tcp
+   * will only use an existing connection (if there is one), which it
+   * may break.  If the conn list lost then the caller is responsible for any
+   * reestablishment and retry.
+   */
+  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);
   
-  adns__tcp_tryconnect(ads);
-  /* fixme: try sending queries as soon as server comes up */
-  /* fixme: use vbuf_ensure, and preallocate buffer space */
-  if (ads->tcpstate != server_ok) return;
+  if (!adns__vbuf_ensure(&ads->tcpsend,ads->tcpsend.used+qu->querylen+2)) return;
 
-  DLIST_UNLINK(ads->tosend,qu);
   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) {
-    r= 0;
+  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;
-    r= writev(ads->tcpsocket,iov,2);
-    if (r < 0) {
+    wr= writev(ads->tcpsocket,iov,2);
+    if (wr < 0) {
       if (!(errno == EAGAIN || errno == EINTR || errno == ENOSPC ||
 	    errno == ENOBUFS || errno == ENOMEM)) {
 	adns__tcp_broken(ads,"write",strerror(errno));
 	return;
       }
-      r= 0;
+      wr= 0;
     }
   }
-  
-  if (r < qu->querylen+2) {
-    newopbufused= qu->opbufused + qu->querylen + 2 - r;
-    if (newopbufused > ads->opbufavail) {
-      newopbufavail= ads->newopbufused<<1;
-      newopbuf= realloc(newopbufavail);
-      if (!newopbuf) {
-	DLIST_UNLINK(ads->timew,qu);
-	query_fail(ads,qu,adns_s_nolocalmem);
-	return;
-      }
-      ads->opbuf= newopbuf;
-      ads->opbufavail= newopbufavail;
-    }
-    if (r<2) {
-      memcpy(ads->opbuf+ads->opbufused,length+r,2-r);
-      ads->opbufused += (2-r);
-      r= 0;
-    } else {
-      r -= 2;
-    }
-    memcpy(ads->opbuf+ads->opbufused,qu->querymsg+r,qu->querylen-r);
-    ads->opbufused= newopbufused;
+
+  if (wr<2) {
+    r= adns__vbuf_append(&ads->tcpsend,length,2-wr); assert(r);
+    wr= 0;
+  } else {
+    wr-= 2;
   }
+  if (wr<qu->querylen) {
+    r= adns__vbuf_append(&ads->tcpsend,qu->querymsg+wr,qu->querylen-wr); assert(r);
+  }
+}
+
+static void query_usetcp(adns_state ads, adns_query qu, struct timeval now) {
+  timevaladd(&now,TCPMS);
+  qu->timeout= now;
+  qu->state= query_tcpwait;
+  LIST_LINK_TAIL(ads->timew,qu);
+  adns__query_tcp(ads,qu,now);
+  adns__tcp_tryconnect(ads,now);
 }
 
-void adns__quproc_tosend(adns_state ads, adns_query qu, struct timeval now) {
-  /* Query must be on the `tosend' queue, and we guarantee to remove it.
+void adns__query_udp(adns_state ads, adns_query qu, struct timeval now) {
+  /* Query must be in state udp/NONE; it will be moved to a new state,
+   * and no further processing can be done on it for now.
+   * (Resulting state is one of udp/timew, tcpwait/timew (if server not connected),
+   *  tcpsent/timew, child/childw or done/output.)
    */
   struct sockaddr_in servaddr;
-  int serv;
+  int serv, r;
 
-  if (qu->nextudpserver == -1) { quproc_tosend_tcp(ads,qu,now); return; }
-  if (qu->querylen > UDPMAXDGRAM) {
-    qu->nextudpserver= -1;
-    quproc_tosend_tcp(ads,qu,now);
+  assert(qu->state == query_udp);
+  if ((qu->flags & adns_qf_usevc) || (qu->querylen > DNS_MAXUDP)) {
+    query_usetcp(ads,qu,now);
     return;
   }
-  
+
   if (qu->udpretries >= UDPMAXRETRIES) {
-    DLIST_UNLINK(ads->tosend,qu);
-    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) {
-    qu->nextudpserver= -1;
-    quproc_tosend_tcp(ads,qu,now); return;
-  }
-  if (r<0) warn("sendto %s failed: %s",inet_ntoa(servaddr.sin_addr),strerror(errno));
+  if (r<0 && errno == EMSGSIZE) { query_usetcp(ads,qu,now); return; }
+  if (r<0) adns__warn(ads,serv,"sendto failed: %s",strerror(errno));
   
-  DLIST_UNLINK(ads->tosend,qu);
   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);
+}