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