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 (C) 1997-1999 Ian Jackson
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2, or (at your option)
  12  *  any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software Foundation,
  21  *  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  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 <netdb.h>
  31 #include <sys/socket.h>
  32 #include <netinet/in.h>
  33 #include <arpa/inet.h>
  34
  35 #include "internal.h"
  36
  37 static void readconfig(adns_state ads, const char *filename);
  38
  39 static void addserver(adns_state ads, struct in_addr addr) {
  40   int i;
  41   struct server *ss;
  42
  43   for (i=0; i<ads->nservers; i++) {
  44     if (ads->servers[i].addr.s_addr == addr.s_addr) {
  45       adns__debug(ads,-1,0,"duplicate nameserver %s ignored",inet_ntoa(addr));
  46       return;
  47     }
  48   }
  49
  50   if (ads->nservers>=MAXSERVERS) {
  51     adns__diag(ads,-1,0,"too many nameservers, ignoring %s",inet_ntoa(addr));
  52     return;
  53   }
  54
  55   ss= ads->servers+ads->nservers;
  56   ss->addr= addr;
  57   ads->nservers++;
  58 }
  59
  60 static void saveerr(adns_state ads, int en) {
  61   if (!ads->configerrno) ads->configerrno= en;
  62 }
  63
  64 static void configparseerr(adns_state ads, const char *fn, int lno,
  65                            const char *fmt, ...) {
  66   va_list al;
  67
  68   saveerr(ads,EINVAL);
  69   if (!ads->diagfile || (ads->iflags & adns_if_noerrprint)) return;
  70
  71   if (lno==-1) fprintf(ads->diagfile,"adns: %s: ",fn);
  72   else fprintf(ads->diagfile,"adns: %s:%d: ",fn,lno);
  73   va_start(al,fmt);
  74   vfprintf(ads->diagfile,fmt,al);
  75   va_end(al);
  76   fputc('\n',ads->diagfile);
  77 }
  78
  79 static int nextword(const char **bufp_io, const char **word_r, int *l_r) {
  80   const char *p, *q;
  81
  82   p= *bufp_io;
  83   while (ctype_whitespace(*p)) p++;
  84   if (!*p) return 0;
  85
  86   q= p;
  87   while (*q && !ctype_whitespace(*q)) q++;
  88
  89   *l_r= q-p;
  90   *word_r= p;
  91   *bufp_io= q;
  92
  93   return 1;
  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   adns__debug(ads,-1,0,"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   const char *bufp, *word;
 109   char *newchars, **newptrs, **pp;
 110   int count, tl, l;
 111
 112   if (!buf) return;
 113
 114   bufp= buf;
 115   count= 0;
 116   tl= 0;
 117   while (nextword(&bufp,&word,&l)) { count++; tl += l+1; }
 118
 119   newptrs= malloc(sizeof(char*)*count);  if (!newptrs) { saveerr(ads,errno); return; }
 120   newchars= malloc(tl);  if (!newchars) { saveerr(ads,errno); free(newptrs); return; }
 121
 122   bufp= buf;
 123   pp= newptrs;
 124   while (nextword(&bufp,&word,&l)) {
 125     *pp++= newchars;
 126     memcpy(newchars,word,l);
 127     newchars += l;
 128     *newchars++ = 0;
 129   }
 130
 131   free(ads->searchlist);
 132   ads->nsearchlist= count;
 133   ads->searchlist= newptrs;
 134 }
 135
 136 static void ccf_sortlist(adns_state ads, const char *fn, int lno, const char *buf) {
 137   const char *word;
 138   char tbuf[200], *slash, *ep;
 139   struct in_addr base, mask;
 140   int l;
 141   unsigned long initial, baselocal;
 142
 143   if (!buf) return;
 144
 145   ads->nsortlist= 0;
 146   while (nextword(&buf,&word,&l)) {
 147     if (ads->nsortlist >= MAXSORTLIST) {
 148       adns__diag(ads,-1,0,"too many sortlist entries, ignoring %.*s onwards",l,word);
 149       return;
 150     }
 151
 152     if (l >= sizeof(tbuf)) {
 153       configparseerr(ads,fn,lno,"sortlist entry `%.*s' too long",l,word);
 154       continue;
 155     }
 156
 157     memcpy(tbuf,word,l); tbuf[l]= 0;
 158     slash= strchr(tbuf,'/');
 159     if (slash) *slash++= 0;
 160
 161     if (!inet_aton(tbuf,&base)) {
 162       configparseerr(ads,fn,lno,"invalid address `%s' in sortlist",tbuf);
 163       continue;
 164     }
 165
 166     if (slash) {
 167       if (strchr(slash,'.')) {
 168         if (!inet_aton(slash,&mask)) {
 169           configparseerr(ads,fn,lno,"invalid mask `%s' in sortlist",slash);
 170           continue;
 171         }
 172         if (base.s_addr & ~mask.s_addr) {
 173           configparseerr(ads,fn,lno,
 174                          "mask `%s' in sortlist overlaps address `%s'",slash,tbuf);
 175           continue;
 176         }
 177       } else {
 178         initial= strtoul(slash,&ep,10);
 179         if (*ep || initial>32) {
 180           configparseerr(ads,fn,lno,"mask length `%s' invalid",slash);
 181           continue;
 182         }
 183         mask.s_addr= htonl((0x0ffffffffUL) << (32-initial));
 184       }
 185     } else {
 186       baselocal= ntohl(base.s_addr);
 187       if (!baselocal & 0x080000000UL) /* class A */
 188         mask.s_addr= htonl(0x0ff000000UL);
 189       else if ((baselocal & 0x0c0000000UL) == 0x080000000UL)
 190         mask.s_addr= htonl(0x0ffff0000UL); /* class B */
 191       else if ((baselocal & 0x0f0000000UL) == 0x0e0000000UL)
 192         mask.s_addr= htonl(0x0ff000000UL); /* class C */
 193       else {
 194         configparseerr(ads,fn,lno,
 195                        "network address `%s' in sortlist is not in classed ranges,"
 196                        " must specify mask explicitly", tbuf);
 197         continue;
 198       }
 199     }
 200
 201     ads->sortlist[ads->nsortlist].base= base;
 202     ads->sortlist[ads->nsortlist].mask= mask;
 203     ads->nsortlist++;
 204   }
 205 }
 206
 207 static void ccf_options(adns_state ads, const char *fn, int lno, const char *buf) {
 208   const char *word;
 209   char *ep;
 210   unsigned long v;
 211   int l;
 212
 213   if (!buf) return;
 214
 215   while (nextword(&buf,&word,&l)) {
 216     if (l==5 && !memcmp(word,"debug",5)) {
 217       ads->iflags |= adns_if_debug;
 218       continue;
 219     }
 220     if (l>=6 && !memcmp(word,"ndots:",6)) {
 221       v= strtoul(word+6,&ep,10);
 222       if (l==6 || ep != word+l || v > INT_MAX) {
 223         configparseerr(ads,fn,lno,"option `%.*s' malformed or has bad value",l,word);
 224         continue;
 225       }
 226       ads->searchndots= v;
 227       continue;
 228     }
 229     adns__diag(ads,-1,0,"%s:%d: unknown option `%.*s'", fn,lno, l,word);
 230   }
 231 }
 232
 233 static void ccf_clearnss(adns_state ads, const char *fn, int lno, const char *buf) {
 234   ads->nservers= 0;
 235 }
 236
 237 static void ccf_include(adns_state ads, const char *fn, int lno, const char *buf) {
 238   if (!*buf) {
 239     configparseerr(ads,fn,lno,"`include' directive with no filename");
 240     return;
 241   }
 242   readconfig(ads,buf);
 243 }
 244
 245 static const struct configcommandinfo {
 246   const char *name;
 247   void (*fn)(adns_state ads, const char *fn, int lno, const char *buf);
 248 } configcommandinfos[]= {
 249   { "nameserver",        ccf_nameserver  },
 250   { "domain",            ccf_search      },
 251   { "search",            ccf_search      },
 252   { "sortlist",          ccf_sortlist    },
 253   { "options",           ccf_options     },
 254   { "clearnameservers",  ccf_clearnss    },
 255   { "include",           ccf_include     },
 256   {  0                                   }
 257 };
 258
 259 typedef union {
 260   FILE *file;
 261   const char *text;
 262 } getline_ctx;
 263
 264 static int gl_file(adns_state ads, getline_ctx *src_io, const char *filename,
 265                    int lno, char *buf, int buflen) {
 266   FILE *file= src_io->file;
 267   int c, i;
 268   char *p;
 269
 270   p= buf;
 271   buflen--;
 272   i= 0;
 273
 274   for (;;) { /* loop over chars */
 275     if (i == buflen) {
 276       adns__diag(ads,-1,0,"%s:%d: line too long, ignored",filename,lno);
 277       goto x_badline;
 278     }
 279     c= getc(file);
 280     if (!c) {
 281       adns__diag(ads,-1,0,"%s:%d: line contains nul, ignored",filename,lno);
 282       goto x_badline;
 283     } else if (c == '\n') {
 284       break;
 285     } else if (c == EOF) {
 286       if (ferror(file)) {
 287         saveerr(ads,errno);
 288         adns__diag(ads,-1,0,"%s:%d: read error: %s",filename,lno,strerror(errno));
 289         return -1;
 290       }
 291       if (!i) return -1;
 292       break;
 293     } else {
 294       *p++= c;
 295       i++;
 296     }
 297   }
 298
 299   *p++= 0;
 300   return i;
 301
 302  x_badline:
 303   saveerr(ads,EINVAL);
 304   while ((c= getc(file)) != EOF && c != '\n');
 305   return -2;
 306 }
 307
 308 static int gl_text(adns_state ads, getline_ctx *src_io, const char *filename,
 309                    int lno, char *buf, int buflen) {
 310   const char *cp= src_io->text;
 311   int l;
 312
 313   if (!cp || !*cp) return -1;
 314
 315   if (*cp == ';' || *cp == '\n') cp++;
 316   l= strcspn(cp,";\n");
 317   src_io->text = cp+l;
 318
 319   if (l >= buflen) {
 320     adns__diag(ads,-1,0,"%s:%d: line too long, ignored",filename,lno);
 321     saveerr(ads,EINVAL);
 322     return -2;
 323   }
 324
 325   memcpy(buf,cp,l);
 326   buf[l]= 0;
 327   return l;
 328 }
 329
 330 static void readconfiggeneric(adns_state ads, const char *filename,
 331                               int (*getline)(adns_state ads, getline_ctx*,
 332                                              const char *filename, int lno,
 333                                              char *buf, int buflen),
 334                               /* Returns >=0 for success, -1 for EOF or error
 335                                * (error will have been reported), or -2 for
 336                                * bad line was encountered, try again.
 337                                */
 338                               getline_ctx gl_ctx) {
 339   char linebuf[2000], *p, *q;
 340   int lno, l, dirl;
 341   const struct configcommandinfo *ccip;
 342
 343   for (lno=1;
 344        (l= getline(ads,&gl_ctx, filename,lno, linebuf,sizeof(linebuf))) != -1;
 345        lno++) {
 346     if (l == -2) continue;
 347     while (l>0 && ctype_whitespace(linebuf[l-1])) l--;
 348     linebuf[l]= 0;
 349     p= linebuf;
 350     while (ctype_whitespace(*p)) p++;
 351     if (*p == '#' || !*p) continue;
 352     q= p;
 353     while (*q && !ctype_whitespace(*q)) q++;
 354     dirl= q-p;
 355     for (ccip=configcommandinfos;
 356          ccip->name && !(strlen(ccip->name)==dirl && !memcmp(ccip->name,p,q-p));
 357          ccip++);
 358     if (!ccip->name) {
 359       adns__diag(ads,-1,0,"%s:%d: unknown configuration directive `%.*s'",
 360                  filename,lno,q-p,p);
 361       continue;
 362     }
 363     while (ctype_whitespace(*q)) q++;
 364     ccip->fn(ads,filename,lno,q);
 365   }
 366 }
 367
 368 static const char *instrum_getenv(adns_state ads, const char *envvar) {
 369   const char *value;
 370
 371   value= getenv(envvar);
 372   if (!value) adns__debug(ads,-1,0,"environment variable %s not set",envvar);
 373   else adns__debug(ads,-1,0,"environment variable %s set to `%s'",envvar,value);
 374   return value;
 375 }
 376
 377 static void readconfig(adns_state ads, const char *filename) {
 378   getline_ctx gl_ctx;
 379
 380   gl_ctx.file= fopen(filename,"r");
 381   if (!gl_ctx.file) {
 382     if (errno == ENOENT) {
 383       adns__debug(ads,-1,0,"configuration file `%s' does not exist",filename);
 384       return;
 385     }
 386     saveerr(ads,errno);
 387     adns__diag(ads,-1,0,"cannot open configuration file `%s': %s",
 388                filename,strerror(errno));
 389     return;
 390   }
 391
 392   readconfiggeneric(ads,filename,gl_file,gl_ctx);
 393
 394   fclose(gl_ctx.file);
 395 }
 396
 397 static void readconfigtext(adns_state ads, const char *text, const char *showname) {
 398   getline_ctx gl_ctx;
 399
 400   gl_ctx.text= text;
 401   readconfiggeneric(ads,showname,gl_text,gl_ctx);
 402 }
 403
 404 static void readconfigenv(adns_state ads, const char *envvar) {
 405   const char *filename;
 406
 407   if (ads->iflags & adns_if_noenv) {
 408     adns__debug(ads,-1,0,"not checking environment variable `%s'",envvar);
 409     return;
 410   }
 411   filename= instrum_getenv(ads,envvar);
 412   if (filename) readconfig(ads,filename);
 413 }
 414
 415 static void readconfigenvtext(adns_state ads, const char *envvar) {
 416   const char *textdata;
 417
 418   if (ads->iflags & adns_if_noenv) {
 419     adns__debug(ads,-1,0,"not checking environment variable `%s'",envvar);
 420     return;
 421   }
 422   textdata= instrum_getenv(ads,envvar);
 423   if (textdata) readconfigtext(ads,textdata,envvar);
 424 }
 425
 426
 427 int adns__setnonblock(adns_state ads, int fd) {
 428   int r;
 429
 430   r= fcntl(fd,F_GETFL,0); if (r<0) return errno;
 431   r |= O_NONBLOCK;
 432   r= fcntl(fd,F_SETFL,r); if (r<0) return errno;
 433   return 0;
 434 }
 435
 436 static int init_begin(adns_state *ads_r, adns_initflags flags, FILE *diagfile) {
 437   adns_state ads;
 438
 439   ads= malloc(sizeof(*ads)); if (!ads) return errno;
 440
 441   ads->iflags= flags;
 442   ads->diagfile= diagfile;
 443   ads->configerrno= 0;
 444   LIST_INIT(ads->timew);
 445   LIST_INIT(ads->childw);
 446   LIST_INIT(ads->output);
 447   ads->forallnext= 0;
 448   ads->nextid= 0x311f;
 449   ads->udpsocket= ads->tcpsocket= -1;
 450   adns__vbuf_init(&ads->tcpsend);
 451   adns__vbuf_init(&ads->tcprecv);
 452   ads->nservers= ads->nsortlist= ads->nsearchlist= ads->tcpserver= 0;
 453   ads->searchndots= 1;
 454   ads->tcpstate= server_disconnected;
 455   timerclear(&ads->tcptimeout);
 456   ads->searchlist= 0;
 457
 458   *ads_r= ads;
 459   return 0;
 460 }
 461
 462 static int init_finish(adns_state ads) {
 463   struct in_addr ia;
 464   struct protoent *proto;
 465   int r;
 466
 467   if (!ads->nservers) {
 468     if (ads->diagfile && ads->iflags & adns_if_debug)
 469       fprintf(ads->diagfile,"adns: no nameservers, using localhost\n");
 470     ia.s_addr= htonl(INADDR_LOOPBACK);
 471     addserver(ads,ia);
 472   }
 473
 474   proto= getprotobyname("udp"); if (!proto) { r= ENOPROTOOPT; goto x_free; }
 475   ads->udpsocket= socket(AF_INET,SOCK_DGRAM,proto->p_proto);
 476   if (ads->udpsocket<0) { r= errno; goto x_free; }
 477
 478   r= adns__setnonblock(ads,ads->udpsocket);
 479   if (r) { r= errno; goto x_closeudp; }
 480
 481   return 0;
 482
 483  x_closeudp:
 484   close(ads->udpsocket);
 485  x_free:
 486   free(ads);
 487   return r;
 488 }
 489
 490 static void init_abort(adns_state ads) {
 491   if (ads->nsearchlist) {
 492     free(ads->searchlist[0]);
 493     free(ads->searchlist);
 494   }
 495   free(ads);
 496 }
 497
 498 int adns_init(adns_state *ads_r, adns_initflags flags, FILE *diagfile) {
 499   adns_state ads;
 500   const char *res_options, *adns_res_options;
 501   int r;
 502
 503   r= init_begin(&ads, flags, diagfile ? diagfile : stderr);
 504   if (r) return r;
 505
 506   res_options= instrum_getenv(ads,"RES_OPTIONS");
 507   adns_res_options= instrum_getenv(ads,"ADNS_RES_OPTIONS");
 508   ccf_options(ads,"RES_OPTIONS",-1,res_options);
 509   ccf_options(ads,"ADNS_RES_OPTIONS",-1,adns_res_options);
 510
 511   readconfig(ads,"/etc/resolv.conf");
 512   readconfigenv(ads,"RES_CONF");
 513   readconfigenv(ads,"ADNS_RES_CONF");
 514
 515   readconfigenvtext(ads,"RES_CONF_TEXT");
 516   readconfigenvtext(ads,"ADNS_RES_CONF_TEXT");
 517
 518   ccf_options(ads,"RES_OPTIONS",-1,res_options);
 519   ccf_options(ads,"ADNS_RES_OPTIONS",-1,adns_res_options);
 520
 521   ccf_search(ads,"LOCALDOMAIN",-1,instrum_getenv(ads,"LOCALDOMAIN"));
 522   ccf_search(ads,"ADNS_LOCALDOMAIN",-1,instrum_getenv(ads,"ADNS_LOCALDOMAIN"));
 523
 524   if (ads->configerrno && ads->configerrno != EINVAL) {
 525     r= ads->configerrno;
 526     init_abort(ads);
 527     return r;
 528   }
 529
 530   r= init_finish(ads);
 531   if (r) return r;
 532
 533   *ads_r= ads;
 534   return 0;
 535 }
 536
 537 int adns_init_strcfg(adns_state *ads_r, adns_initflags flags,
 538                      FILE *diagfile, const char *configtext) {
 539   adns_state ads;
 540   int r;
 541
 542   r= init_begin(&ads, flags, diagfile);  if (r) return r;
 543
 544   readconfigtext(ads,configtext,"<supplied configuration text>");
 545   if (ads->configerrno) {
 546     r= ads->configerrno;
 547     init_abort(ads);
 548     return r;
 549   }
 550
 551   r= init_finish(ads);  if (r) return r;
 552   *ads_r= ads;
 553   return 0;
 554 }
 555
 556 void adns_finish(adns_state ads) {
 557   for (;;) {
 558     if (ads->timew.head) adns_cancel(ads->timew.head);
 559     else if (ads->childw.head) adns_cancel(ads->childw.head);
 560     else if (ads->output.head) adns_cancel(ads->output.head);
 561     else break;
 562   }
 563   close(ads->udpsocket);
 564   if (ads->tcpsocket >= 0) close(ads->tcpsocket);
 565   adns__vbuf_free(&ads->tcpsend);
 566   adns__vbuf_free(&ads->tcprecv);
 567   free(ads);
 568 }
 569
 570 void adns_forallqueries_begin(adns_state ads) {
 571   ads->forallnext=
 572     ads->timew.head ? ads->timew.head :
 573     ads->childw.head ? ads->childw.head :
 574     ads->output.head;
 575 }
 576
 577 adns_query adns_forallqueries_next(adns_state ads, void **context_r) {
 578   adns_query qu, nqu;
 579
 580   nqu= ads->forallnext;
 581   for (;;) {
 582     qu= nqu;
 583     if (!qu) return 0;
 584     if (qu->next) {
 585       nqu= qu->next;
 586     } else if (qu == ads->timew.tail) {
 587       if (ads->childw.head) {
 588         nqu= ads->childw.head;
 589       } else {
 590         nqu= ads->output.head;
 591       }
 592     } else if (qu == ads->childw.tail) {
 593       nqu= ads->output.head;
 594     } else {
 595       nqu= 0;
 596     }
 597     if (!qu->parent) break;
 598   }
 599   ads->forallnext= nqu;
 600   if (context_r) *context_r= qu->ctx.ext;
 601   return qu;
 602 }
 603
 604 void adns__checkqueues(adns_state ads) {
 605   adns_forallqueries_begin(ads);
 606   while (adns_forallqueries_next(ads,0));
 607 }