mdw@git.distorted.org.uk Git - adns/blob - src/setup.c

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