Exemplo n.º 1
0
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;
}
Exemplo n.º 2
0
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++;
}
Exemplo n.º 3
0
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;
}
Exemplo n.º 4
0
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;
}
Exemplo n.º 5
0
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);
}
Exemplo n.º 6
0
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;
}
Exemplo n.º 7
0
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);
  }
}
Exemplo n.º 8
0
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);
  }
}
Exemplo n.º 9
0
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++;
  }
}
Exemplo n.º 10
0
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);
}
Exemplo n.º 11
0
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;
}