src/setup.c

   1 /**/
   2
   3 #include "adns-internal.h"
   4
   5 void adns__vdiag(adns_state ads, adns_initflags prevent, const char *pfx,
   6                         int serv, const char *fmt, va_list al) {
   7   if (!(ads->iflags & adns_if_debug) && (!prevent || (ads->iflags & prevent))) return;
   8   if (serv>=0) {
   9     fprintf(stderr,"adns%s: nameserver %s: ",pfx,inet_ntoa(ads->servers[serv].addr));
  10   } else {
  11     fprintf(stderr,"adns%s: ",pfx);
  12   }
  13   vfprintf(stderr,fmt,al);
  14   fputc('\n',stderr);
  15 }
  16
  17 void adns__debug(adns_state ads, int serv, const char *fmt, ...) {
  18   va_list al;
  19
  20   va_start(al,fmt);
  21   vdiag(ads," debug",0,serv,fmt,al);
  22   va_end(al);
  23 }
  24
  25 void adns__swarn(adns_state ads, int serv, const char *fmt, ...) {
  26   va_list al;
  27
  28   va_start(al,fmt);
  29   vdiag(ads," warning",adns_if_noerrprint|adns_if_noserverwarn,serv,fmt,al);
  30   va_end(al);
  31 }
  32
  33 void adns__diag(adns_state ads, int serv, const char *fmt, ...) {
  34   va_list al;
  35
  36   va_start(al,fmt);
  37   vdiag(ads,"",adns_if_noerrprint,serv,fmt,al);
  38   va_end(al);
  39 }
  40
  41 /* FIXME: unsigned char -> byte everywhere */
  42
  43
  44 int adns__vbuf_ensure(adns__vbuf *vb, size_t want) {
  45   byte *nb;
  46
  47   if (vb->avail >= want) return;
  48   nb= realloc(vb->buf,want); if (!nb) return 0;
  49   vb->buf= nb;
  50   vb->avail= want;
  51   return 1;
  52 }
  53
  54 void adns__vbuf_appendq(adns__vbuf *vb, const byte *data, size_t len) {
  55   memcpy(vb->buf+vb->used,data,len);
  56   vb->used+= len;
  57 }
  58
  59 int adns__vbuf_append(adns__vbuf *vb, const byte *data, size_t len) {
  60   size_t newlen, newalloc;
  61   byte *nb;
  62
  63   newlen= vb->used+len;
  64   if (vb->avail < newlen) {
  65     newlen <<= 1;
  66     nb= realloc(vb->buf,newlen);
  67     if (!nb) { newlen >>= 1; nb= realloc(vb->buf,newlen); }
  68     if (!nb) return 0;
  69     vb->buf= nb;
  70     vb->avail= newlen;
  71   }
  72   adns__vbuf_appendq(vb,data,len);
  73   return 1;
  74 }
  75
  76 static void addserver(adns_state ads, struct in_addr addr) {
  77   int i;
  78   struct server *ss;
  79
  80   for (i=0; i<ads->nservers; i++) {
  81     if (ads->servers[i].addr.s_addr == addr.s_addr) {
  82       debug(ads,"duplicate nameserver %s ignored",inet_ntoa(addr));
  83       return;
  84     }
  85   }
  86
  87   if (ads->nservers>=MAXSERVERS) {
  88     diag(ads,"too many nameservers, ignoring %s",inet_ntoa(addr));
  89     return;
  90   }
  91
  92   ss= ads->servers+ads->nservers;
  93   ss->addr= addr;
  94   ss->state= server_disc;
  95   ss->connw.head= ss->connw.tail= 0;
  96   ads->nservers++;
  97 }
  98
  99 static void configparseerr(adns_state ads, const char *fn, int lno,
 100                            const char *fmt, ...) {
 101   va_list al;
 102
 103   if (ads->iflags & adns_if_noerrprint) return;
 104   if (lno==-1) fprintf(stderr,"adns: %s: ",fn);
 105   else fprintf(stderr,"adns: %s:%d: ",fn,lno);
 106   va_start(al,fmt);
 107   vfprintf(stderr,fmt,al);
 108   va_end(al);
 109   fputc('\n',stderr);
 110 }
 111
 112 static void ccf_nameserver(adns_state ads, const char *fn, int lno, const char *buf) {
 113   struct in_addr ia;
 114
 115   if (!inet_aton(buf,&ia)) {
 116     configparseerr(ads,fn,lno,"invalid nameserver address `%s'",buf);
 117     return;
 118   }
 119   debug(ads,"using nameserver %s",inet_ntoa(ia));
 120   addserver(ads,ia);
 121 }
 122
 123 static void ccf_search(adns_state ads, const char *fn, int lno, const char *buf) {
 124   if (!buf) return;
 125   diag(ads,"warning - `search' ignored FIXME");
 126 }
 127
 128 static void ccf_sortlist(adns_state ads, const char *fn, int lno, const char *buf) {
 129   diag(ads,"warning - `sortlist' ignored FIXME");
 130 }
 131
 132 static void ccf_options(adns_state ads, const char *fn, int lno, const char *buf) {
 133   if (!buf) return;
 134   diag(ads,"warning - `options' ignored FIXME");
 135 }
 136
 137 static void ccf_clearnss(adns_state ads, const char *fn, int lno, const char *buf) {
 138   ads->nservers= 0;
 139 }
 140
 141 static const struct configcommandinfo {
 142   const char *name;
 143   void (*fn)(adns_state ads, const char *fn, int lno, const char *buf);
 144 } configcommandinfos[]= {
 145   { "nameserver",        ccf_nameserver  },
 146   { "domain",            ccf_search      },
 147   { "search",            ccf_search      },
 148   { "sortlist",          ccf_sortlist    },
 149   { "options",           ccf_options     },
 150   { "clearnameservers",  ccf_clearnss    },
 151   {  0                                   }
 152 };
 153
 154 static void readconfig(adns_state ads, const char *filename) {
 155   char linebuf[2000], *p, *q;
 156   FILE *file;
 157   int lno, l, c;
 158   const struct configcommandinfo *ccip;
 159
 160   file= fopen(filename,"r");
 161   if (!file) {
 162     if (errno == ENOENT) {
 163       debug(ads,"configuration file `%s' does not exist",filename);
 164       return;
 165     }
 166     diag(ads,"cannot open configuration file `%s': %s",filename,strerror(errno));
 167     return;
 168   }
 169
 170   for (lno=1; fgets(linebuf,sizeof(linebuf),file); lno++) {
 171     l= strlen(linebuf);
 172     if (!l) continue;
 173     if (linebuf[l-1] != '\n' && !feof(file)) {
 174       diag(ads,"%s:%d: line too long",filename,lno);
 175       while ((c= getc(file)) != EOF && c != '\n') { }
 176       if (c == EOF) break;
 177       continue;
 178     }
 179     while (l>0 && ctype_whitespace(linebuf[l-1])) l--;
 180     linebuf[l]= 0;
 181     p= linebuf;
 182     while (ctype_whitespace(*p)) p++;
 183     if (*p == '#' || *p == '\n') continue;
 184     q= p;
 185     while (*q && !ctype_whitespace(*q)) q++;
 186     for (ccip=configcommandinfos;
 187          ccip->name && strncmp(ccip->name,p,q-p);
 188          ccip++);
 189     if (!ccip->name) {
 190       diag(ads,"%s:%d: unknown configuration directive `%.*s'",filename,lno,q-p,p);
 191       continue;
 192     }
 193     while (ctype_whitespace(*q)) q++;
 194     ccip->fn(ads,filename,lno,q);
 195   }
 196   if (ferror(file)) {
 197     diag(ads,"%s:%d: read error: %s",filename,lno,strerror(errno));
 198   }
 199   fclose(file);
 200 }
 201
 202 static const char *instrum_getenv(adns_state ads, const char *envvar) {
 203   const char *value;
 204
 205   value= getenv(envvar);
 206   if (!value) debug(ads,"environment variable %s not set",envvar);
 207   else debug(ads,"environment variable %s set to `%s'",envvar,value);
 208   return value;
 209 }
 210
 211 static void readconfigenv(adns_state ads, const char *envvar) {
 212   const char *filename;
 213
 214   if (ads->iflags & adns_if_noenv) {
 215     debug(ads,"not checking environment variable `%s'",envvar);
 216     return;
 217   }
 218   filename= instrum_getenv(ads,envvar);
 219   if (filename) readconfig(ads,filename);
 220 }
 221
 222 int adns_init(adns_state *ads_r, adns_initflags flags) {
 223   adns_state ads;
 224   const char *res_options, *adns_res_options;
 225   struct protoent *proto;
 226   int r;
 227
 228   ads= malloc(sizeof(*ads)); if (!ads) return errno;
 229   ads->timew.head= ads->timew.tail= 0;
 230   ads->childw.head= ads->childw.tail= 0;
 231   ads->output.head= ads->output.tail= 0;
 232   ads->nextid= 0x311f;
 233   ads->udpsocket= -1;
 234   ads->qbufavail= 0;
 235   ads->qbuf= 0;
 236   ads->tcpbufavail= ads->tcpbufused= ads->tcpbufdone= 0;
 237   ads->tcpbuf= 0;
 238   ads->iflags= flags;
 239   ads->nservers= 0;
 240   ads->iflags= flags;
 241
 242   res_options= instrum_getenv(ads,"RES_OPTIONS");
 243   adns_res_options= instrum_getenv(ads,"ADNS_RES_OPTIONS");
 244   ccf_options(ads,"RES_OPTIONS",-1,res_options);
 245   ccf_options(ads,"ADNS_RES_OPTIONS",-1,adns_res_options);
 246
 247   readconfig(ads,"/etc/resolv.conf");
 248   readconfigenv(ads,"RES_CONF");
 249   readconfigenv(ads,"ADNS_RES_CONF");
 250
 251   ccf_options(ads,"RES_OPTIONS",-1,res_options);
 252   ccf_options(ads,"ADNS_RES_OPTIONS",-1,adns_res_options);
 253
 254   ccf_search(ads,"LOCALDOMAIN",-1,instrum_getenv(ads,"LOCALDOMAIN"));
 255   ccf_search(ads,"ADNS_LOCALDOMAIN",-1,instrum_getenv(ads,"ADNS_LOCALDOMAIN"));
 256
 257   if (!ads->nservers) {
 258     struct in_addr ia;
 259     if (ads->iflags & adns_if_debug)
 260       fprintf(stderr,"adns: no nameservers, using localhost\n");
 261     ia.s_addr= INADDR_LOOPBACK;
 262     addserver(ads,ia);
 263   }
 264
 265   proto= getprotobyname("udp"); if (!proto) { r= ENOPROTOOPT; goto x_free; }
 266   ads->udpsocket= socket(AF_INET,SOCK_DGRAM,proto->p_proto);
 267   if (ads->udpsocket<0) { r= errno; goto x_free; }
 268
 269   /*fixme: nonblock */
 270
 271   *ads_r= ads;
 272   return 0;
 273
 274  x_free:
 275   free(ads);
 276   return r;
 277 }
 278
 279 int adns_finish(adns_state ads) {
 280   abort(); /* FIXME */
 281 }