src/setup.c

   1 /*
   2  * setup.c
   3  * - configuration file parsing
   4  * - management of global state
   5  */
   6 /*
   7  *  This file is part of adns, which is Copyright Ian Jackson
   8  *  and contributors (see the file INSTALL for full details).
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 3, or (at your option)
  13  *  any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software Foundation.
  22  */
  23
  24 #include <stdlib.h>
  25 #include <errno.h>
  26 #include <limits.h>
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29
  30 #include <sys/types.h>
  31 #include <netdb.h>
  32 #include <sys/socket.h>
  33 #include <netinet/in.h>
  34 #include <arpa/inet.h>
  35
  36 #include "internal.h"
  37
  38 static void readconfig(adns_state ads, const char *filename, int warnmissing);
  39
  40 static void addserver(adns_state ads, const struct sockaddr *sa, int salen) {
  41   int i;
  42   adns_rr_addr *ss;
  43   char buf[ADNS_ADDR2TEXT_BUFLEN];
  44
  45   for (i=0; i<ads->nservers; i++) {
  46     if (adns__sockaddrs_equal(sa, &ads->servers[i].addr.sa)) {
  47       adns__debug(ads,-1,0,"duplicate nameserver %s ignored",
  48                   adns__sockaddr_ntoa(sa, buf));
  49       return;
  50     }
  51   }
  52
  53   if (ads->nservers>=MAXSERVERS) {
  54     adns__diag(ads,-1,0,"too many nameservers, ignoring %s",
  55                adns__sockaddr_ntoa(sa, buf));
  56     return;
  57   }
  58
  59   ss= ads->servers+ads->nservers;
  60   assert(salen <= sizeof(ss->addr));
  61   ss->len = salen;
  62   memcpy(&ss->addr, sa, salen);
  63   ads->nservers++;
  64 }
  65
  66 static void freesearchlist(adns_state ads) {
  67   if (ads->nsearchlist) free(*ads->searchlist);
  68   free(ads->searchlist);
  69 }
  70
  71 static void saveerr(adns_state ads, int en) {
  72   if (!ads->configerrno) ads->configerrno= en;
  73 }
  74
  75 static void configparseerr(adns_state ads, const char *fn, int lno,
  76                            const char *fmt, ...) {
  77   va_list al;
  78
  79   saveerr(ads,EINVAL);
  80   if (!ads->logfn || (ads->iflags & adns_if_noerrprint)) return;
  81
  82   if (lno==-1) adns__lprintf(ads,"adns: %s: ",fn);
  83   else adns__lprintf(ads,"adns: %s:%d: ",fn,lno);
  84   va_start(al,fmt);
  85   adns__vlprintf(ads,fmt,al);
  86   va_end(al);
  87   adns__lprintf(ads,"\n");
  88 }
  89
  90 static int nextword(const char **bufp_io, const char **word_r, int *l_r) {
  91   const char *p, *q;
  92
  93   p= *bufp_io;
  94   while (ctype_whitespace(*p)) p++;
  95   if (!*p) return 0;
  96
  97   q= p;
  98   while (*q && !ctype_whitespace(*q)) q++;
  99
 100   *l_r= q-p;
 101   *word_r= p;
 102   *bufp_io= q;
 103
 104   return 1;
 105 }
 106
 107 static void ccf_nameserver(adns_state ads, const char *fn,
 108                            int lno, const char *buf) {
 109   adns_rr_addr a;
 110   char addrbuf[ADNS_ADDR2TEXT_BUFLEN];
 111   int err;
 112   socklen_t salen;
 113
 114   salen= sizeof(a.addr);
 115   err= adns_text2addr(buf,DNS_PORT, 0, &a.addr.sa,&salen);
 116   a.len= salen;
 117   switch (err) {
 118   case 0:
 119     break;
 120   case EINVAL:
 121     configparseerr(ads,fn,lno,"invalid nameserver address `%s'",buf);
 122     return;
 123   default:
 124     configparseerr(ads,fn,lno,"failed to parse nameserver address `%s': %s",
 125                    buf,strerror(err));
 126     return;
 127   }
 128   adns__debug(ads,-1,0,"using nameserver %s",
 129               adns__sockaddr_ntoa(&a.addr.sa, addrbuf));
 130   addserver(ads,&a.addr.sa,salen);
 131 }
 132
 133 static void ccf_search(adns_state ads, const char *fn,
 134                        int lno, const char *buf) {
 135   const char *bufp, *word;
 136   char *newchars, **newptrs, **pp;
 137   int count, tl, l;
 138
 139   if (!buf) return;
 140
 141   bufp= buf;
 142   count= 0;
 143   tl= 0;
 144   while (nextword(&bufp,&word,&l)) { count++; tl += l+1; }
 145
 146   if (count) {
 147     newptrs= malloc(sizeof(char*)*count);
 148     if (!newptrs) { saveerr(ads,errno); return; }
 149
 150     newchars= malloc(tl);
 151     if (!newchars) { saveerr(ads,errno); free(newptrs); return; }
 152   } else {
 153     assert(!tl);
 154     newptrs= 0;
 155     newchars= 0;
 156   }
 157
 158   bufp= buf;
 159   pp= newptrs;
 160   while (nextword(&bufp,&word,&l)) {
 161     *pp++= newchars;
 162     memcpy(newchars,word,l);
 163     newchars += l;
 164     *newchars++ = 0;
 165   }
 166
 167   freesearchlist(ads);
 168   ads->nsearchlist= count;
 169   ads->searchlist= newptrs;
 170 }
 171
 172 static int gen_pton(const char *text, int want_af, adns_sockaddr *a) {
 173   int err;
 174   socklen_t len;
 175
 176   len= sizeof(*a);
 177   err= adns_text2addr(text,0, adns_qf_addrlit_scope_forbid,
 178                       &a->sa, &len);
 179   if (err) { assert(err == EINVAL); return 0; }
 180   if (want_af != AF_UNSPEC && a->sa.sa_family != want_af) return 0;
 181   return 1;
 182 }
 183
 184 static void ccf_sortlist(adns_state ads, const char *fn,
 185                          int lno, const char *buf) {
 186   const char *word;
 187   char tbuf[200], *slash, *ep;
 188   const char *maskwhat;
 189   struct sortlist *sl;
 190   int l;
 191   int initial= -1;
 192
 193   if (!buf) return;
 194
 195   ads->nsortlist= 0;
 196   while (nextword(&buf,&word,&l)) {
 197     if (ads->nsortlist >= MAXSORTLIST) {
 198       adns__diag(ads,-1,0,"too many sortlist entries,"
 199                  " ignoring %.*s onwards",l,word);
 200       return;
 201     }
 202
 203     if (l >= sizeof(tbuf)) {
 204       configparseerr(ads,fn,lno,"sortlist entry `%.*s' too long",l,word);
 205       continue;
 206     }
 207
 208     memcpy(tbuf,word,l); tbuf[l]= 0;
 209     slash= strchr(tbuf,'/');
 210     if (slash) *slash++= 0;
 211
 212     sl= &ads->sortlist[ads->nsortlist];
 213     if (!gen_pton(tbuf, AF_UNSPEC, &sl->base)) {
 214       configparseerr(ads,fn,lno,"invalid address `%s' in sortlist",tbuf);
 215       continue;
 216     }
 217
 218     if (slash) {
 219       if (slash[strspn(slash, "0123456789")]) {
 220         maskwhat = "mask";
 221         if (!gen_pton(slash, sl->base.sa.sa_family, &sl->mask)) {
 222           configparseerr(ads,fn,lno,"invalid mask `%s' in sortlist",slash);
 223           continue;
 224         }
 225       } else {
 226         maskwhat = "prefix length";
 227         unsigned long prefixlen = strtoul(slash,&ep,10);
 228         if (*ep || prefixlen>adns__addr_width(sl->base.sa.sa_family)) {
 229           configparseerr(ads,fn,lno,"mask length `%s' invalid",slash);
 230           continue;
 231         }
 232         initial= prefixlen;
 233         sl->mask.sa.sa_family= sl->base.sa.sa_family;
 234         adns__prefix_mask(&sl->mask, initial);
 235       }
 236     } else {
 237       maskwhat = "implied prefix length";
 238       initial= adns__guess_prefix_length(&sl->base);
 239       if (initial < 0) {
 240         configparseerr(ads,fn,lno, "network address `%s'"
 241                        " in sortlist is not in classed ranges,"
 242                        " must specify mask explicitly", tbuf);
 243         continue;
 244       }
 245       sl->mask.sa.sa_family= sl->base.sa.sa_family;
 246       adns__prefix_mask(&sl->mask, initial);
 247     }
 248
 249     if (!adns__addr_matches(sl->base.sa.sa_family,
 250                             adns__sockaddr_addr(&sl->base.sa),
 251                             &sl->base,&sl->mask)) {
 252       if (initial >= 0) {
 253         configparseerr(ads,fn,lno, "%s %d in sortlist"
 254                        " overlaps address `%s'",maskwhat,initial,tbuf);
 255       } else {
 256         configparseerr(ads,fn,lno, "%s `%s' in sortlist"
 257                        " overlaps address `%s'",maskwhat,slash,tbuf);
 258       }
 259       continue;
 260     }
 261
 262     ads->nsortlist++;
 263   }
 264 }
 265
 266 static void ccf_options(adns_state ads, const char *fn,
 267                         int lno, const char *buf) {
 268   const char *opt, *word, *endword, *endopt;
 269   char *ep;
 270   unsigned long v;
 271   int l;
 272
 273   if (!buf) return;
 274
 275 #define WORD__IS(s,op) ((endword-word) op (sizeof(s)-1) && \
 276                           !memcmp(word,s,(sizeof(s)-1)))
 277 #define WORD_IS(s)     (WORD__IS(s,==))
 278 #define WORD_STARTS(s) (WORD__IS(s,>=) ? ((word+=sizeof(s)-1)) : 0)
 279
 280   while (nextword(&buf,&word,&l)) {
 281     opt=word;
 282     endopt=endword=word+l;
 283     if (WORD_IS("debug")) {
 284       ads->iflags |= adns_if_debug;
 285       continue;
 286     }
 287     if (WORD_STARTS("ndots:")) {
 288       v= strtoul(word,&ep,10);
 289       if (ep==word || ep != endword || v > INT_MAX) {
 290         configparseerr(ads,fn,lno,"option `%.*s' malformed"
 291                        " or has bad value",l,opt);
 292         continue;
 293       }
 294       ads->searchndots= v;
 295       continue;
 296     }
 297     if (WORD_STARTS("adns_checkc:")) {
 298       if (WORD_IS("none")) {
 299         ads->iflags &= ~adns_if_checkc_freq;
 300         ads->iflags |= adns_if_checkc_entex;
 301       } else if (WORD_IS("entex")) {
 302         ads->iflags &= ~adns_if_checkc_freq;
 303         ads->iflags |= adns_if_checkc_entex;
 304       } else if (WORD_IS("freq")) {
 305         ads->iflags |= adns_if_checkc_freq;
 306       } else {
 307         configparseerr(ads,fn,lno, "option adns_checkc has bad value `%s' "
 308                        "(must be none, entex or freq", word);
 309       }
 310       continue;
 311     }
 312     if (WORD_STARTS("adns_af:")) {
 313       ads->iflags &= ~adns_if_afmask;
 314       if (!WORD_IS("any")) for (;;) {
 315         const char *comma= memchr(word,',',endopt-word);
 316         endword=comma?comma:endopt;
 317         if (WORD_IS("ipv4"))
 318           ads->iflags |= adns_if_permit_ipv4;
 319         else if (WORD_IS("ipv6"))
 320           ads->iflags |= adns_if_permit_ipv6;
 321         else {
 322           if (ads->config_report_unknown)
 323             adns__diag(ads,-1,0,"%s:%d: "
 324                        "option adns_af has bad value or entry `%.*s' "
 325                        "(option must be `any', or list of `ipv4',`ipv6')",
 326                        fn,lno, (int)(endword-word),word);
 327           break;
 328         }
 329         if (!comma) break;
 330         word= comma+1;
 331       }
 332       continue;
 333     }
 334     if (WORD_IS("adns_ignoreunkcfg")) {
 335       ads->config_report_unknown=0;
 336       continue;
 337     }
 338     if (/* adns's query strategy is not configurable */
 339         WORD_STARTS("timeout:") ||
 340         WORD_STARTS("attempts:") ||
 341         WORD_IS("rotate") ||
 342         /* adns provides the application with knob for this */
 343         WORD_IS("no-check-names") ||
 344         /* adns normally does IPv6 if the application wants it; control
 345          * this with the adns_af: option if you like */
 346         WORD_IS("inet6") ||
 347         /* adns trusts the resolver anyway */
 348         WORD_IS("trust-ad") ||
 349         /* adns does not do edns0 and this is not a problem */
 350         WORD_IS("edns0"))
 351       continue;
 352     if (ads->config_report_unknown)
 353       adns__diag(ads,-1,0,"%s:%d: unknown option `%.*s'", fn,lno, l,opt);
 354   }
 355
 356 #undef WORD__IS
 357 #undef WORD_IS
 358 #undef WORD_STARTS
 359 }
 360
 361 static void ccf_clearnss(adns_state ads, const char *fn,
 362                          int lno, const char *buf) {
 363   ads->nservers= 0;
 364 }
 365
 366 static void ccf_include(adns_state ads, const char *fn,
 367                         int lno, const char *buf) {
 368   if (!*buf) {
 369     configparseerr(ads,fn,lno,"`include' directive with no filename");
 370     return;
 371   }
 372   readconfig(ads,buf,1);
 373 }
 374
 375 static void ccf_lookup(adns_state ads, const char *fn, int lno,
 376                        const char *buf) {
 377   int found_bind=0;
 378   const char *word;
 379   int l;
 380
 381   if (!*buf) {
 382     configparseerr(ads,fn,lno,"`lookup' directive with no databases");
 383     return;
 384   }
 385
 386   while (nextword(&buf,&word,&l)) {
 387     if (l==4 && !memcmp(word,"bind",4)) {
 388       found_bind=1;
 389     } else if (l==4 && !memcmp(word,"file",4)) {
 390       /* ignore this and hope /etc/hosts is not essential */
 391     } else if (l==2 && !memcmp(word,"yp",2)) {
 392       adns__diag(ads,-1,0,"%s:%d: yp lookups not supported by adns", fn,lno);
 393       found_bind=-1;
 394     } else {
 395       if (ads->config_report_unknown)
 396         adns__diag(ads,-1,0,"%s:%d: unknown `lookup' database `%.*s'",
 397                    fn,lno, l,word);
 398       found_bind=-1;
 399     }
 400   }
 401   if (!found_bind)
 402     adns__diag(ads,-1,0,"%s:%d: `lookup' specified, but not `bind'", fn,lno);
 403 }
 404
 405 static void ccf_ignore(adns_state ads, const char *fn, int lno,
 406                        const char *buf) {
 407 }
 408
 409 static const struct configcommandinfo {
 410   const char *name;
 411   void (*fn)(adns_state ads, const char *fn, int lno, const char *buf);
 412 } configcommandinfos[]= {
 413   { "nameserver",        ccf_nameserver  },
 414   { "domain",            ccf_search      },
 415   { "search",            ccf_search      },
 416   { "sortlist",          ccf_sortlist    },
 417   { "options",           ccf_options     },
 418   { "clearnameservers",  ccf_clearnss    },
 419   { "include",           ccf_include     },
 420   { "lookup",            ccf_lookup      }, /* OpenBSD */
 421   { "lwserver",          ccf_ignore      }, /* BIND9 lwresd */
 422   {  0                                   }
 423 };
 424
 425 typedef union {
 426   FILE *file;
 427   const char *text;
 428 } getline_ctx;
 429
 430 static int gl_file(adns_state ads, getline_ctx *src_io, const char *filename,
 431                    int lno, char *buf, int buflen) {
 432   FILE *file= src_io->file;
 433   int c, i;
 434   char *p;
 435
 436   p= buf;
 437   buflen--;
 438   i= 0;
 439
 440   for (;;) { /* loop over chars */
 441     if (i == buflen) {
 442       adns__diag(ads,-1,0,"%s:%d: line too long, ignored",filename,lno);
 443       goto x_badline;
 444     }
 445     c= getc(file);
 446     if (!c) {
 447       adns__diag(ads,-1,0,"%s:%d: line contains nul, ignored",filename,lno);
 448       goto x_badline;
 449     } else if (c == '\n') {
 450       break;
 451     } else if (c == EOF) {
 452       if (ferror(file)) {
 453         saveerr(ads,errno);
 454         adns__diag(ads,-1,0,"%s:%d: read error: %s",
 455                    filename,lno,strerror(errno));
 456         return -1;
 457       }
 458       if (!i) return -1;
 459       break;
 460     } else {
 461       *p++= c;
 462       i++;
 463     }
 464   }
 465
 466   *p++= 0;
 467   return i;
 468
 469  x_badline:
 470   saveerr(ads,EINVAL);
 471   while ((c= getc(file)) != EOF && c != '\n');
 472   return -2;
 473 }
 474
 475 static int gl_text(adns_state ads, getline_ctx *src_io, const char *filename,
 476                    int lno, char *buf, int buflen) {
 477   const char *cp= src_io->text;
 478   int l;
 479
 480   if (!cp || !*cp) return -1;
 481
 482   if (*cp == ';' || *cp == '\n') cp++;
 483   l= strcspn(cp,";\n");
 484   src_io->text = cp+l;
 485
 486   if (l >= buflen) {
 487     adns__diag(ads,-1,0,"%s:%d: line too long, ignored",filename,lno);
 488     saveerr(ads,EINVAL);
 489     return -2;
 490   }
 491
 492   memcpy(buf,cp,l);
 493   buf[l]= 0;
 494   return l;
 495 }
 496
 497 static void readconfiggeneric(adns_state ads, const char *filename,
 498                               int (*getline)(adns_state ads, getline_ctx*,
 499                                              const char *filename, int lno,
 500                                              char *buf, int buflen),
 501                               /* Returns >=0 for success, -1 for EOF or error
 502                                * (error will have been reported), or -2 for
 503                                * bad line was encountered, try again.
 504                                */
 505                               getline_ctx gl_ctx) {
 506   char linebuf[2000], *p, *q;
 507   int lno, l, dirl;
 508   const struct configcommandinfo *ccip;
 509
 510   for (lno=1;
 511        (l= getline(ads,&gl_ctx, filename,lno, linebuf,sizeof(linebuf))) != -1;
 512        lno++) {
 513     if (l == -2) continue;
 514     while (l>0 && ctype_whitespace(linebuf[l-1])) l--;
 515     linebuf[l]= 0;
 516     p= linebuf;
 517     while (ctype_whitespace(*p)) p++;
 518     if (*p == '#' || *p == ';' || !*p) continue;
 519     q= p;
 520     while (*q && !ctype_whitespace(*q)) q++;
 521     dirl= q-p;
 522     for (ccip=configcommandinfos;
 523          ccip->name &&
 524            !(strlen(ccip->name)==dirl && !memcmp(ccip->name,p,q-p));
 525          ccip++);
 526     if (!ccip->name) {
 527       if (ads->config_report_unknown)
 528         adns__diag(ads,-1,0,"%s:%d: unknown configuration directive `%.*s'",
 529                    filename,lno,(int)(q-p),p);
 530       continue;
 531     }
 532     while (ctype_whitespace(*q)) q++;
 533     ccip->fn(ads,filename,lno,q);
 534   }
 535 }
 536
 537 static const char *instrum_getenv(adns_state ads, const char *envvar) {
 538   const char *value;
 539
 540   value= getenv(envvar);
 541   if (!value) adns__debug(ads,-1,0,"environment variable %s not set",envvar);
 542   else adns__debug(ads,-1,0,"environment variable %s"
 543                    " set to `%s'",envvar,value);
 544   return value;
 545 }
 546
 547 static void readconfig(adns_state ads, const char *filename, int warnmissing) {
 548   getline_ctx gl_ctx;
 549
 550   gl_ctx.file= fopen(filename,"r");
 551   if (!gl_ctx.file) {
 552     if (errno == ENOENT) {
 553       if (warnmissing)
 554         adns__debug(ads,-1,0, "configuration file"
 555                     " `%s' does not exist",filename);
 556       return;
 557     }
 558     saveerr(ads,errno);
 559     adns__diag(ads,-1,0,"cannot open configuration file `%s': %s",
 560                filename,strerror(errno));
 561     return;
 562   }
 563
 564   readconfiggeneric(ads,filename,gl_file,gl_ctx);
 565
 566   fclose(gl_ctx.file);
 567 }
 568
 569 static void readconfigtext(adns_state ads, const char *text,
 570                            const char *showname) {
 571   getline_ctx gl_ctx;
 572
 573   gl_ctx.text= text;
 574   readconfiggeneric(ads,showname,gl_text,gl_ctx);
 575 }
 576
 577 static void readconfigenv(adns_state ads, const char *envvar) {
 578   const char *filename;
 579
 580   if (ads->iflags & adns_if_noenv) {
 581     adns__debug(ads,-1,0,"not checking environment variable `%s'",envvar);
 582     return;
 583   }
 584   filename= instrum_getenv(ads,envvar);
 585   if (filename) readconfig(ads,filename,1);
 586 }
 587
 588 static void readconfigenvtext(adns_state ads, const char *envvar) {
 589   const char *textdata;
 590
 591   if (ads->iflags & adns_if_noenv) {
 592     adns__debug(ads,-1,0,"not checking environment variable `%s'",envvar);
 593     return;
 594   }
 595   textdata= instrum_getenv(ads,envvar);
 596   if (textdata) readconfigtext(ads,textdata,envvar);
 597 }
 598
 599
 600 int adns__setnonblock(adns_state ads, int fd) {
 601   int r;
 602
 603   r= fcntl(fd,F_GETFL,0); if (r<0) return errno;
 604   r |= O_NONBLOCK;
 605   r= fcntl(fd,F_SETFL,r); if (r<0) return errno;
 606   return 0;
 607 }
 608
 609 static int init_begin(adns_state *ads_r, adns_initflags flags,
 610                       adns_logcallbackfn *logfn, void *logfndata) {
 611   adns_state ads;
 612   pid_t pid;
 613
 614   if (flags & ~(adns_initflags)(0x4fff))
 615     /* 0x4000 is reserved for `harmless' future expansion */
 616     return ENOSYS;
 617
 618   ads= malloc(sizeof(*ads)); if (!ads) return errno;
 619
 620   ads->iflags= flags;
 621   ads->logfn= logfn;
 622   ads->logfndata= logfndata;
 623   ads->configerrno= 0;
 624   LIST_INIT(ads->udpw);
 625   LIST_INIT(ads->tcpw);
 626   LIST_INIT(ads->childw);
 627   LIST_INIT(ads->output);
 628   LIST_INIT(ads->intdone);
 629   ads->forallnext= 0;
 630   ads->nextid= 0x311f;
 631   ads->nudpsockets= 0;
 632   ads->tcpsocket= -1;
 633   adns__vbuf_init(&ads->tcpsend);
 634   adns__vbuf_init(&ads->tcprecv);
 635   ads->tcprecv_skip= 0;
 636   ads->nservers= ads->nsortlist= ads->nsearchlist= ads->tcpserver= 0;
 637   ads->searchndots= 1;
 638   ads->tcpstate= server_disconnected;
 639   timerclear(&ads->tcptimeout);
 640   ads->searchlist= 0;
 641   ads->config_report_unknown=1;
 642
 643   pid= getpid();
 644   ads->rand48xsubi[0]= pid;
 645   ads->rand48xsubi[1]= (unsigned long)pid >> 16;
 646   ads->rand48xsubi[2]= pid ^ ((unsigned long)pid >> 16);
 647
 648   *ads_r= ads;
 649   return 0;
 650 }
 651
 652 static int init_finish(adns_state ads) {
 653   struct sockaddr_in sin;
 654   struct protoent *proto;
 655   struct udpsocket *udp;
 656   int i;
 657   int r;
 658
 659   if (!ads->nservers) {
 660     if (ads->logfn && ads->iflags & adns_if_debug)
 661       adns__lprintf(ads,"adns: no nameservers, using IPv4 localhost\n");
 662     memset(&sin, 0, sizeof(sin));
 663     sin.sin_family = AF_INET;
 664     sin.sin_port = htons(DNS_PORT);
 665     sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 666     addserver(ads,(struct sockaddr *)&sin, sizeof(sin));
 667   }
 668
 669   proto= getprotobyname("udp"); if (!proto) { r= ENOPROTOOPT; goto x_free; }
 670   ads->nudpsockets= 0;
 671   for (i=0; i<ads->nservers; i++) {
 672     if (adns__udpsocket_by_af(ads, ads->servers[i].addr.sa.sa_family))
 673       continue;
 674     assert(ads->nudpsockets < MAXUDP);
 675     udp= &ads->udpsockets[ads->nudpsockets];
 676     udp->af= ads->servers[i].addr.sa.sa_family;
 677     udp->fd= socket(udp->af,SOCK_DGRAM,proto->p_proto);
 678     if (udp->fd < 0) { r= errno; goto x_free; }
 679     ads->nudpsockets++;
 680     r= adns__setnonblock(ads,udp->fd);
 681     if (r) { r= errno; goto x_closeudp; }
 682   }
 683
 684   return 0;
 685
 686  x_closeudp:
 687   for (i=0; i<ads->nudpsockets; i++) close(ads->udpsockets[i].fd);
 688  x_free:
 689   free(ads);
 690   return r;
 691 }
 692
 693 static void init_abort(adns_state ads) {
 694   if (ads->nsearchlist) {
 695     free(ads->searchlist[0]);
 696     free(ads->searchlist);
 697   }
 698   free(ads);
 699 }
 700
 701 static void logfn_file(adns_state ads, void *logfndata,
 702                        const char *fmt, va_list al) {
 703   vfprintf(logfndata,fmt,al);
 704 }
 705
 706 static int init_files(adns_state *ads_r, adns_initflags flags,
 707                       adns_logcallbackfn *logfn, void *logfndata) {
 708   adns_state ads;
 709   const char *res_options, *adns_res_options;
 710   int r;
 711
 712   r= init_begin(&ads, flags, logfn, logfndata);
 713   if (r) return r;
 714
 715   res_options= instrum_getenv(ads,"RES_OPTIONS");
 716   adns_res_options= instrum_getenv(ads,"ADNS_RES_OPTIONS");
 717   ccf_options(ads,"RES_OPTIONS",-1,res_options);
 718   ccf_options(ads,"ADNS_RES_OPTIONS",-1,adns_res_options);
 719
 720   readconfig(ads,"/etc/resolv.conf",1);
 721   readconfig(ads,"/etc/resolv-adns.conf",0);
 722   readconfigenv(ads,"RES_CONF");
 723   readconfigenv(ads,"ADNS_RES_CONF");
 724
 725   readconfigenvtext(ads,"RES_CONF_TEXT");
 726   readconfigenvtext(ads,"ADNS_RES_CONF_TEXT");
 727
 728   ccf_options(ads,"RES_OPTIONS",-1,res_options);
 729   ccf_options(ads,"ADNS_RES_OPTIONS",-1,adns_res_options);
 730
 731   ccf_search(ads,"LOCALDOMAIN",-1,instrum_getenv(ads,"LOCALDOMAIN"));
 732   ccf_search(ads,"ADNS_LOCALDOMAIN",-1,instrum_getenv(ads,"ADNS_LOCALDOMAIN"));
 733
 734   if (ads->configerrno && ads->configerrno != EINVAL) {
 735     r= ads->configerrno;
 736     init_abort(ads);
 737     return r;
 738   }
 739
 740   r= init_finish(ads);
 741   if (r) return r;
 742
 743   adns__consistency(ads,0,cc_exit);
 744   *ads_r= ads;
 745   return 0;
 746 }
 747
 748 int adns_init(adns_state *ads_r, adns_initflags flags, FILE *diagfile) {
 749   return init_files(ads_r, flags, logfn_file, diagfile ? diagfile : stderr);
 750 }
 751
 752 static int init_strcfg(adns_state *ads_r, adns_initflags flags,
 753                        adns_logcallbackfn *logfn, void *logfndata,
 754                        const char *configtext) {
 755   adns_state ads;
 756   int r;
 757
 758   r= init_begin(&ads, flags, logfn, logfndata);
 759   if (r) return r;
 760
 761   readconfigtext(ads,configtext,"<supplied configuration text>");
 762   if (ads->configerrno) {
 763     r= ads->configerrno;
 764     init_abort(ads);
 765     return r;
 766   }
 767
 768   r= init_finish(ads);  if (r) return r;
 769   adns__consistency(ads,0,cc_exit);
 770   *ads_r= ads;
 771   return 0;
 772 }
 773
 774 int adns_init_strcfg(adns_state *ads_r, adns_initflags flags,
 775                      FILE *diagfile, const char *configtext) {
 776   return init_strcfg(ads_r, flags,
 777                      diagfile ? logfn_file : 0, diagfile,
 778                      configtext);
 779 }
 780
 781 int adns_init_logfn(adns_state *newstate_r, adns_initflags flags,
 782                     const char *configtext /*0=>use default config files*/,
 783                     adns_logcallbackfn *logfn /*0=>logfndata is a FILE* */,
 784                     void *logfndata /*0 with logfn==0 => discard*/) {
 785   if (!logfn && logfndata)
 786     logfn= logfn_file;
 787   if (configtext)
 788     return init_strcfg(newstate_r, flags, logfn, logfndata, configtext);
 789   else
 790     return init_files(newstate_r, flags, logfn, logfndata);
 791 }
 792
 793 static void cancel_all(adns_query qu) {
 794   if (!qu->parent) adns__cancel(qu);
 795   else cancel_all(qu->parent);
 796 }
 797
 798 void adns_finish(adns_state ads) {
 799   int i;
 800   adns__consistency(ads,0,cc_enter);
 801   for (;;) {
 802     if (ads->udpw.head) cancel_all(ads->udpw.head);
 803     else if (ads->tcpw.head) cancel_all(ads->tcpw.head);
 804     else if (ads->childw.head) cancel_all(ads->childw.head);
 805     else if (ads->output.head) cancel_all(ads->output.head);
 806     else if (ads->intdone.head) cancel_all(ads->output.head);
 807     else break;
 808   }
 809   for (i=0; i<ads->nudpsockets; i++) close(ads->udpsockets[i].fd);
 810   if (ads->tcpsocket >= 0) close(ads->tcpsocket);
 811   adns__vbuf_free(&ads->tcpsend);
 812   adns__vbuf_free(&ads->tcprecv);
 813   freesearchlist(ads);
 814   free(ads);
 815 }
 816
 817 void adns_forallqueries_begin(adns_state ads) {
 818   adns__consistency(ads,0,cc_enter);
 819   ads->forallnext=
 820     ads->udpw.head ? ads->udpw.head :
 821     ads->tcpw.head ? ads->tcpw.head :
 822     ads->childw.head ? ads->childw.head :
 823     ads->output.head;
 824 }
 825
 826 adns_query adns_forallqueries_next(adns_state ads, void **context_r) {
 827   adns_query qu, nqu;
 828
 829   adns__consistency(ads,0,cc_enter);
 830   nqu= ads->forallnext;
 831   for (;;) {
 832     qu= nqu;
 833     if (!qu) return 0;
 834     if (qu->next) {
 835       nqu= qu->next;
 836     } else if (qu == ads->udpw.tail) {
 837       nqu=
 838         ads->tcpw.head ? ads->tcpw.head :
 839         ads->childw.head ? ads->childw.head :
 840         ads->output.head;
 841     } else if (qu == ads->tcpw.tail) {
 842       nqu=
 843         ads->childw.head ? ads->childw.head :
 844         ads->output.head;
 845     } else if (qu == ads->childw.tail) {
 846       nqu= ads->output.head;
 847     } else {
 848       nqu= 0;
 849     }
 850     if (!qu->parent) break;
 851   }
 852   ads->forallnext= nqu;
 853   if (context_r) *context_r= qu->ctx.ext;
 854   return qu;
 855 }