X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=adns.git;a=blobdiff_plain;f=src%2Fquery.c;h=2b21da473dd2a6f404067112fbc79cfae5b72413;hp=81acb6181ec2617c0b1d3e3d0495880a9e3ea158;hb=b9de380c1e587b6c5828cb9de796746024946880;hpb=8402e34c7df0adad223cf1fa1328bb524a15d99f

diff --git a/src/query.c b/src/query.c
index 81acb61..2b21da4 100644
--- a/src/query.c
+++ b/src/query.c
@@ -1,24 +1,26 @@
 /**/
 
-#include "adns-internal.h"
+#include <errno.h>
+#include <string.h>
 
-static adns_status 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;
+#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) {
+  /* 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,DNSHDRSIZE+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 +35,7 @@ static adns_status 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,8 +47,8 @@ static adns_status mkquery(adns_state ads, const char *owner, int ol, int id,
 	  return adns_s_invaliddomain;
 	}
       }
-      if (!(flags & adns_f_anyquote)) {
-	if ((c >= '0' && c <= '9') || c == '-') {
+      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')) {
 	  return adns_s_invaliddomain;
@@ -58,104 +60,141 @@ static adns_status 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(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;
 }
 
-void adns__quproc_tosend(adns_state ads, adns_query qu, struct timeval now) {
-  /* Query must be on the `tosend' queue, and guarantees to remove it.
-   * fixme: Do not send more than 512-byte udp datagrams
+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.
    */
-  struct sockaddr_in servaddr;
-  int serv;
+  byte length[2];
+  struct iovec iov[2];
+  int wr, r;
 
-  if (qu->nextudpserver != -1) {
-    if (qu->udpretries >= UDPMAXRETRIES) {
-      DLIST_UNLINK(ads->tosend,qu);
-      query_fail(ads,qu,adns_s_notresponding);
-      return;
-    }
-    serv= qu->nextudpserver;
-    memset(&servaddr,0,sizeof(servaddr));
-    servaddr.sin_family= AF_INET;
-    servaddr.sin_addr= ads->servers[serv].addr;
-    servaddr.sin_port= htons(NSPORT);
-    r= sendto(ads->udpsocket,qu->querymsg,qu->querylen,0,&servaddr,sizeof(servaddr));
-    if (r<0 && errno == EMSGSIZE) {
-      qu->nextudpserver= -1;
-    } else {
-      if (r<0) {
-	warn("sendto %s failed: %s",inet_ntoa(servaddr.sin_addr),strerror(errno));
+  if (ads->tcpstate != server_ok) return;
+
+  length[0]= (qu->querylen&0x0ff00U) >>8;
+  length[1]= (qu->querylen&0x0ff);
+  
+  if (!adns__vbuf_ensure(&ads->tcpsend,ads->tcpsend.used+qu->querylen+2)) return;
+
+  timevaladd(&now,TCPMS);
+  qu->timeout= now;
+  qu->state= query_tcpsent;
+  LIST_LINK_TAIL(ads->timew,qu);
+
+  if (ads->tcpsend.used) {
+    wr= 0;
+  } else {
+    iov[0].iov_base= length;
+    iov[0].iov_len= 2;
+    iov[1].iov_base= qu->querymsg;
+    iov[1].iov_len= qu->querylen;
+    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;
       }
-      DLIST_UNLINK(ads->tosend,qu);
-      timevaladd(&now,UDPRETRYMS);
-      qu->timeout= now;
-      qu->sentudp |= (1<<serv);
-      qu->nextudpserver= (serv+1)%ads->nservers;
-      qu->udpretries++;
-      DLIST_LINKTAIL(ads->timew,qu);
-      return;
+      wr= 0;
     }
   }
 
-  /* fixme: TCP queries preceded by length */
-  for (;;) {
-    adns__tcp_tryconnect(ads);
-    /* fixme: make this work properly */
-    serv= tcpserver_get(ads);
-    if (serv<0) { r=0; break; }
-    if (ads->opbufused) { r=0; break; }
-    r= write(ads->tcpsocket,qu->querymsg,qu->querylen);
-    if (r >= 0) break;
-    if (errno == EAGAIN || errno == EINTR || errno == ENOSPC ||
-	errno == ENOBUFS || errno == ENOMEM) {
-      r= 0; break;
-    }
-    tcpserver_broken(serv);
+  if (wr<2) {
+    r= adns__vbuf_append(&ads->tcpsend,length,2-wr); assert(r);
+    wr= 0;
+  } else {
+    wr-= 2;
   }
-  if (r < qu->querylen) {
-    newopbufused= qu->opbufused + (qu->querylen-r);
-    if (newopbufused > ads->opbufavail) {
-      newopbufavail= ads->newopbufused<<1;
-      newopbuf= realloc(newopbufavail);
-      if (!newopbuf) {
-	DLIST_UNLINK(ads->tosend,qu);
-	query_fail(ads,qu,adns_s_nolocalmem);
-	return;
-      }
-      ads->opbuf= newopbuf;
-      ads->opbufavail= newopbufavail;
-    }
-    memcpy(ads->opbuf+ads->opbufused,qu->querymsg+r,qu->querylen-r);
-    ads->opbufused= newopbufused;
+  if (wr<qu->querylen) {
+    r= adns__vbuf_append(&ads->tcpsend,qu->querymsg+wr,qu->querylen-wr); assert(r);
   }
-  DLIST_UNLINK(ads->tosend,qu);
+}
+
+static void query_usetcp(adns_state ads, adns_query qu, struct timeval now) {
   timevaladd(&now,TCPMS);
   qu->timeout= now;
-  qu->senttcp |= (1<<qu->nextserver);
-  DLIST_LINKTAIL(ads->timew,qu);
+  qu->state= query_tcpwait;
+  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) {
+  /* 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, r;
+
+  assert(qu->state == query_udp);
+  if ((qu->flags & adns_qf_usevc) || (qu->querylen > MAXUDPDGRAM)) {
+    query_usetcp(ads,qu,now);
+    return;
+  }
+
+  if (qu->udpretries >= MAXUDPRETRIES) {
+    adns__query_fail(ads,qu,adns_s_timeout);
+    return;
+  }
+
+  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);
+  
+  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) adns__warn(ads,serv,"sendto failed: %s",strerror(errno));
+  
+  timevaladd(&now,UDPRETRYMS);
+  qu->timeout= now;
+  qu->udpsent |= (1<<serv);
+  qu->udpnextserver= (serv+1)%ads->nservers;
+  qu->udpretries++;
+  LIST_LINK_TAIL(ads->timew,qu);
+}
+
+void adns__query_nomem(adns_state ads, adns_query qu) {
+  qu->answer.used= 0;
+  qu->id= -1;
+  LIST_LINK_TAIL(ads->output,qu);
 }
 
 void adns__query_fail(adns_state ads, adns_query qu, adns_status stat) {
   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;
+
+  if (!adns__vbuf_ensure(&qu->answer,sizeof(adns_answer))) {
+    adns__query_nomem(ads,qu);
+    return;
   }
-  qu->answer= ans;
+  ans= (adns_answer*)qu->answer.buf;
+  ans->status= stat;
+  ans->cname= 0;
+  ans->type= qu->type;
+  ans->nrrs= 0;
+  qu->answer.used= sizeof(adns_answer);
   qu->id= -1;
   LIST_LINK_TAIL(ads->output,qu);
 }