[adns] / src / setup.c

/**/

#include "adns-internal.h"

void adns__vdiag(adns_state ads, adns_initflags prevent, const char *pfx,
			int serv, const char *fmt, va_list al) {
  if (!(ads->iflags & adns_if_debug) && (!prevent || (ads->iflags & prevent))) return;
  if (serv>=0) {
    fprintf(stderr,"adns%s: nameserver %s: ",pfx,inet_ntoa(ads->servers[serv].addr));
  } else {
    fprintf(stderr,"adns%s: ",pfx);
  }
  vfprintf(stderr,fmt,al);
  fputc('\n',stderr);
}

void adns__debug(adns_state ads, int serv, const char *fmt, ...) {
  va_list al;

  va_start(al,fmt);
  vdiag(ads," debug",0,serv,fmt,al);
  va_end(al);
}

void adns__swarn(adns_state ads, int serv, const char *fmt, ...) {
  va_list al;

  va_start(al,fmt);
  vdiag(ads," warning",adns_if_noerrprint|adns_if_noserverwarn,serv,fmt,al);
  va_end(al);
}

void adns__diag(adns_state ads, int serv, const char *fmt, ...) {
  va_list al;

  va_start(al,fmt);
  vdiag(ads,"",adns_if_noerrprint,serv,fmt,al);
  va_end(al);
}

/* FIXME: unsigned char -> byte everywhere */


int adns__vbuf_ensure(adns__vbuf *vb, size_t want) {
  byte *nb;
  
  if (vb->avail >= want) return;
  nb= realloc(vb->buf,want); if (!nb) return 0;
  vb->buf= nb;
  vb->avail= want;
  return 1;
}
  
void adns__vbuf_appendq(adns__vbuf *vb, const byte *data, size_t len) {
  memcpy(vb->buf+vb->used,data,len);
  vb->used+= len;
}

int adns__vbuf_append(adns__vbuf *vb, const byte *data, size_t len) {
  size_t newlen, newalloc;
  byte *nb;

  newlen= vb->used+len;
  if (vb->avail < newlen) {
    newlen <<= 1;
    nb= realloc(vb->buf,newlen);
    if (!nb) { newlen >>= 1; nb= realloc(vb->buf,newlen); }
    if (!nb) return 0;
    vb->buf= nb;
    vb->avail= newlen;
  }
  adns__vbuf_appendq(vb,data,len);
  return 1;
}

static void addserver(adns_state ads, struct in_addr addr) {
  int i;
  struct server *ss;
  
  for (i=0; i<ads->nservers; i++) {
    if (ads->servers[i].addr.s_addr == addr.s_addr) {
      debug(ads,"duplicate nameserver %s ignored",inet_ntoa(addr));
      return;
    }
  }
  
  if (ads->nservers>=MAXSERVERS) {
    diag(ads,"too many nameservers, ignoring %s",inet_ntoa(addr));
    return;
  }

  ss= ads->servers+ads->nservers;
  ss->addr= addr;
  ss->state= server_disc;
  ss->connw.head= ss->connw.tail= 0;
  ads->nservers++;
}

static void configparseerr(adns_state ads, const char *fn, int lno,
			   const char *fmt, ...) {
  va_list al;
  
  if (ads->iflags & adns_if_noerrprint) return;
  if (lno==-1) fprintf(stderr,"adns: %s: ",fn);
  else fprintf(stderr,"adns: %s:%d: ",fn,lno);
  va_start(al,fmt);
  vfprintf(stderr,fmt,al);
  va_end(al);
  fputc('\n',stderr);
}

static void ccf_nameserver(adns_state ads, const char *fn, int lno, const char *buf) {
  struct in_addr ia;
  
  if (!inet_aton(buf,&ia)) {
    configparseerr(ads,fn,lno,"invalid nameserver address `%s'",buf);
    return;
  }
  debug(ads,"using nameserver %s",inet_ntoa(ia));
  addserver(ads,ia);
}

static void ccf_search(adns_state ads, const char *fn, int lno, const char *buf) {
  if (!buf) return;
  diag(ads,"warning - `search' ignored FIXME");
}

static void ccf_sortlist(adns_state ads, const char *fn, int lno, const char *buf) {
  diag(ads,"warning - `sortlist' ignored FIXME");
}

static void ccf_options(adns_state ads, const char *fn, int lno, const char *buf) {
  if (!buf) return;
  diag(ads,"warning - `options' ignored FIXME");
}

static void ccf_clearnss(adns_state ads, const char *fn, int lno, const char *buf) {
  ads->nservers= 0;
}

static const struct configcommandinfo {
  const char *name;
  void (*fn)(adns_state ads, const char *fn, int lno, const char *buf);
} configcommandinfos[]= {
  { "nameserver",        ccf_nameserver  },
  { "domain",            ccf_search      },
  { "search",            ccf_search      },
  { "sortlist",          ccf_sortlist    },
  { "options",           ccf_options     },
  { "clearnameservers",  ccf_clearnss    },
  {  0                                   }
};

static void readconfig(adns_state ads, const char *filename) {
  char linebuf[2000], *p, *q;
  FILE *file;
  int lno, l, c;
  const struct configcommandinfo *ccip;

  file= fopen(filename,"r");
  if (!file) {
    if (errno == ENOENT) {
      debug(ads,"configuration file `%s' does not exist",filename);
      return;
    }
    diag(ads,"cannot open configuration file `%s': %s",filename,strerror(errno));
    return;
  }

  for (lno=1; fgets(linebuf,sizeof(linebuf),file); lno++) {
    l= strlen(linebuf);
    if (!l) continue;
    if (linebuf[l-1] != '\n' && !feof(file)) {
      diag(ads,"%s:%d: line too long",filename,lno);
      while ((c= getc(file)) != EOF && c != '\n') { }
      if (c == EOF) break;
      continue;
    }
    while (l>0 && ctype_whitespace(linebuf[l-1])) l--;
    linebuf[l]= 0;
    p= linebuf;
    while (ctype_whitespace(*p)) p++;
    if (*p == '#' || *p == '\n') continue;
    q= p;
    while (*q && !ctype_whitespace(*q)) q++;
    for (ccip=configcommandinfos;
	 ccip->name && strncmp(ccip->name,p,q-p);
	 ccip++);
    if (!ccip->name) {
      diag(ads,"%s:%d: unknown configuration directive `%.*s'",filename,lno,q-p,p);
      continue;
    }
    while (ctype_whitespace(*q)) q++;
    ccip->fn(ads,filename,lno,q);
  }
  if (ferror(file)) {
    diag(ads,"%s:%d: read error: %s",filename,lno,strerror(errno));
  }
  fclose(file);
}

static const char *instrum_getenv(adns_state ads, const char *envvar) {
  const char *value;

  value= getenv(envvar);
  if (!value) debug(ads,"environment variable %s not set",envvar);
  else debug(ads,"environment variable %s set to `%s'",envvar,value);
  return value;
}

static void readconfigenv(adns_state ads, const char *envvar) {
  const char *filename;

  if (ads->iflags & adns_if_noenv) {
    debug(ads,"not checking environment variable `%s'",envvar);
    return;
  }
  filename= instrum_getenv(ads,envvar);
  if (filename) readconfig(ads,filename);
}
  
int adns_init(adns_state *ads_r, adns_initflags flags) {
  adns_state ads;
  const char *res_options, *adns_res_options;
  struct protoent *proto;
  int r;
  
  ads= malloc(sizeof(*ads)); if (!ads) return errno;
  ads->timew.head= ads->timew.tail= 0;
  ads->childw.head= ads->childw.tail= 0;
  ads->output.head= ads->output.tail= 0;
  ads->nextid= 0x311f;
  ads->udpsocket= -1;
  ads->qbufavail= 0;
  ads->qbuf= 0;
  ads->tcpbufavail= ads->tcpbufused= ads->tcpbufdone= 0;
  ads->tcpbuf= 0;
  ads->iflags= flags;
  ads->nservers= 0;
  ads->iflags= flags;

  res_options= instrum_getenv(ads,"RES_OPTIONS");
  adns_res_options= instrum_getenv(ads,"ADNS_RES_OPTIONS");
  ccf_options(ads,"RES_OPTIONS",-1,res_options);
  ccf_options(ads,"ADNS_RES_OPTIONS",-1,adns_res_options);

  readconfig(ads,"/etc/resolv.conf");
  readconfigenv(ads,"RES_CONF");
  readconfigenv(ads,"ADNS_RES_CONF");

  ccf_options(ads,"RES_OPTIONS",-1,res_options);
  ccf_options(ads,"ADNS_RES_OPTIONS",-1,adns_res_options);

  ccf_search(ads,"LOCALDOMAIN",-1,instrum_getenv(ads,"LOCALDOMAIN"));
  ccf_search(ads,"ADNS_LOCALDOMAIN",-1,instrum_getenv(ads,"ADNS_LOCALDOMAIN"));

  if (!ads->nservers) {
    struct in_addr ia;
    if (ads->iflags & adns_if_debug)
      fprintf(stderr,"adns: no nameservers, using localhost\n");
    ia.s_addr= INADDR_LOOPBACK;
    addserver(ads,ia);
  }

  proto= getprotobyname("udp"); if (!proto) { r= ENOPROTOOPT; goto x_free; }
  ads->udpsocket= socket(AF_INET,SOCK_DGRAM,proto->p_proto);
  if (ads->udpsocket<0) { r= errno; goto x_free; }

  /*fixme: nonblock */
  
  *ads_r= ads;
  return 0;

 x_free:
  free(ads);
  return r;
}

int adns_finish(adns_state ads) {
  abort(); /* FIXME */
}
Commit	Line	Data
656b2da9	1	/**/
	2
	3	#include "adns-internal.h"
	4
37e28fde	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	}
656b2da9	13	vfprintf(stderr,fmt,al);
	14	fputc('\n',stderr);
	15	}
	16
37e28fde	17	void adns__debug(adns_state ads, int serv, const char *fmt, ...) {
656b2da9	18	va_list al;
	19
	20	va_start(al,fmt);
37e28fde	21	vdiag(ads," debug",0,serv,fmt,al);
656b2da9	22	va_end(al);
	23	}
	24
37e28fde	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);
656b2da9	31	}
656b2da9	32
37e28fde	33	void adns__diag(adns_state ads, int serv, const char *fmt, ...) {
656b2da9	34	va_list al;
	35
	36	va_start(al,fmt);
37e28fde	37	vdiag(ads,"",adns_if_noerrprint,serv,fmt,al);
656b2da9	38	va_end(al);
	39	}
	40
ddfda861	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
656b2da9	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
656b2da9	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;
656b2da9	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);
8402e34c	267	if (ads->udpsocket<0) { r= errno; goto x_free; }
4bec51a4	268
4bec51a4	269	/fixme: nonblock /
656b2da9	270
	271	*ads_r= ads;
	272	return 0;
	273
656b2da9	274	x_free:
	275	free(ads);
	276	return r;
	277	}
	278
	279	int adns_finish(adns_state ads) {
	280	abort(); /* FIXME */
	281	}