src/query.c

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