src/adns.c

   1 /**/
   2
   3 #include <stdarg.h>
   4 #include <stdio.h>
   5 #include <errno.h>
   6 #include <string.h>
   7 #include <stdlib.h>
   8 #include <assert.h>
   9
  10 #include <arpa/nameser.h>
  11 #include <sys/socket.h>
  12 #include <netinet/in.h>
  13 #include <arpa/inet.h>
  14
  15 #include "adns-internal.h"
  16
  17 #define LIST_UNLINK(list,node) \
  18   do { \
  19     if ((node)->back) (node)->back->next= (node)->next; \
  20       else                   (list).head= (node)->next; \
  21     if ((node)->next) (node)->next->back= (node)->back; \
  22       else                   (list).tail= (node)->back; \
  23   } while(0)
  24
  25 #define LIST_LINK_TAIL(list,node) \
  26   do { \
  27     (node)->back= 0; \
  28     (node)->next= (list).tail; \
  29     if ((list).tail) (list).tail->back= (node); else (list).head= (node); \
  30     (list).tail= (node); \
  31   } while(0)
  32
  33 static void vdebug(adns_state ads, const char *fmt, va_list al) {
  34   if (!(ads->iflags & adns_if_debug)) return;
  35   fputs("adns debug: ",stderr);
  36   vfprintf(stderr,fmt,al);
  37   fputc('\n',stderr);
  38 }
  39
  40 static void debug(adns_state ads, const char *fmt, ...) {
  41   va_list al;
  42
  43   va_start(al,fmt);
  44   vdebug(ads,fmt,al);
  45   va_end(al);
  46 }
  47
  48 static void vdiag(adns_state ads, const char *fmt, va_list al) {
  49   if (ads->iflags & adns_if_noerrprint) return;
  50   fputs("adns: ",stderr);
  51   vfprintf(stderr,fmt,al);
  52   fputc('\n',stderr);
  53 }
  54
  55 static void diag(adns_state ads, const char *fmt, ...) {
  56   va_list al;
  57
  58   va_start(al,fmt);
  59   vdiag(ads,fmt,al);
  60   va_end(al);
  61 }
  62
  63 static void addserver(adns_state ads, struct in_addr addr) {
  64   int i;
  65
  66   for (i=0; i<ads->nservers; i++) {
  67     if (ads->servers[i].addr.s_addr == addr.s_addr) {
  68       debug(ads,"duplicate nameserver %s ignored",inet_ntoa(addr));
  69       return;
  70     }
  71   }
  72
  73   if (ads->nservers>=MAXSERVERS) {
  74     diag(ads,"too many nameservers, ignoring %s",inet_ntoa(addr));
  75     return;
  76   }
  77
  78   ads->servers[ads->nservers].addr= addr;
  79   ads->servers[ads->nservers].tcpsocket= -1;
  80   ads->nservers++;
  81 }
  82
  83 static void configparseerr(adns_state ads, const char *fn, int lno,
  84                            const char *fmt, ...) {
  85   va_list al;
  86
  87   if (ads->iflags & adns_if_noerrprint) return;
  88   if (lno==-1) fprintf(stderr,"adns: %s: ",fn);
  89   else fprintf(stderr,"adns: %s:%d: ",fn,lno);
  90   va_start(al,fmt);
  91   vfprintf(stderr,fmt,al);
  92   va_end(al);
  93   fputc('\n',stderr);
  94 }
  95
  96 static void ccf_nameserver(adns_state ads, const char *fn, int lno, const char *buf) {
  97   struct in_addr ia;
  98
  99   if (!inet_aton(buf,&ia)) {
 100     configparseerr(ads,fn,lno,"invalid nameserver address `%s'",buf);
 101     return;
 102   }
 103   debug(ads,"using nameserver %s",inet_ntoa(ia));
 104   addserver(ads,ia);
 105 }
 106
 107 static void ccf_search(adns_state ads, const char *fn, int lno, const char *buf) {
 108   if (!buf) return;
 109   diag(ads,"warning - `search' ignored FIXME");
 110 }
 111
 112 static void ccf_sortlist(adns_state ads, const char *fn, int lno, const char *buf) {
 113   diag(ads,"warning - `sortlist' ignored FIXME");
 114 }
 115
 116 static void ccf_options(adns_state ads, const char *fn, int lno, const char *buf) {
 117   if (!buf) return;
 118   diag(ads,"warning - `options' ignored FIXME");
 119 }
 120
 121 static void ccf_clearnss(adns_state ads, const char *fn, int lno, const char *buf) {
 122   ads->nservers= 0;
 123 }
 124
 125 static const struct configcommandinfo {
 126   const char *name;
 127   void (*fn)(adns_state ads, const char *fn, int lno, const char *buf);
 128 } configcommandinfos[]= {
 129   { "nameserver",        ccf_nameserver  },
 130   { "domain",            ccf_search      },
 131   { "search",            ccf_search      },
 132   { "sortlist",          ccf_sortlist    },
 133   { "options",           ccf_options     },
 134   { "clearnameservers",  ccf_clearnss    },
 135   {  0                                   }
 136 };
 137
 138 static int whitespace(int c) {
 139   return c==' ' || c=='\n' || c=='\t';
 140 }
 141
 142 static void readconfig(adns_state ads, const char *filename) {
 143   char linebuf[2000], *p, *q;
 144   FILE *file;
 145   int lno, l, c;
 146   const struct configcommandinfo *ccip;
 147
 148   file= fopen(filename,"r");
 149   if (!file) {
 150     if (errno == ENOENT) {
 151       debug(ads,"configuration file `%s' does not exist",filename);
 152       return;
 153     }
 154     diag(ads,"cannot open configuration file `%s': %s",filename,strerror(errno));
 155     return;
 156   }
 157
 158   for (lno=1; fgets(linebuf,sizeof(linebuf),file); lno++) {
 159     l= strlen(linebuf);
 160     if (!l) continue;
 161     if (linebuf[l-1] != '\n' && !feof(file)) {
 162       diag(ads,"%s:%d: line too long",filename,lno);
 163       while ((c= getc(file)) != EOF && c != '\n') { }
 164       if (c == EOF) break;
 165       continue;
 166     }
 167     while (l>0 && whitespace(linebuf[l-1])) l--;
 168     linebuf[l]= 0;
 169     p= linebuf;
 170     while (whitespace(*p)) p++;
 171     if (*p == '#' || *p == '\n') continue;
 172     q= p;
 173     while (*q && !whitespace(*q)) q++;
 174     for (ccip=configcommandinfos;
 175          ccip->name && strncmp(ccip->name,p,q-p);
 176          ccip++);
 177     if (!ccip->name) {
 178       diag(ads,"%s:%d: unknown configuration directive `%.*s'",filename,lno,q-p,p);
 179       continue;
 180     }
 181     while (whitespace(*q)) q++;
 182     ccip->fn(ads,filename,lno,q);
 183   }
 184   if (ferror(file)) {
 185     diag(ads,"%s:%d: read error: %s",filename,lno,strerror(errno));
 186   }
 187   fclose(file);
 188 }
 189
 190 static const char *instrum_getenv(adns_state ads, const char *envvar) {
 191   const char *value;
 192
 193   value= getenv(envvar);
 194   if (!value) debug(ads,"environment variable %s not set",envvar);
 195   else debug(ads,"environment variable %s set to `%s'",envvar,value);
 196   return value;
 197 }
 198
 199 static void readconfigenv(adns_state ads, const char *envvar) {
 200   const char *filename;
 201
 202   if (ads->iflags & adns_if_noenv) {
 203     debug(ads,"not checking environment variable `%s'",envvar);
 204     return;
 205   }
 206   filename= instrum_getenv(ads,envvar);
 207   if (filename) readconfig(ads,filename);
 208 }
 209
 210 int adns_init(adns_state *ads_r, adns_initflags flags) {
 211   adns_state ads;
 212   const char *res_options, *adns_res_options;
 213
 214   ads= malloc(sizeof(*ads)); if (!ads) return errno;
 215   ads->input.head= ads->input.tail= 0;
 216   ads->timew.head= ads->timew.tail= 0;
 217   ads->childw.head= ads->childw.tail= 0;
 218   ads->output.head= ads->output.tail= 0;
 219   ads->udpsocket= -1;
 220   ads->qbufavail= 0;
 221   ads->qbuf= 0;
 222   ads->tcpbufavail= ads->tcpbufused= ads->tcpbufdone= 0;
 223   ads->tcpbuf= 0;
 224   ads->iflags= flags;
 225   ads->nservers= 0;
 226   ads->iflags= flags;
 227
 228   res_options= instrum_getenv(ads,"RES_OPTIONS");
 229   adns_res_options= instrum_getenv(ads,"ADNS_RES_OPTIONS");
 230   ccf_options(ads,"RES_OPTIONS",-1,res_options);
 231   ccf_options(ads,"ADNS_RES_OPTIONS",-1,adns_res_options);
 232
 233   readconfig(ads,"/etc/resolv.conf");
 234   readconfigenv(ads,"RES_CONF");
 235   readconfigenv(ads,"ADNS_RES_CONF");
 236
 237   ccf_options(ads,"RES_OPTIONS",-1,res_options);
 238   ccf_options(ads,"ADNS_RES_OPTIONS",-1,adns_res_options);
 239
 240   ccf_search(ads,"LOCALDOMAIN",-1,instrum_getenv(ads,"LOCALDOMAIN"));
 241   ccf_search(ads,"ADNS_LOCALDOMAIN",-1,instrum_getenv(ads,"ADNS_LOCALDOMAIN"));
 242
 243   if (!ads->nservers) {
 244     struct in_addr ia;
 245     if (ads->iflags & adns_if_debug)
 246       fprintf(stderr,"adns: no nameservers, using localhost\n");
 247     ia.s_addr= INADDR_LOOPBACK;
 248     addserver(ads,ia);
 249   }
 250
 251   *ads_r= ads;
 252   return 0;
 253 }
 254
 255 static void query_fail(adns_state ads, adns_query qu, adns_status stat) {
 256   adns_answer *ans;
 257
 258   ans= qu->answer;
 259   if (!ans) ans= malloc(sizeof(*qu->answer));
 260   if (ans) {
 261     ans->status= stat;
 262     ans->cname= 0;
 263     ans->type= qu->type;
 264     ans->nrrs= 0;
 265   }
 266   qu->answer= ans;
 267   LIST_LINK_TAIL(ads->input,qu);
 268 }
 269
 270 void adns_interest(adns_state ads, int *maxfd,
 271                    fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
 272                    struct timeval **tv_io, struct timeval *tvbuf) {
 273   abort(); /* FIXME */
 274 }
 275
 276 static void autosys(adns_state ads) {
 277   if (ads->iflags & adns_if_noautosys) return;
 278   adns_callback(ads,-1,0,0,0);
 279 }
 280
 281 void adns_cancel(adns_state ads, adns_query query) {
 282   abort(); /* FIXME */
 283 }
 284
 285 int adns_callback(adns_state ads, int maxfd,
 286                   const fd_set *readfds, const fd_set *writefds,
 287                   const fd_set *exceptfds) {
 288   abort(); /* FIXME */
 289 }
 290
 291 static int internal_check(adns_state ads,
 292                           adns_query *query_io,
 293                           adns_answer *answer,
 294                           void *context_r) {
 295   abort(); /* FIXME */
 296 }
 297
 298 int adns_wait(adns_state ads,
 299               adns_query *query_io,
 300               adns_answer *answer,
 301               void *context_r) {
 302   int r, maxfd, rsel, rcb;
 303   fd_set readfds, writefds, exceptfds;
 304   struct timeval tvbuf, *tvp;
 305
 306   for (;;) {
 307     r= internal_check(ads,query_io,answer,context_r);
 308     if (r && r != EWOULDBLOCK) return r;
 309     FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds);
 310     maxfd= 0; tvp= 0;
 311     adns_interest(ads,&maxfd,&readfds,&writefds,&exceptfds,&tvp,&tvbuf);
 312     rsel= select(maxfd,&readfds,&writefds,&exceptfds,tvp);
 313     if (rsel==-1) return r;
 314     rcb= adns_callback(ads,maxfd,&readfds,&writefds,&exceptfds);
 315     assert(rcb==rsel);
 316   }
 317 }
 318
 319 int adns_check(adns_state ads,
 320                adns_query *query_io,
 321                adns_answer *answer,
 322                void *context_r) {
 323   autosys(ads);
 324   return internal_check(ads,query_io,answer,context_r);
 325 }
 326
 327 int adns_synchronous(adns_state ads,
 328                      const char *owner,
 329                      adns_rrtype type,
 330                      int flags,
 331                      adns_answer *answer) {
 332   adns_query qu;
 333   int r;
 334
 335   r= adns_submit(ads,owner,type,flags,0,&qu);
 336   if (r) return r;
 337
 338   r= adns_wait(ads,&qu,answer,0);
 339   if (r) adns_cancel(ads,qu);
 340   return r;
 341 }
 342
 343 int adns_submit(adns_state ads,
 344                 const char *owner,
 345                 adns_rrtype type,
 346                 int flags,
 347                 void *context,
 348                 adns_query *query_r) {
 349   adns_query qu;
 350   adns_status stat;
 351   int ol;
 352
 353   stat= 0;
 354   ol= strlen(owner);
 355   if (ol>MAXDNAME+1) { stat= adns_s_invaliddomain; ol= 0; }
 356   if (ol>0 && owner[ol-1]=='.') { flags &= ~adns_f_search; ol--; }
 357   qu= malloc(sizeof(*qu)+ol+1); if (!qu) return errno;
 358   qu->next= qu->back= qu->parent= qu->child= 0;
 359   qu->type= type;
 360   qu->answer= 0;
 361   qu->flags= flags;
 362   qu->context= context;
 363   qu->udpretries= 0;
 364   qu->server= 0;
 365   memcpy(qu->owner,owner,ol); qu->owner[ol]= 0;
 366   if (stat) {
 367     query_fail(ads,qu,stat);
 368   } else {
 369     LIST_LINK_TAIL(ads->input,qu);
 370     autosys(ads);
 371   }
 372   *query_r= qu;
 373   return 0;
 374 }