[adns] / src / adns.c

/**/

#include <stdarg.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>

#include <arpa/nameser.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "adns-internal.h"

#define LIST_UNLINK(list,node) \
  do { \
    if ((node)->back) (node)->back->next= (node)->next; \
      else                   (list).head= (node)->next; \
    if ((node)->next) (node)->next->back= (node)->back; \
      else                   (list).tail= (node)->back; \
  } while(0)

#define LIST_LINK_TAIL(list,node) \
  do { \
    (node)->back= 0; \
    (node)->next= (list).tail; \
    if ((list).tail) (list).tail->back= (node); else (list).head= (node); \
    (list).tail= (node); \
  } while(0)

static void vdebug(adns_state ads, const char *fmt, va_list al) {
  if (!(ads->iflags & adns_if_debug)) return;
  fputs("adns debug: ",stderr);
  vfprintf(stderr,fmt,al);
  fputc('\n',stderr);
}

static void debug(adns_state ads, const char *fmt, ...) {
  va_list al;

  va_start(al,fmt);
  vdebug(ads,fmt,al);
  va_end(al);
}

static void vdiag(adns_state ads, const char *fmt, va_list al) {
  if (ads->iflags & adns_if_noerrprint) return;
  fputs("adns: ",stderr);
  vfprintf(stderr,fmt,al);
  fputc('\n',stderr);
}

static void diag(adns_state ads, const char *fmt, ...) {
  va_list al;

  va_start(al,fmt);
  vdiag(ads,fmt,al);
  va_end(al);
}

static void addserver(adns_state ads, struct in_addr addr) {
  int i;
  
  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;
  }

  ads->servers[ads->nservers].addr= addr;
  ads->servers[ads->nservers].tcpsocket= -1;
  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 int whitespace(int c) {
  return c==' ' || c=='\n' || c=='\t';
}

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 && whitespace(linebuf[l-1])) l--;
    linebuf[l]= 0;
    p= linebuf;
    while (whitespace(*p)) p++;
    if (*p == '#' || *p == '\n') continue;
    q= p;
    while (*q && !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 (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;
  
  ads= malloc(sizeof(*ads)); if (!ads) return errno;
  ads->input.head= ads->input.tail= 0;
  ads->timew.head= ads->timew.tail= 0;
  ads->childw.head= ads->childw.tail= 0;
  ads->output.head= ads->output.tail= 0;
  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);
  }
  
  *ads_r= ads;
  return 0;
}

static void query_fail(adns_state ads, adns_query qu, adns_status stat) {
  adns_answer *ans;
  
  ans= qu->answer;
  if (!ans) ans= malloc(sizeof(*qu->answer));
  if (ans) {
    ans->status= stat;
    ans->cname= 0;
    ans->type= qu->type;
    ans->nrrs= 0;
  }
  qu->answer= ans;
  LIST_LINK_TAIL(ads->input,qu);
}

void adns_interest(adns_state ads, int *maxfd,
		   fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
		   struct timeval **tv_io, struct timeval *tvbuf) {
  abort(); /* FIXME */
}

static void autosys(adns_state ads) {
  if (ads->iflags & adns_if_noautosys) return;
  adns_callback(ads,-1,0,0,0);
}

void adns_cancel(adns_state ads, adns_query query) {
  abort(); /* FIXME */
}

int adns_callback(adns_state ads, int maxfd,
		  const fd_set *readfds, const fd_set *writefds,
		  const fd_set *exceptfds) {
  abort(); /* FIXME */
}

static int internal_check(adns_state ads,
			  adns_query *query_io,
			  adns_answer *answer,
			  void *context_r) {
  abort(); /* FIXME */
}

int adns_wait(adns_state ads,
	      adns_query *query_io,
	      adns_answer *answer,
	      void *context_r) {
  int r, maxfd, rsel, rcb;
  fd_set readfds, writefds, exceptfds;
  struct timeval tvbuf, *tvp;
  
  for (;;) {
    r= internal_check(ads,query_io,answer,context_r);
    if (r && r != EWOULDBLOCK) return r;
    FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds);
    maxfd= 0; tvp= 0;
    adns_interest(ads,&maxfd,&readfds,&writefds,&exceptfds,&tvp,&tvbuf);
    rsel= select(maxfd,&readfds,&writefds,&exceptfds,tvp);
    if (rsel==-1) return r;
    rcb= adns_callback(ads,maxfd,&readfds,&writefds,&exceptfds);
    assert(rcb==rsel);
  }
}

int adns_check(adns_state ads,
	       adns_query *query_io,
	       adns_answer *answer,
	       void *context_r) {
  autosys(ads);
  return internal_check(ads,query_io,answer,context_r);
}

int adns_synchronous(adns_state ads,
		     const char *owner,
		     adns_rrtype type,
		     adns_queryflags flags,
		     adns_answer *answer) {
  adns_query qu;
  int r;
  
  r= adns_submit(ads,owner,type,flags,0,&qu);
  if (r) return r;

  do {
    r= adns_wait(ads,&qu,answer,0);
  } while (r==EINTR);
  if (r) adns_cancel(ads,qu);
  return r;
}

int adns_submit(adns_state ads,
		const char *owner,
		adns_rrtype type,
		adns_queryflags flags,
		void *context,
		adns_query *query_r) {
  adns_query qu;
  adns_status stat;
  int ol;

  stat= 0;
  ol= strlen(owner);
  if (ol>MAXDNAME+1) { stat= adns_s_invaliddomain; ol= 0; }
  if (ol>0 && owner[ol-1]=='.') { flags &= ~adns_f_search; ol--; }
  qu= malloc(sizeof(*qu)+ol+1); if (!qu) return errno;
  qu->next= qu->back= qu->parent= qu->child= 0;
  qu->type= type;
  qu->answer= 0;
  qu->flags= flags;
  qu->context= context;
  qu->udpretries= 0;
  qu->server= 0;
  memcpy(qu->owner,owner,ol); qu->owner[ol]= 0;
  if (stat) {
    query_fail(ads,qu,stat);
  } else {
    LIST_LINK_TAIL(ads->input,qu);
    autosys(ads);
  }
  *query_r= qu;
  return 0;
}
Commit	Line	Data
5db99a2e	1	/**/
5db99a2e	2
e7afa27f	3	#include <stdarg.h>
	4	#include <stdio.h>
	5	#include <errno.h>
	6	#include <string.h>
	7	#include <stdlib.h>
5617a135	8	#include <assert.h>
e7afa27f	9
5db99a2e	10	#include <arpa/nameser.h>
e7afa27f	11	#include <sys/socket.h>
	12	#include <netinet/in.h>
	13	#include <arpa/inet.h>
5db99a2e	14
	15	#include "adns-internal.h"
	16
	17	#define LIST_UNLINK(list,node) \
	18	do { \
	19	if ((node)->back) (node)->back->next= (node)->next; \
	20	else (list).head= (node)->next; \
	21	if ((node)->next) (node)->next->back= (node)->back; \
	22	else (list).tail= (node)->back; \
	23	} while(0)
	24
	25	#define LIST_LINK_TAIL(list,node) \
	26	do { \
	27	(node)->back= 0; \
	28	(node)->next= (list).tail; \
e7afa27f	29	if ((list).tail) (list).tail->back= (node); else (list).head= (node); \
5db99a2e	30	(list).tail= (node); \
	31	} while(0)
	32
e7afa27f	33	static void vdebug(adns_state ads, const char *fmt, va_list al) {
	34	if (!(ads->iflags & adns_if_debug)) return;
	35	fputs("adns debug: ",stderr);
	36	vfprintf(stderr,fmt,al);
	37	fputc('\n',stderr);
	38	}
	39
	40	static void debug(adns_state ads, const char *fmt, ...) {
	41	va_list al;
	42
	43	va_start(al,fmt);
	44	vdebug(ads,fmt,al);
	45	va_end(al);
	46	}
	47
	48	static void vdiag(adns_state ads, const char *fmt, va_list al) {
	49	if (ads->iflags & adns_if_noerrprint) return;
	50	fputs("adns: ",stderr);
	51	vfprintf(stderr,fmt,al);
	52	fputc('\n',stderr);
	53	}
	54
	55	static void diag(adns_state ads, const char *fmt, ...) {
	56	va_list al;
	57
	58	va_start(al,fmt);
	59	vdiag(ads,fmt,al);
	60	va_end(al);
	61	}
	62
	63	static void addserver(adns_state ads, struct in_addr addr) {
5617a135	64	int i;
	65
	66	for (i=0; i<ads->nservers; i++) {
	67	if (ads->servers[i].addr.s_addr == addr.s_addr) {
	68	debug(ads,"duplicate nameserver %s ignored",inet_ntoa(addr));
	69	return;
	70	}
	71	}
	72
5db99a2e	73	if (ads->nservers>=MAXSERVERS) {
e7afa27f	74	diag(ads,"too many nameservers, ignoring %s",inet_ntoa(addr));
5617a135	75	return;
5db99a2e	76	}
5617a135	77
	78	ads->servers[ads->nservers].addr= addr;
	79	ads->servers[ads->nservers].tcpsocket= -1;
	80	ads->nservers++;
5db99a2e	81	}
5db99a2e	82
e7afa27f	83	static void configparseerr(adns_state ads, const char *fn, int lno,
	84	const char *fmt, ...) {
	85	va_list al;
	86
	87	if (ads->iflags & adns_if_noerrprint) return;
	88	if (lno==-1) fprintf(stderr,"adns: %s: ",fn);
	89	else fprintf(stderr,"adns: %s:%d: ",fn,lno);
	90	va_start(al,fmt);
	91	vfprintf(stderr,fmt,al);
	92	va_end(al);
	93	fputc('\n',stderr);
	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	debug(ads,"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	if (!buf) return;
	109	diag(ads,"warning - `search' ignored FIXME");
	110	}
	111
	112	static void ccf_sortlist(adns_state ads, const char fn, int lno, const char buf) {
	113	diag(ads,"warning - `sortlist' ignored FIXME");
	114	}
	115
	116	static void ccf_options(adns_state ads, const char fn, int lno, const char buf) {
	117	if (!buf) return;
	118	diag(ads,"warning - `options' ignored FIXME");
	119	}
	120
	121	static void ccf_clearnss(adns_state ads, const char fn, int lno, const char buf) {
	122	ads->nservers= 0;
	123	}
	124
	125	static const struct configcommandinfo {
	126	const char *name;
	127	void (fn)(adns_state ads, const char fn, int lno, const char *buf);
	128	} configcommandinfos[]= {
	129	{ "nameserver", ccf_nameserver },
	130	{ "domain", ccf_search },
	131	{ "search", ccf_search },
	132	{ "sortlist", ccf_sortlist },
	133	{ "options", ccf_options },
	134	{ "clearnameservers", ccf_clearnss },
	135	{ 0 }
	136	};
	137
	138	static int whitespace(int c) {
	139	return c==' ' \|\| c=='\n' \|\| c=='\t';
	140	}
	141
	142	static void readconfig(adns_state ads, const char *filename) {
	143	char linebuf[2000], p, q;
	144	FILE *file;
	145	int lno, l, c;
	146	const struct configcommandinfo *ccip;
147
148	file= fopen(filename,"r");
149	if (!file) {
150	if (errno == ENOENT) {
151	debug(ads,"configuration file `%s' does not exist",filename);
152	return;
153	}
154	diag(ads,"cannot open configuration file `%s': %s",filename,strerror(errno));
155	return;
156	}
157
158	for (lno=1; fgets(linebuf,sizeof(linebuf),file); lno++) {
159	l= strlen(linebuf);
160	if (!l) continue;
161	if (linebuf[l-1] != '\n' && !feof(file)) {
162	diag(ads,"%s:%d: line too long",filename,lno);
163	while ((c= getc(file)) != EOF && c != '\n') { }
164	if (c == EOF) break;
165	continue;
166	}
167	while (l>0 && whitespace(linebuf[l-1])) l--;
168	linebuf[l]= 0;
169	p= linebuf;
170	while (whitespace(*p)) p++;
171	if (p == '#' \|\| p == '\n') continue;
172	q= p;
173	while (q && !whitespace(q)) q++;
174	for (ccip=configcommandinfos;
175	ccip->name && strncmp(ccip->name,p,q-p);
176	ccip++);
177	if (!ccip->name) {
178	diag(ads,"%s:%d: unknown configuration directive `%.*s'",filename,lno,q-p,p);
179	continue;
180	}
181	while (whitespace(*q)) q++;
182	ccip->fn(ads,filename,lno,q);
183	}
184	if (ferror(file)) {
185	diag(ads,"%s:%d: read error: %s",filename,lno,strerror(errno));
186	}
187	fclose(file);
188	}
189
190	static const char instrum_getenv(adns_state ads, const char envvar) {
191	const char *value;
192
193	value= getenv(envvar);
5617a135	194	if (!value) debug(ads,"environment variable %s not set",envvar);
5617a135	195	else debug(ads,"environment variable %s set to `%s'",envvar,value);
e7afa27f	196	return value;
5db99a2e	197	}
5db99a2e	198
e7afa27f	199	static void readconfigenv(adns_state ads, const char *envvar) {
5db99a2e	200	const char *filename;
5db99a2e	201
e7afa27f	202	if (ads->iflags & adns_if_noenv) {
	203	debug(ads,"not checking environment variable `%s'",envvar);
	204	return;
	205	}
	206	filename= instrum_getenv(ads,envvar);
	207	if (filename) readconfig(ads,filename);
5db99a2e	208	}
5db99a2e	209
e7afa27f	210	int adns_init(adns_state *ads_r, adns_initflags flags) {
5db99a2e	211	adns_state ads;
e7afa27f	212	const char res_options, adns_res_options;
5db99a2e	213
5db99a2e	214	ads= malloc(sizeof(*ads)); if (!ads) return errno;
e7afa27f	215	ads->input.head= ads->input.tail= 0;
5db99a2e	216	ads->timew.head= ads->timew.tail= 0;
e7afa27f	217	ads->childw.head= ads->childw.tail= 0;
e7afa27f	218	ads->output.head= ads->output.tail= 0;
5db99a2e	219	ads->udpsocket= -1;
	220	ads->qbufavail= 0;
	221	ads->qbuf= 0;
	222	ads->tcpbufavail= ads->tcpbufused= ads->tcpbufdone= 0;
	223	ads->tcpbuf= 0;
e7afa27f	224	ads->iflags= flags;
5db99a2e	225	ads->nservers= 0;
e7afa27f	226	ads->iflags= flags;
	227
	228	res_options= instrum_getenv(ads,"RES_OPTIONS");
	229	adns_res_options= instrum_getenv(ads,"ADNS_RES_OPTIONS");
	230	ccf_options(ads,"RES_OPTIONS",-1,res_options);
	231	ccf_options(ads,"ADNS_RES_OPTIONS",-1,adns_res_options);
5db99a2e	232
	233	readconfig(ads,"/etc/resolv.conf");
	234	readconfigenv(ads,"RES_CONF");
	235	readconfigenv(ads,"ADNS_RES_CONF");
e7afa27f	236
	237	ccf_options(ads,"RES_OPTIONS",-1,res_options);
	238	ccf_options(ads,"ADNS_RES_OPTIONS",-1,adns_res_options);
	239
	240	ccf_search(ads,"LOCALDOMAIN",-1,instrum_getenv(ads,"LOCALDOMAIN"));
	241	ccf_search(ads,"ADNS_LOCALDOMAIN",-1,instrum_getenv(ads,"ADNS_LOCALDOMAIN"));
	242
5db99a2e	243	if (!ads->nservers) {
e7afa27f	244	struct in_addr ia;
e7afa27f	245	if (ads->iflags & adns_if_debug)
5db99a2e	246	fprintf(stderr,"adns: no nameservers, using localhost\n");
e7afa27f	247	ia.s_addr= INADDR_LOOPBACK;
e7afa27f	248	addserver(ads,ia);
5db99a2e	249	}
	250
	251	*ads_r= ads;
	252	return 0;
	253	}
	254
e7afa27f	255	static void query_fail(adns_state ads, adns_query qu, adns_status stat) {
5617a135	256	adns_answer *ans;
5db99a2e	257
	258	ans= qu->answer;
	259	if (!ans) ans= malloc(sizeof(*qu->answer));
	260	if (ans) {
	261	ans->status= stat;
	262	ans->cname= 0;
	263	ans->type= qu->type;
	264	ans->nrrs= 0;
	265	}
	266	qu->answer= ans;
e7afa27f	267	LIST_LINK_TAIL(ads->input,qu);
5db99a2e	268	}
5db99a2e	269
5617a135	270	void adns_interest(adns_state ads, int *maxfd,
e7afa27f	271	fd_set readfds, fd_set writefds, fd_set *exceptfds,
5617a135	272	struct timeval *tv_io, struct timeval tvbuf) {
e7afa27f	273	abort(); /* FIXME */
5db99a2e	274	}
5db99a2e	275
5617a135	276	static void autosys(adns_state ads) {
	277	if (ads->iflags & adns_if_noautosys) return;
	278	adns_callback(ads,-1,0,0,0);
	279	}
	280
	281	void adns_cancel(adns_state ads, adns_query query) {
	282	abort(); /* FIXME */
	283	}
	284
	285	int adns_callback(adns_state ads, int maxfd,
	286	const fd_set readfds, const fd_set writefds,
	287	const fd_set *exceptfds) {
	288	abort(); /* FIXME */
	289	}
	290
	291	static int internal_check(adns_state ads,
	292	adns_query *query_io,
	293	adns_answer *answer,
	294	void *context_r) {
	295	abort(); /* FIXME */
	296	}
	297
	298	int adns_wait(adns_state ads,
	299	adns_query *query_io,
	300	adns_answer *answer,
	301	void *context_r) {
	302	int r, maxfd, rsel, rcb;
	303	fd_set readfds, writefds, exceptfds;
	304	struct timeval tvbuf, *tvp;
	305
	306	for (;;) {
	307	r= internal_check(ads,query_io,answer,context_r);
	308	if (r && r != EWOULDBLOCK) return r;
	309	FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds);
	310	maxfd= 0; tvp= 0;
	311	adns_interest(ads,&maxfd,&readfds,&writefds,&exceptfds,&tvp,&tvbuf);
	312	rsel= select(maxfd,&readfds,&writefds,&exceptfds,tvp);
	313	if (rsel==-1) return r;
	314	rcb= adns_callback(ads,maxfd,&readfds,&writefds,&exceptfds);
	315	assert(rcb==rsel);
	316	}
	317	}
	318
	319	int adns_check(adns_state ads,
	320	adns_query *query_io,
	321	adns_answer *answer,
	322	void *context_r) {
	323	autosys(ads);
	324	return internal_check(ads,query_io,answer,context_r);
	325	}
	326
	327	int adns_synchronous(adns_state ads,
	328	const char *owner,
	329	adns_rrtype type,
ebd44fbe	330	adns_queryflags flags,
5617a135	331	adns_answer *answer) {
	332	adns_query qu;
	333	int r;
	334
	335	r= adns_submit(ads,owner,type,flags,0,&qu);
	336	if (r) return r;
	337
ebd44fbe	338	do {
	339	r= adns_wait(ads,&qu,answer,0);
	340	} while (r==EINTR);
5617a135	341	if (r) adns_cancel(ads,qu);
	342	return r;
	343	}
	344
5db99a2e	345	int adns_submit(adns_state ads,
	346	const char *owner,
	347	adns_rrtype type,
ebd44fbe	348	adns_queryflags flags,
5db99a2e	349	void *context,
	350	adns_query *query_r) {
	351	adns_query qu;
	352	adns_status stat;
e7afa27f	353	int ol;
5db99a2e	354
	355	stat= 0;
	356	ol= strlen(owner);
e7afa27f	357	if (ol>MAXDNAME+1) { stat= adns_s_invaliddomain; ol= 0; }
5db99a2e	358	if (ol>0 && owner[ol-1]=='.') { flags &= ~adns_f_search; ol--; }
	359	qu= malloc(sizeof(*qu)+ol+1); if (!qu) return errno;
	360	qu->next= qu->back= qu->parent= qu->child= 0;
	361	qu->type= type;
	362	qu->answer= 0;
	363	qu->flags= flags;
	364	qu->context= context;
e7afa27f	365	qu->udpretries= 0;
5db99a2e	366	qu->server= 0;
	367	memcpy(qu->owner,owner,ol); qu->owner[ol]= 0;
	368	if (stat) {
	369	query_fail(ads,qu,stat);
	370	} else {
	371	LIST_LINK_TAIL(ads->input,qu);
5617a135	372	autosys(ads);
5db99a2e	373	}
5db99a2e	374	*query_r= qu;
5617a135	375	return 0;
5db99a2e	376	}