int adns_wait_poll(adns_state ads,
adns_query *query_io,
adns_answer **answer_r,
void **context_r) {
int r, nfds, to;
struct pollfd fds[MAX_POLLFDS];
adns__consistency(ads,0,cc_entex);
for (;;) {
r= adns__internal_check(ads,query_io,answer_r,context_r);
if (r != EAGAIN) goto xit;
nfds= MAX_POLLFDS; to= -1;
adns_beforepoll(ads,fds,&nfds,&to,0);
r= poll(fds,nfds,to);
if (r == -1) {
if (errno == EINTR) {
if (ads->iflags & adns_if_eintr) { r= EINTR; goto xit; }
} else {
adns__diag(ads,-1,0,"poll failed in wait: %s",strerror(errno));
adns_globalsystemfailure(ads);
}
} else {
assert(r >= 0);
adns_afterpoll(ads,fds,nfds,0);
}
}
xit:
adns__consistency(ads,0,cc_entex);
return r;
}
static void addserver(adns_state ads, struct in_addr addr)
{
int i;
struct server *ss;
if(addr.s_addr == 0)
addr.s_addr = htonl(INADDR_LOOPBACK);
for (i=0; i<ads->nservers; i++)
{
if (ads->servers[i].addr.s_addr == addr.s_addr)
{
adns__debug(ads,-1,0,
"duplicate nameserver %s ignored",inetntoa((char *)&addr));
return;
}
}
if (ads->nservers>=MAXSERVERS)
{
adns__diag(ads,-1,0,"too many nameservers, ignoring %s",inetntoa((char *)&addr));
return;
}
ss= ads->servers+ads->nservers;
ss->addr= addr;
ads->nservers++;
}
static int gl_file(adns_state ads, getline_ctx *src_io, const char *filename,
int lno, char *buf, int buflen) {
FILE *file= src_io->file;
int c, i;
char *p;
p= buf;
buflen--;
i= 0;
for (;;) { /* loop over chars */
if (i == buflen) {
adns__diag(ads,-1,0,"%s:%d: line too long, ignored",filename,lno);
goto x_badline;
}
c= getc(file);
if (!c) {
adns__diag(ads,-1,0,"%s:%d: line contains nul, ignored",filename,lno);
goto x_badline;
} else if (c == '\n') {
break;
} else if (c == EOF) {
if (ferror(file)) {
saveerr(ads,errno);
adns__diag(ads,-1,0,"%s:%d: read error: %s",filename,lno,strerror(errno));
return -1;
}
if (!i) return -1;
break;
} else {
*p++= c;
i++;
}
}
*p++= 0;
return i;
x_badline:
saveerr(ads,EINVAL);
while ((c= getc(file)) != EOF && c != '\n');
return -2;
}
adns_status adns__findlabel_next(findlabel_state *fls,
int *lablen_r, int *labstart_r)
{
int lablen, jumpto;
const char *dgram;
dgram= fls->dgram;
for (;;)
{
if (fls->cbyte >= fls->dglen) goto x_truncated;
if (fls->cbyte >= fls->max) goto x_badresponse;
GET_B(fls->cbyte,lablen);
if (!(lablen & 0x0c0)) break;
if ((lablen & 0x0c0) != 0x0c0) return adns_s_unknownformat;
if (fls->cbyte >= fls->dglen) goto x_truncated;
if (fls->cbyte >= fls->max) goto x_badresponse;
GET_B(fls->cbyte,jumpto);
jumpto |= (lablen&0x3f)<<8;
if (fls->dmend_r) *(fls->dmend_r)= fls->cbyte;
fls->cbyte= jumpto;
fls->dmend_r= 0;
fls->max= fls->dglen+1;
}
if (labstart_r) *labstart_r= fls->cbyte;
if (lablen)
{
if (fls->namelen) fls->namelen++;
fls->namelen+= lablen;
if (fls->namelen > DNS_MAXDOMAIN) return adns_s_answerdomaintoolong;
fls->cbyte+= lablen;
if (fls->cbyte > fls->dglen) goto x_truncated;
if (fls->cbyte > fls->max) goto x_badresponse;
}
else
{
if (fls->dmend_r) *(fls->dmend_r)= fls->cbyte;
}
*lablen_r= lablen;
return adns_s_ok;
x_truncated:
*lablen_r= -1;
return adns_s_ok;
x_badresponse:
adns__diag(fls->ads,fls->serv,fls->qu,"label in domain runs beyond end of domain");
return adns_s_invalidresponse;
}
static void readconfig(adns_state ads, const char *filename, int warnmissing) {
getline_ctx gl_ctx;
gl_ctx.file= fopen(filename,"r");
if (!gl_ctx.file) {
if (errno == ENOENT) {
if (warnmissing)
adns__debug(ads,-1,0,"configuration file `%s' does not exist",filename);
return;
}
saveerr(ads,errno);
adns__diag(ads,-1,0,"cannot open configuration file `%s': %s",
filename,strerror(errno));
return;
}
readconfiggeneric(ads,filename,gl_file,gl_ctx);
fclose(gl_ctx.file);
}
static int gl_text(adns_state ads, getline_ctx *src_io, const char *filename,
int lno, char *buf, int buflen) {
const char *cp= src_io->text;
int l;
if (!cp || !*cp) return -1;
if (*cp == ';' || *cp == '\n') cp++;
l= strcspn(cp,";\n");
src_io->text = cp+l;
if (l >= buflen) {
adns__diag(ads,-1,0,"%s:%d: line too long, ignored",filename,lno);
saveerr(ads,EINVAL);
return -2;
}
memcpy(buf,cp,l);
buf[l]= 0;
return l;
}
static void ccf_options(adns_state ads, const char *fn, int lno, const char *buf) {
const char *word;
char *ep;
unsigned long v;
int l;
if (!buf) return;
while (nextword(&buf,&word,&l)) {
if (l==5 && !memcmp(word,"debug",5)) {
ads->iflags |= adns_if_debug;
continue;
}
if (l>=6 && !memcmp(word,"ndots:",6)) {
v= strtoul(word+6,&ep,10);
if (l==6 || ep != word+l || v > INT_MAX) {
configparseerr(ads,fn,lno,"option `%.*s' malformed or has bad value",l,word);
continue;
}
ads->searchndots= v;
continue;
}
if (l>=12 && !memcmp(word,"adns_checkc:",12)) {
if (!strcmp(word+12,"none")) {
ads->iflags &= ~adns_if_checkc_freq;
ads->iflags |= adns_if_checkc_entex;
} else if (!strcmp(word+12,"entex")) {
ads->iflags &= ~adns_if_checkc_freq;
ads->iflags |= adns_if_checkc_entex;
} else if (!strcmp(word+12,"freq")) {
ads->iflags |= adns_if_checkc_freq;
} else {
configparseerr(ads,fn,lno, "option adns_checkc has bad value `%s' "
"(must be none, entex or freq", word+12);
}
continue;
}
adns__diag(ads,-1,0,"%s:%d: unknown option `%.*s'", fn,lno, l,word);
}
}
static void readconfiggeneric(adns_state ads, const char *filename,
int (*getline)(adns_state ads, getline_ctx*,
const char *filename, int lno,
char *buf, int buflen),
/* Returns >=0 for success, -1 for EOF or error
* (error will have been reported), or -2 for
* bad line was encountered, try again.
*/
getline_ctx gl_ctx)
{
char linebuf[2000], *p, *q;
int lno, l, dirl;
const struct configcommandinfo *ccip;
for (lno=1;
(l= getline(ads,&gl_ctx, filename,lno, linebuf,sizeof(linebuf))) != -1;
lno++) {
if (l == -2) continue;
while (l>0 && ctype_whitespace(linebuf[l-1])) l--;
linebuf[l]= 0;
p= linebuf;
while (ctype_whitespace(*p)) p++;
if (*p == '#' || !*p) continue;
q= p;
while (*q && !ctype_whitespace(*q)) q++;
dirl= q-p;
for (ccip=configcommandinfos;
ccip->name && !(strlen(ccip->name)==dirl && !memcmp(ccip->name,p,q-p));
ccip++);
if (!ccip->name) {
adns__diag(ads,-1,0,"%s:%d: unknown configuration directive `%.*s'",
filename,lno,q-p,p);
continue;
}
while (ctype_whitespace(*q)) q++;
ccip->fn(ads,filename,lno,q);
}
}
static void ccf_sortlist(adns_state ads, const char *fn, int lno, const char *buf) {
const char *word;
char tbuf[200], *slash, *ep;
struct in_addr base, mask;
int l;
unsigned long initial, baselocal;
if (!buf) return;
ads->nsortlist= 0;
while (nextword(&buf,&word,&l)) {
if (ads->nsortlist >= MAXSORTLIST) {
adns__diag(ads,-1,0,"too many sortlist entries, ignoring %.*s onwards",l,word);
return;
}
if (l >= sizeof(tbuf)) {
configparseerr(ads,fn,lno,"sortlist entry `%.*s' too long",l,word);
continue;
}
memcpy(tbuf,word,l); tbuf[l]= 0;
slash= strchr(tbuf,'/');
if (slash) *slash++= 0;
if (!inet_aton(tbuf,&base)) {
configparseerr(ads,fn,lno,"invalid address `%s' in sortlist",tbuf);
continue;
}
if (slash) {
if (strchr(slash,'.')) {
if (!inet_aton(slash,&mask)) {
configparseerr(ads,fn,lno,"invalid mask `%s' in sortlist",slash);
continue;
}
if (base.s_addr & ~mask.s_addr) {
configparseerr(ads,fn,lno,
"mask `%s' in sortlist overlaps address `%s'",slash,tbuf);
continue;
}
} else {
initial= strtoul(slash,&ep,10);
if (*ep || initial>32) {
configparseerr(ads,fn,lno,"mask length `%s' invalid",slash);
continue;
}
mask.s_addr= htonl((0x0ffffffffUL) << (32-initial));
}
} else {
baselocal= ntohl(base.s_addr);
if (!baselocal & 0x080000000UL) /* class A */
mask.s_addr= htonl(0x0ff000000UL);
else if ((baselocal & 0x0c0000000UL) == 0x080000000UL)
mask.s_addr= htonl(0x0ffff0000UL); /* class B */
else if ((baselocal & 0x0f0000000UL) == 0x0e0000000UL)
mask.s_addr= htonl(0x0ff000000UL); /* class C */
else {
configparseerr(ads,fn,lno,
"network address `%s' in sortlist is not in classed ranges,"
" must specify mask explicitly", tbuf);
continue;
}
}
ads->sortlist[ads->nsortlist].base= base;
ads->sortlist[ads->nsortlist].mask= mask;
ads->nsortlist++;
}
}
void adns__procdgram(adns_state ads, const byte * dgram, int dglen,
int serv, int viatcp, struct timeval now)
{
int cbyte, rrstart, wantedrrs, rri, foundsoa, foundns, cname_here;
int id, f1, f2, qdcount, ancount, nscount, arcount;
int flg_ra, flg_rd, flg_tc, flg_qr, opcode;
int rrtype, rrclass, rdlength, rdstart;
int anstart, nsstart, arstart;
int ownermatched, l, nrrs;
unsigned long ttl, soattl;
const typeinfo *typei;
adns_query qu, nqu;
dns_rcode rcode;
adns_status st;
vbuf tempvb;
byte *newquery, *rrsdata;
parseinfo pai;
if (dglen < DNS_HDRSIZE) {
adns__diag(ads, serv, 0,
"received datagram too short for message header (%d)",
dglen);
return;
}
cbyte = 0;
GET_W(cbyte, id);
GET_B(cbyte, f1);
GET_B(cbyte, f2);
GET_W(cbyte, qdcount);
GET_W(cbyte, ancount);
GET_W(cbyte, nscount);
GET_W(cbyte, arcount);
assert(cbyte == DNS_HDRSIZE);
flg_qr = f1 & 0x80;
opcode = (f1 & 0x78) >> 3;
flg_tc = f1 & 0x02;
flg_rd = f1 & 0x01;
flg_ra = f2 & 0x80;
rcode = (f2 & 0x0f);
cname_here = 0;
if (!flg_qr) {
adns__diag(ads, serv, 0,
"server sent us a query, not a response");
return;
}
if (opcode) {
adns__diag(ads, serv, 0,
"server sent us unknown opcode %d (wanted 0=QUERY)",
opcode);
return;
}
qu = 0;
/* See if we can find the relevant query, or leave qu=0 otherwise ... */
if (qdcount == 1) {
for (qu = viatcp ? ads->tcpw.head : ads->udpw.head; qu;
qu = nqu) {
nqu = qu->next;
if (qu->id != id)
continue;
if (dglen < qu->query_dglen)
continue;
if (memcmp(qu->query_dgram + DNS_HDRSIZE,
dgram + DNS_HDRSIZE,
qu->query_dglen - DNS_HDRSIZE))
continue;
if (viatcp) {
assert(qu->state == query_tcpw);
} else {
assert(qu->state == query_tosend);
if (!(qu->udpsent & (1 << serv)))
continue;
}
break;
}
if (qu) {
/* We're definitely going to do something with this query now */
if (viatcp)
ALIST_UNLINK(ads->tcpw, qu);
else
ALIST_UNLINK(ads->udpw, qu);
}
}
/* If we're going to ignore the packet, we return as soon as we have
* failed the query (if any) and printed the warning message (if
* any).
*/
switch (rcode) {
case rcode_noerror:
case rcode_nxdomain:
break;
case rcode_formaterror:
adns__warn(ads, serv, qu,
"server cannot understand our query (Format Error)");
if (qu)
adns__query_fail(qu, adns_s_rcodeformaterror);
return;
case rcode_servfail:
if (qu)
adns__query_fail(qu, adns_s_rcodeservfail);
else
adns__debug(ads, serv, qu,
"server failure on unidentifiable query");
return;
case rcode_notimp:
adns__warn(ads, serv, qu,
"server claims not to implement our query");
if (qu)
adns__query_fail(qu, adns_s_rcodenotimplemented);
return;
case rcode_refused:
adns__debug(ads, serv, qu, "server refused our query");
if (qu)
adns__query_fail(qu, adns_s_rcoderefused);
return;
default:
adns__warn(ads, serv, qu,
"server gave unknown response code %d", rcode);
if (qu)
adns__query_fail(qu, adns_s_rcodeunknown);
return;
}
if (!qu) {
if (!qdcount) {
adns__diag(ads, serv, 0,
"server sent reply without quoting our question");
} else if (qdcount > 1) {
adns__diag(ads, serv, 0,
"server claimed to answer %d questions with one message",
qdcount);
} else if (ads->iflags & adns_if_debug) {
adns__vbuf_init(&tempvb);
adns__debug(ads, serv, 0,
"reply not found, id %02x, query owner %s",
id, adns__diag_domain(ads, serv, 0,
&tempvb, dgram,
dglen,
DNS_HDRSIZE));
adns__vbuf_free(&tempvb);
}
return;
}
/* We're definitely going to do something with this packet and this query now. */
anstart = qu->query_dglen;
arstart = -1;
/* Now, take a look at the answer section, and see if it is complete.
* If it has any CNAMEs we stuff them in the answer.
*/
wantedrrs = 0;
cbyte = anstart;
for (rri = 0; rri < ancount; rri++) {
rrstart = cbyte;
st = adns__findrr(qu, serv, dgram, dglen, &cbyte,
&rrtype, &rrclass, &ttl, &rdlength,
&rdstart, &ownermatched);
if (st) {
adns__query_fail(qu, st);
return;
}
if (rrtype == -1)
goto x_truncated;
if (rrclass != DNS_CLASS_IN) {
adns__diag(ads, serv, qu,
"ignoring answer RR with wrong class %d (expected IN=%d)",
rrclass, DNS_CLASS_IN);
continue;
}
if (!ownermatched) {
if (ads->iflags & adns_if_debug) {
adns__debug(ads, serv, qu,
"ignoring RR with an unexpected owner %s",
adns__diag_domain(ads, serv,
qu, &qu->vb,
dgram, dglen,
rrstart));
}
continue;
}
if (rrtype == adns_r_cname &&
(qu->typei->type & adns__rrt_typemask) !=
adns_r_cname) {
if (qu->flags & adns_qf_cname_forbid) {
adns__query_fail(qu,
adns_s_prohibitedcname);
return;
} else if (qu->cname_dgram) { /* Ignore second and subsequent CNAME(s) */
adns__debug(ads, serv, qu,
"allegedly canonical name %s is actually alias for %s",
qu->answer->cname,
adns__diag_domain(ads, serv,
qu, &qu->vb,
dgram, dglen,
rdstart));
adns__query_fail(qu,
adns_s_prohibitedcname);
return;
} else if (wantedrrs) { /* Ignore CNAME(s) after RR(s). */
adns__debug(ads, serv, qu,
"ignoring CNAME (to %s) coexisting with RR",
adns__diag_domain(ads, serv,
qu, &qu->vb,
dgram, dglen,
rdstart));
} else {
qu->cname_begin = rdstart;
qu->cname_dglen = dglen;
st = adns__parse_domain(ads, serv, qu,
&qu->vb,
qu->
flags &
adns_qf_quotefail_cname
? 0 : pdf_quoteok,
dgram, dglen,
&rdstart,
rdstart +
rdlength);
if (!qu->vb.used)
goto x_truncated;
if (st) {
adns__query_fail(qu, st);
return;
}
l = strlen((char *)qu->vb.buf) + 1;
qu->answer->cname =
adns__alloc_preserved(qu, l);
if (!qu->answer->cname) {
adns__query_fail(qu,
adns_s_nomemory);
return;
}
qu->cname_dgram =
adns__alloc_mine(qu, dglen);
os_memcpy(qu->cname_dgram, dgram, dglen);
os_memcpy(qu->answer->cname, qu->vb.buf, l);
cname_here = 1;
adns__update_expires(qu, ttl, now);
/* If we find the answer section truncated after this point we restart
* the query at the CNAME; if beforehand then we obviously have to use
* TCP. If there is no truncation we can use the whole answer if
* it contains the relevant info.
*/
}
} else if (rrtype ==
(qu->typei->type & adns__rrt_typemask)) {
wantedrrs++;
} else {
adns__debug(ads, serv, qu,
"ignoring answer RR with irrelevant type %d",
rrtype);
}
}
/* We defer handling truncated responses here, in case there was a CNAME
* which we could use.
*/
if (flg_tc)
goto x_truncated;
nsstart = cbyte;
if (!wantedrrs) {
/* Oops, NODATA or NXDOMAIN or perhaps a referral (which would be a problem) */
/* RFC2308: NODATA has _either_ a SOA _or_ _no_ NS records in authority section */
foundsoa = 0;
soattl = 0;
foundns = 0;
for (rri = 0; rri < nscount; rri++) {
rrstart = cbyte;
st = adns__findrr(qu, serv, dgram, dglen, &cbyte,
&rrtype, &rrclass, &ttl,
&rdlength, &rdstart, 0);
if (st) {
adns__query_fail(qu, st);
return;
}
if (rrtype == -1)
goto x_truncated;
if (rrclass != DNS_CLASS_IN) {
adns__diag(ads, serv, qu,
"ignoring authority RR with wrong class %d (expected IN=%d)",
rrclass, DNS_CLASS_IN);
continue;
}
if (rrtype == adns_r_soa_raw) {
foundsoa = 1;
soattl = ttl;
break;
} else if (rrtype == adns_r_ns_raw) {
foundns = 1;
}
}
if (rcode == rcode_nxdomain) {
/* We still wanted to look for the SOA so we could find the TTL. */
adns__update_expires(qu, soattl, now);
if (qu->flags & adns_qf_search) {
adns__search_next(ads, qu, now);
} else {
adns__query_fail(qu, adns_s_nxdomain);
}
return;
}
if (foundsoa || !foundns) {
/* Aha ! A NODATA response, good. */
adns__update_expires(qu, soattl, now);
adns__query_fail(qu, adns_s_nodata);
return;
}
/* Now what ? No relevant answers, no SOA, and at least some NS's.
* Looks like a referral. Just one last chance ... if we came across
* a CNAME in this datagram then we should probably do our own CNAME
* lookup now in the hope that we won't get a referral again.
*/
if (cname_here)
goto x_restartquery;
/* Bloody hell, I thought we asked for recursion ? */
if (!flg_ra) {
adns__diag(ads, serv, qu,
"server is not willing to do recursive lookups for us");
adns__query_fail(qu, adns_s_norecurse);
} else {
if (!flg_rd)
adns__diag(ads, serv, qu,
"server thinks we didn't ask for recursive lookup");
else
adns__debug(ads, serv, qu,
"server claims to do recursion, but gave us a referral");
adns__query_fail(qu, adns_s_invalidresponse);
}
return;
}
/* Now, we have some RRs which we wanted. */
qu->answer->rrs.untyped =
adns__alloc_interim(qu, qu->typei->rrsz * wantedrrs);
if (!qu->answer->rrs.untyped) {
adns__query_fail(qu, adns_s_nomemory);
return;
}
typei = qu->typei;
cbyte = anstart;
rrsdata = qu->answer->rrs.bytes;
pai.ads = qu->ads;
pai.qu = qu;
pai.serv = serv;
pai.dgram = dgram;
pai.dglen = dglen;
pai.nsstart = nsstart;
pai.nscount = nscount;
pai.arcount = arcount;
pai.now = now;
for (rri = 0, nrrs = 0; rri < ancount; rri++) {
st = adns__findrr(qu, serv, dgram, dglen, &cbyte,
&rrtype, &rrclass, &ttl, &rdlength,
&rdstart, &ownermatched);
assert(!st);
assert(rrtype != -1);
if (rrclass != DNS_CLASS_IN ||
rrtype != (qu->typei->type & adns__rrt_typemask) ||
!ownermatched)
continue;
adns__update_expires(qu, ttl, now);
st = typei->parse(&pai, rdstart, rdstart + rdlength,
rrsdata + nrrs * typei->rrsz);
if (st) {
adns__query_fail(qu, st);
return;
}
if (rdstart == -1)
goto x_truncated;
nrrs++;
}
assert(nrrs == wantedrrs);
qu->answer->nrrs = nrrs;
/* This may have generated some child queries ... */
if (qu->children.head) {
qu->state = query_childw;
ALIST_LINK_TAIL(ads->childw, qu);
return;
}
adns__query_done(qu);
return;
x_truncated:
if (!flg_tc) {
adns__diag(ads, serv, qu,
"server sent datagram which points outside itself");
adns__query_fail(qu, adns_s_invalidresponse);
return;
}
qu->flags |= adns_qf_usevc;
x_restartquery:
if (qu->cname_dgram) {
st = adns__mkquery_frdgram(qu->ads, &qu->vb, &qu->id,
qu->cname_dgram,
qu->cname_dglen,
qu->cname_begin,
qu->typei->type, qu->flags);
if (st) {
adns__query_fail(qu, st);
return;
}
newquery = ns_realloc(qu->query_dgram, qu->vb.used);
if (!newquery) {
adns__query_fail(qu, adns_s_nomemory);
return;
}
qu->query_dgram = newquery;
qu->query_dglen = qu->vb.used;
os_memcpy(newquery, qu->vb.buf, qu->vb.used);
}
if (qu->state == query_tcpw)
qu->state = query_tosend;
qu->retries = 0;
adns__reset_preserved(qu);
adns__query_send(qu, now);
}
int adns_init(adns_state *ads_r, adns_initflags flags, FILE *diagfile) {
adns_state ads;
const char *res_options, *adns_res_options;
int r;
#ifdef ADNS_JGAA_WIN32
#define SECURE_PATH_LEN (MAX_PATH - 64)
char PathBuf[MAX_PATH];
struct in_addr addr;
#define ADNS_PFIXED_INFO_BLEN (2048)
PFIXED_INFO network_info = (PFIXED_INFO)alloca(ADNS_PFIXED_INFO_BLEN);
ULONG network_info_blen = ADNS_PFIXED_INFO_BLEN;
DWORD network_info_result;
PIP_ADDR_STRING pip;
const char *network_err_str = "";
#endif
r= init_begin(&ads, flags, diagfile ? diagfile : stderr);
if (r) return r;
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);
#ifdef ADNS_JGAA_WIN32
GetWindowsDirectory(PathBuf, SECURE_PATH_LEN);
strcat(PathBuf,"\\resolv.conf");
readconfig(ads,PathBuf,1);
GetWindowsDirectory(PathBuf, SECURE_PATH_LEN);
strcat(PathBuf,"\\resolv-adns.conf");
readconfig(ads,PathBuf,0);
GetWindowsDirectory(PathBuf, SECURE_PATH_LEN);
strcat(PathBuf,"\\System32\\Drivers\\etc\\resolv.conf");
readconfig(ads,PathBuf,1);
GetWindowsDirectory(PathBuf, SECURE_PATH_LEN);
strcat(PathBuf,"\\System32\\Drivers\\etc\\resolv-adns.conf");
readconfig(ads,PathBuf,0);
network_info_result = GetNetworkParams(network_info, &network_info_blen);
if (network_info_result != ERROR_SUCCESS){
switch(network_info_result) {
case ERROR_BUFFER_OVERFLOW: network_err_str = "ERROR_BUFFER_OVERFLOW"; break;
case ERROR_INVALID_PARAMETER: network_err_str = "ERROR_INVALID_PARAMETER"; break;
case ERROR_NO_DATA: network_err_str = "ERROR_NO_DATA"; break;
case ERROR_NOT_SUPPORTED: network_err_str = "ERROR_NOT_SUPPORTED"; break;}
adns__diag(ads,-1,0,"GetNetworkParams() failed with error [%d] %s",
network_info_result,network_err_str);
}
else {
for(pip = &(network_info->DnsServerList); pip; pip = pip->Next) {
addr.s_addr = inet_addr(pip->IpAddress.String);
if ((addr.s_addr != INADDR_ANY) && (addr.s_addr != INADDR_NONE))
addserver(ads, addr);
}
}
#else
readconfig(ads,"/etc/resolv.conf",1);
readconfig(ads,"/etc/resolv-adns.conf",0);
#endif
readconfigenv(ads,"RES_CONF");
readconfigenv(ads,"ADNS_RES_CONF");
readconfigenvtext(ads,"RES_CONF_TEXT");
readconfigenvtext(ads,"ADNS_RES_CONF_TEXT");
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->configerrno && ads->configerrno != EINVAL) {
r= ads->configerrno;
init_abort(ads);
return r;
}
r= init_finish(ads);
if (r) return r;
adns__consistency(ads,0,cc_entex);
*ads_r= ads;
return 0;
}