mdw@git.distorted.org.uk Git - adns/blob - src/query.c

   1 /**/
   2
   3 #include <errno.h>
   4 #include <string.h>
   5
   6 #include <sys/uio.h>
   7
   8 #include "internal.h"
   9
  10 adns_status adns__mkquery(adns_state ads, const char *owner, int ol, int id,
  11                           adns_rrtype type, adns_queryflags flags) {
  12   /* Assembles a query packet in ads->rqbuf. */
  13   int ll, c, nlabs;
  14   byte label[255], *rqp;
  15   const char *p, *pe;
  16
  17 #define MKQUERY_ADDB(b) *rqp++= (b)
  18 #define MKQUERY_ADDW(w) (MKQUERY_ADDB(((w)>>8)&0x0ff), MKQUERY_ADDB((w)&0x0ff))
  19
  20   if (!adns__vbuf_ensure(&ads->rqbuf,12+strlen(owner)+1+5)) return adns_s_nolocalmem;
  21   rqp= ads->rqbuf.buf;
  22
  23   MKQUERY_ADDW(id);
  24   MKQUERY_ADDB(0x01); /* QR=Q(0), OPCODE=QUERY(0000), !AA, !TC, RD */
  25   MKQUERY_ADDB(0x00); /* !RA, Z=000, RCODE=NOERROR(0000) */
  26   MKQUERY_ADDW(1); /* QDCOUNT=1 */
  27   MKQUERY_ADDW(0); /* ANCOUNT=0 */
  28   MKQUERY_ADDW(0); /* NSCOUNT=0 */
  29   MKQUERY_ADDW(0); /* ARCOUNT=0 */
  30   p= owner; pe= owner+ol;
  31   nlabs= 0;
  32   if (!*p) return adns_s_invaliddomain;
  33   do {
  34     ll= 0;
  35     while (p!=pe && (c= *p++)!='.') {
  36       if (c=='\\') {
  37         if (!(flags & adns_qf_anyquote)) return adns_s_invaliddomain;
  38         if (ctype_digit(p[0])) {
  39           if (ctype_digit(p[1]) && ctype_digit(p[2])) {
  40             c= (*p++ - '0')*100 + (*p++ - '0')*10 + (*p++ - '0');
  41             if (c >= 256) return adns_s_invaliddomain;
  42           } else {
  43             return adns_s_invaliddomain;
  44           }
  45         } else if (!(c= *p++)) {
  46           return adns_s_invaliddomain;
  47         }
  48       }
  49       if (!(flags & adns_qf_anyquote)) {
  50         if (ctype_digit(c) || c == '-') {
  51           if (!ll) return adns_s_invaliddomain;
  52         } else if ((c < 'a' || c > 'z') && (c < 'A' && c > 'Z')) {
  53           return adns_s_invaliddomain;
  54         }
  55       }
  56       if (ll == sizeof(label)) return adns_s_invaliddomain;
  57       label[ll++]= c;
  58     }
  59     if (!ll) return adns_s_invaliddomain;
  60     if (nlabs++ > 63) return adns_s_invaliddomain;
  61     MKQUERY_ADDB(ll);
  62     memcpy(rqp,label,ll); rqp+= ll;
  63   } while (p!=pe);
  64
  65   MKQUERY_ADDB(0);
  66   MKQUERY_ADDW(type & adns__rrt_typemask); /* QTYPE */
  67   MKQUERY_ADDW(1); /* QCLASS=IN */
  68
  69   ads->rqbuf.used= rqp - ads->rqbuf.buf;
  70   assert(ads->rqbuf.used <= ads->rqbuf.avail);
  71
  72   return adns_s_ok;
  73 }
  74
  75 void adns__query_tcp(adns_state ads, adns_query qu, struct timeval now) {
  76   /* Query must be in state tcpwait/timew; it will be moved to a new state
  77    * if possible and no further processing can be done on it for now.
  78    * (Resulting state is one of tcpwait/timew (if server not connected),
  79    *  tcpsent/timew, child/childw or done/output.)
  80    *
  81    * adns__tcp_tryconnect should already have been called - _tcp
  82    * will only use an existing connection (if there is one), which it
  83    * may break.  If the conn list lost then the caller is responsible for any
  84    * reestablishment and retry.
  85    */
  86   byte length[2];
  87   struct iovec iov[2];
  88   int wr, r;
  89
  90   if (ads->tcpstate != server_ok) return;
  91
  92   length[0]= (qu->querylen&0x0ff00U) >>8;
  93   length[1]= (qu->querylen&0x0ff);
  94
  95   if (!adns__vbuf_ensure(&ads->tcpsend,ads->tcpsend.used+qu->querylen+2)) return;
  96
  97   timevaladd(&now,TCPMS);
  98   qu->timeout= now;
  99   qu->state= query_tcpsent;
 100   LIST_LINK_TAIL(ads->timew,qu);
 101
 102   if (ads->tcpsend.used) {
 103     wr= 0;
 104   } else {
 105     iov[0].iov_base= length;
 106     iov[0].iov_len= 2;
 107     iov[1].iov_base= qu->querymsg;
 108     iov[1].iov_len= qu->querylen;
 109     wr= writev(ads->tcpsocket,iov,2);
 110     if (wr < 0) {
 111       if (!(errno == EAGAIN || errno == EINTR || errno == ENOSPC ||
 112             errno == ENOBUFS || errno == ENOMEM)) {
 113         adns__tcp_broken(ads,"write",strerror(errno));
 114         return;
 115       }
 116       wr= 0;
 117     }
 118   }
 119
 120   if (wr<2) {
 121     r= adns__vbuf_append(&ads->tcpsend,length,2-wr); assert(r);
 122     wr= 0;
 123   } else {
 124     wr-= 2;
 125   }
 126   if (wr<qu->querylen) {
 127     r= adns__vbuf_append(&ads->tcpsend,qu->querymsg+wr,qu->querylen-wr); assert(r);
 128   }
 129 }
 130
 131 static void query_usetcp(adns_state ads, adns_query qu, struct timeval now) {
 132   timevaladd(&now,TCPMS);
 133   qu->timeout= now;
 134   qu->state= query_tcpwait;
 135   LIST_LINK_TAIL(ads->timew,qu);
 136   adns__query_tcp(ads,qu,now);
 137   adns__tcp_tryconnect(ads,now);
 138 }
 139
 140 void adns__query_udp(adns_state ads, adns_query qu, struct timeval now) {
 141   /* Query must be in state udp/NONE; it will be moved to a new state,
 142    * and no further processing can be done on it for now.
 143    * (Resulting state is one of udp/timew, tcpwait/timew (if server not connected),
 144    *  tcpsent/timew, child/childw or done/output.)
 145    */
 146   struct sockaddr_in servaddr;
 147   int serv, r;
 148
 149   assert(qu->state == query_udp);
 150   if ((qu->flags & adns_qf_usevc) || (qu->querylen > MAXUDPDGRAM)) {
 151     query_usetcp(ads,qu,now);
 152     return;
 153   }
 154
 155   if (qu->udpretries >= MAXUDPRETRIES) {
 156     adns__query_fail(ads,qu,adns_s_timeout);
 157     return;
 158   }
 159
 160   serv= qu->udpnextserver;
 161   memset(&servaddr,0,sizeof(servaddr));
 162   servaddr.sin_family= AF_INET;
 163   servaddr.sin_addr= ads->servers[serv].addr;
 164   servaddr.sin_port= htons(NSPORT);
 165
 166   r= sendto(ads->udpsocket,qu->querymsg,qu->querylen,0,&servaddr,sizeof(servaddr));
 167   if (r<0 && errno == EMSGSIZE) { query_usetcp(ads,qu,now); return; }
 168   if (r<0) adns__warn(ads,serv,"sendto failed: %s",strerror(errno));
 169
 170   timevaladd(&now,UDPRETRYMS);
 171   qu->timeout= now;
 172   qu->udpsent |= (1<<serv);
 173   qu->udpnextserver= (serv+1)%ads->nservers;
 174   qu->udpretries++;
 175   LIST_LINK_TAIL(ads->timew,qu);
 176 }
 177
 178 void adns__query_nomem(adns_state ads, adns_query qu) {
 179   qu->answer.used= 0;
 180   qu->id= -1;
 181   LIST_LINK_TAIL(ads->output,qu);
 182 }
 183
 184 void adns__query_fail(adns_state ads, adns_query qu, adns_status stat) {
 185   adns_answer *ans;
 186
 187   if (!adns__vbuf_ensure(&qu->answer,sizeof(adns_answer))) {
 188     adns__query_nomem(ads,qu);
 189     return;
 190   }
 191   ans= (adns_answer*)qu->answer.buf;
 192   ans->status= stat;
 193   ans->cname= 0;
 194   ans->type= qu->type;
 195   ans->nrrs= 0;
 196   qu->answer.used= sizeof(adns_answer);
 197   qu->id= -1;
 198   LIST_LINK_TAIL(ads->output,qu);
 199 }