internal.h File Reference

#include "config.h"
#include <stdarg.h>
#include <assert.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <string.h>
#include <sys/time.h>
#include "adns.h"
#include "dlist.h"

Include dependency graph for internal.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
union	rr_align
struct	vbuf
struct	parseinfo
struct	typeinfo
struct	allocnode
union	maxalign
struct	qcontext
struct	adns__query
struct	query_queue
struct	adns__state
struct	adns__state::server
struct	adns__state::sortlist
struct	findlabel_state

Macros
#define	MAXSERVERS   5
#define	MAXSORTLIST   15
#define	UDPMAXRETRIES   15
#define	UDPRETRYMS   2000
#define	TCPWAITMS   30000
#define	TCPCONNMS   14000
#define	TCPIDLEMS   30000
#define	MAXTTLBELIEVE   (7*86400) /* any TTL > 7 days is capped */
#define	DNS_PORT   53
#define	DNS_MAXUDP   512
#define	DNS_MAXLABEL   63
#define	DNS_MAXDOMAIN   255
#define	DNS_HDRSIZE   12
#define	DNS_IDOFFSET   0
#define	DNS_CLASS_IN   1
#define	DNS_INADDR_ARPA   "in-addr", "arpa"
#define	MAX_POLLFDS   ADNS_POLLFDS_RECOMMENDED
#define	MEM_ROUND(sz)
#define	GETIL_B(cb)   (((dgram)[(cb)++]) & 0x0ff)
#define	GET_B(cb, tv)   ((tv)= GETIL_B((cb)))
#define	GET_W(cb, tv)   ((tv)=0, (tv)|=(GETIL_B((cb))<<8), (tv)|=GETIL_B(cb), (tv))
#define	GET_L(cb, tv)

Typedefs
typedef unsigned char	byte
typedef struct allocnode	allocnode

Enumerations
enum	consistency_checks { cc_user , cc_entex , cc_freq }
enum	dns_rcode {   rcode_noerror , rcode_formaterror , rcode_servfail , rcode_nxdomain ,   rcode_notimp , rcode_refused }
enum	parsedomain_flags { pdf_quoteok = 0x001 }

Functions
int	adns__setnonblock (adns_state ads, ADNS_SOCKET fd)
void	adns__vdiag (adns_state ads, const char *pfx, adns_initflags prevent, int serv, adns_query qu, const char *fmt, va_list al)
void	adns__debug (adns_state ads, int serv, adns_query qu, const char *fmt,...) PRINTFFORMAT(4
void void	adns__warn (adns_state ads, int serv, adns_query qu, const char *fmt,...) PRINTFFORMAT(4
void void void	adns__diag (adns_state ads, int serv, adns_query qu, const char *fmt,...) PRINTFFORMAT(4
void void void int	adns__vbuf_ensure (vbuf *vb, int want)
int	adns__vbuf_appendstr (vbuf *vb, const char *data)
int	adns__vbuf_append (vbuf *vb, const byte *data, int len)
void	adns__vbuf_appendq (vbuf *vb, const byte *data, int len)
void	adns__vbuf_init (vbuf *vb)
void	adns__vbuf_free (vbuf *vb)
const char *	adns__diag_domain (adns_state ads, int serv, adns_query qu, vbuf *vb, const byte *dgram, int dglen, int cbyte)
void	adns__isort (void *array, int nobjs, int sz, void *tempbuf, int(*needswap)(void *context, const void *a, const void *b), void *context)
void	adns__sigpipe_protect (adns_state)
void	adns__sigpipe_unprotect (adns_state)
adns_status	adns__mkquery (adns_state ads, vbuf *vb, int *id_r, const char *owner, int ol, const typeinfo *typei, adns_queryflags flags)
adns_status	adns__mkquery_frdgram (adns_state ads, vbuf *vb, int *id_r, const byte *qd_dgram, int qd_dglen, int qd_begin, adns_rrtype type, adns_queryflags flags)
void	adns__querysend_tcp (adns_query qu, struct timeval now)
void	adns__query_send (adns_query qu, struct timeval now)
adns_status	adns__internal_submit (adns_state ads, adns_query *query_r, const typeinfo *typei, vbuf *qumsg_vb, int id, adns_queryflags flags, struct timeval now, const qcontext *ctx)
void	adns__search_next (adns_state ads, adns_query qu, struct timeval now)
void *	adns__alloc_interim (adns_query qu, size_t sz)
void *	adns__alloc_preserved (adns_query qu, size_t sz)
void	adns__transfer_interim (adns_query from, adns_query to, void *block, size_t sz)
void *	adns__alloc_mine (adns_query qu, size_t sz)
void *	adns__alloc_final (adns_query qu, size_t sz)
void	adns__makefinal_block (adns_query qu, void **blpp, size_t sz)
void	adns__makefinal_str (adns_query qu, char **strp)
void	adns__reset_preserved (adns_query qu)
void	adns__query_done (adns_query qu)
void	adns__query_fail (adns_query qu, adns_status stat)
void	adns__procdgram (adns_state ads, const byte *dgram, int len, int serv, int viatcp, struct timeval now)
const typeinfo *	adns__findtype (adns_rrtype type)
void	adns__findlabel_start (findlabel_state *fls, adns_state ads, int serv, adns_query qu, const byte *dgram, int dglen, int max, int dmbegin, int *dmend_rlater)
adns_status	adns__findlabel_next (findlabel_state *fls, int *lablen_r, int *labstart_r)
adns_status	adns__parse_domain (adns_state ads, int serv, adns_query qu, vbuf *vb, adns_queryflags flags, const byte *dgram, int dglen, int *cbyte_io, int max)
adns_status	adns__parse_domain_more (findlabel_state *fls, adns_state ads, adns_query qu, vbuf *vb, parsedomain_flags flags, const byte *dgram)
adns_status	adns__findrr (adns_query qu, int serv, const byte *dgram, int dglen, int *cbyte_io, int *type_r, int *class_r, unsigned long *ttl_r, int *rdlen_r, int *rdstart_r, int *ownermatchedquery_r)
adns_status	adns__findrr_anychk (adns_query qu, int serv, const byte *dgram, int dglen, int *cbyte_io, int *type_r, int *class_r, unsigned long *ttl_r, int *rdlen_r, int *rdstart_r, const byte *eo_dgram, int eo_dglen, int eo_cbyte, int *eo_matched_r)
void	adns__update_expires (adns_query qu, unsigned long ttl, struct timeval now)
int	vbuf__append_quoted1035 (vbuf *vb, const byte *buf, int len)
void	adns__tcp_broken (adns_state ads, const char *what, const char *why)
void	adns__tcp_tryconnect (adns_state ads, struct timeval now)
void	adns__autosys (adns_state ads, struct timeval now)
void	adns__must_gettimeofday (adns_state ads, const struct timeval **now_io, struct timeval *tv_buf)
int	adns__pollfds (adns_state ads, struct pollfd pollfds_buf[MAX_POLLFDS])
void	adns__fdevents (adns_state ads, const struct pollfd *pollfds, int npollfds, int maxfd, const fd_set *readfds, const fd_set *writefds, const fd_set *exceptfds, struct timeval now, int *r_r)
int	adns__internal_check (adns_state ads, adns_query *query_io, adns_answer **answer, void **context_r)
void	adns__timeouts (adns_state ads, int act, struct timeval **tv_io, struct timeval *tvbuf, struct timeval now)
void	adns__consistency (adns_state ads, adns_query qu, consistency_checks cc)
static int	ctype_whitespace (int c)
static int	ctype_digit (int c)
static int	ctype_alpha (int c)
static int	ctype_822special (int c)
static int	ctype_domainunquoted (int c)
static int	errno_resources (int e)

Macro Definition Documentation

DNS_CLASS_IN

#define DNS_CLASS_IN   1

Definition at line 78 of file internal.h.

DNS_HDRSIZE

#define DNS_HDRSIZE   12

Definition at line 76 of file internal.h.

DNS_IDOFFSET

#define DNS_IDOFFSET   0

Definition at line 77 of file internal.h.

DNS_INADDR_ARPA

#define DNS_INADDR_ARPA   "in-addr", "arpa"

Definition at line 80 of file internal.h.

DNS_MAXDOMAIN

#define DNS_MAXDOMAIN   255

Definition at line 75 of file internal.h.

DNS_MAXLABEL

#define DNS_MAXLABEL   63

Definition at line 74 of file internal.h.

DNS_MAXUDP

#define DNS_MAXUDP   512

Definition at line 73 of file internal.h.

DNS_PORT

#define DNS_PORT   53

Definition at line 72 of file internal.h.

GET_B

#define GET_B	(		cb,
			tv
	)		((tv)= GETIL_B((cb)))

Definition at line 716 of file internal.h.

GET_L

#define GET_L	(		cb,
			tv
	)

Value:

               ( (tv)=0, \
               (tv)|=(GETIL_B((cb))<<24), \
               (tv)|=(GETIL_B((cb))<<16), \
               (tv)|=(GETIL_B((cb))<<8), \
               (tv)|=GETIL_B(cb), \
               (tv) )

Definition at line 718 of file internal.h.

GET_W

#define GET_W	(		cb,
			tv
	)		((tv)=0, (tv)|=(GETIL_B((cb))<<8), (tv)|=GETIL_B(cb), (tv))

Definition at line 717 of file internal.h.

GETIL_B

#define GETIL_B

(

cb

)

(((dgram)[(cb)++]) & 0x0ff)

Definition at line 715 of file internal.h.

MAX_POLLFDS

#define MAX_POLLFDS   ADNS_POLLFDS_RECOMMENDED

Definition at line 82 of file internal.h.

MAXSERVERS

#define MAXSERVERS   5

Definition at line 63 of file internal.h.

MAXSORTLIST

#define MAXSORTLIST   15

Definition at line 64 of file internal.h.

MAXTTLBELIEVE

#define MAXTTLBELIEVE   (7*86400) /* any TTL > 7 days is capped */

Definition at line 70 of file internal.h.

MEM_ROUND

#define MEM_ROUND

(

sz

)

Value:

  (( ((sz)+sizeof(union maxalign)-1) / sizeof(union maxalign) ) \
   * sizeof(union maxalign) )

Definition at line 711 of file internal.h.

TCPCONNMS

#define TCPCONNMS   14000

Definition at line 68 of file internal.h.

TCPIDLEMS

#define TCPIDLEMS   30000

Definition at line 69 of file internal.h.

TCPWAITMS

#define TCPWAITMS   30000

Definition at line 67 of file internal.h.

UDPMAXRETRIES

#define UDPMAXRETRIES   15

Definition at line 65 of file internal.h.

UDPRETRYMS

#define UDPRETRYMS   2000

Definition at line 66 of file internal.h.

Typedef Documentation

allocnode

typedef struct allocnode allocnode

byte

typedef unsigned char byte

Definition at line 36 of file internal.h.

Enumeration Type Documentation

consistency_checks

enum consistency_checks

Enumerator
cc_user
cc_entex
cc_freq

Definition at line 84 of file internal.h.

             {
  cc_user,
  cc_entex,
  cc_freq
} consistency_checks;

dns_rcode

enum dns_rcode

Enumerator
rcode_noerror
rcode_formaterror
rcode_servfail
rcode_nxdomain
rcode_notimp
rcode_refused

Definition at line 90 of file internal.h.

             {
  rcode_noerror,
  rcode_formaterror,
  rcode_servfail,
  rcode_nxdomain,
  rcode_notimp,
  rcode_refused
} dns_rcode;

parsedomain_flags

enum parsedomain_flags

Enumerator
pdf_quoteok

Definition at line 577 of file internal.h.

             {
  pdf_quoteok= 0x001
} parsedomain_flags;

Function Documentation

adns__alloc_final()

void * adns__alloc_final	(	adns_query	qu,
		size_t	sz
	)

Definition at line 385 of file query.c.

                                                  {
  /* When we're in the _final stage, we _subtract_ from interim_alloc'd
   * each allocation, and use final_allocspace to point to the next free
   * bit.
   */
  void *rp;
 
  sz= MEM_ROUND(sz);
  rp= qu->final_allocspace;
  assert(rp);
  qu->interim_allocd -= sz;
  assert(qu->interim_allocd>=0);
  qu->final_allocspace= (byte*)rp + sz;
  return rp;
}

Referenced by adns__makefinal_block(), and adns__makefinal_str().

adns__alloc_interim()

void * adns__alloc_interim	(	adns_query	qu,
		size_t	sz
	)

Definition at line 342 of file query.c.

                                                    {
  void *rv;
 
  sz= MEM_ROUND(sz);
  rv= alloc_common(qu,sz);
  if (!rv) return 0;
  qu->interim_allocd += sz;
  return rv;
}

Referenced by adns__alloc_preserved(), adns__procdgram(), pa_txt(), pap_domain(), pap_findaddrs(), pap_mailbox822(), and pap_qstring().

adns__alloc_mine()

void * adns__alloc_mine	(	adns_query	qu,
		size_t	sz
	)

Definition at line 362 of file query.c.

                                                 {
  return alloc_common(qu,MEM_ROUND(sz));
}

Referenced by adns__procdgram().

adns__alloc_preserved()

void * adns__alloc_preserved	(	adns_query	qu,
		size_t	sz
	)

Definition at line 352 of file query.c.

                                                      {
  void *rv;
 
  sz= MEM_ROUND(sz);
  rv= adns__alloc_interim(qu,sz);
  if (!rv) return 0;
  qu->preserved_allocd += sz;
  return rv;
}

Referenced by adns__procdgram(), and save_owner().

adns__autosys()

void adns__autosys	(	adns_state	ads,
		struct timeval	now
	)

Definition at line 665 of file event.c.

                                                       {
  if (ads->iflags & adns_if_noautosys) return;
  adns_processany(ads);
}

Referenced by adns_check(), and adns_submit().

adns__consistency()

void adns__consistency	(	adns_state	ads,
		adns_query	qu,
		consistency_checks	cc
	)

Definition at line 185 of file check.c.

                                                                             {
  adns_query search;
 
  switch (cc) {
  case cc_user:
    break;
  case cc_entex:
    if (!(ads->iflags & adns_if_checkc_entex)) return;
    break;
  case cc_freq:
    if ((ads->iflags & adns_if_checkc_freq) != adns_if_checkc_freq) return;
    break;
  default:
    abort();
  }
 
  checkc_global(ads);
  checkc_queue_udpw(ads);
  checkc_queue_tcpw(ads);
  checkc_queue_childw(ads);
  checkc_queue_output(ads);
 
  if (qu) {
    switch (qu->state) {
    case query_tosend:
      DLIST_ASSERTON(qu, search, ads->udpw, );
      break;
    case query_tcpw:
      DLIST_ASSERTON(qu, search, ads->tcpw, );
      break;
    case query_childw:
      DLIST_ASSERTON(qu, search, ads->childw, );
      break;
    case query_done:
      DLIST_ASSERTON(qu, search, ads->output, );
      break;
    default:
      assert(!"specific query state");
    }
  }
}

Referenced by adns_afterselect(), adns_beforeselect(), adns_cancel(), adns_check(), adns_checkconsistency(), adns_finish(), adns_firsttimeout(), adns_forallqueries_begin(), adns_forallqueries_next(), adns_globalsystemfailure(), adns_init(), adns_init_strcfg(), adns_processany(), adns_processexceptional(), adns_processreadable(), adns_processtimeouts(), adns_processwriteable(), adns_submit(), and adns_wait().

adns__debug()

void adns__debug	(	adns_state	ads,
		int	serv,
		adns_query	qu,
		const char *	fmt,
			...
	)

adns__diag()

void void void adns__diag	(	adns_state	ads,
		int	serv,
		adns_query	qu,
		const char *	fmt,
			...
	)

adns__diag_domain()

const char * adns__diag_domain	(	adns_state	ads,
		int	serv,
		adns_query	qu,
		vbuf *	vb,
		const byte *	dgram,
		int	dglen,
		int	cbyte
	)

Definition at line 162 of file general.c.

                                                                     {
  adns_status st;
 
  st= adns__parse_domain(ads,serv,qu,vb, pdf_quoteok, dgram,dglen,&cbyte,dglen);
  if (st == adns_s_nomemory) {
    return "<cannot report domain... out of memory>";
  }
  if (st) {
    vb->used= 0;
    if (!(adns__vbuf_appendstr(vb,"<bad format... ") &&
      adns__vbuf_appendstr(vb,adns_strerror(st)) &&
      adns__vbuf_appendstr(vb,">") &&
      adns__vbuf_append(vb,(byte*)"",1))) {
      return "<cannot report bad format... out of memory>";
    }
  }
  if (!vb->used) {
    adns__vbuf_appendstr(vb,"<truncated ...>");
    adns__vbuf_append(vb,(byte*)"",1);
  }
  return (char*)vb->buf;
}

Referenced by adns__procdgram(), and adns__vdiag().

adns__fdevents()

void adns__fdevents	(	adns_state	ads,
		const struct pollfd *	pollfds,
		int	npollfds,
		int	maxfd,
		const fd_set *	readfds,
		const fd_set *	writefds,
		const fd_set *	exceptfds,
		struct timeval	now,
		int *	r_r
	)

Definition at line 542 of file event.c.

                                          {
  int i, revents;
  ADNS_SOCKET fd;
 
  for (i=0; i<npollfds; i++) {
    fd= pollfds[i].fd;
    if ((int)fd >= maxfd) maxfd= fd+1;
    revents= pollfds[i].revents;
    fd_event(ads,fd, revents,POLLIN, maxfd,readfds, adns_processreadable,now,r_r);
    fd_event(ads,fd, revents,POLLOUT, maxfd,writefds, adns_processwriteable,now,r_r);
    fd_event(ads,fd, revents,POLLPRI, maxfd,exceptfds, adns_processexceptional,now,r_r);
  }
}

Referenced by adns_afterselect(), and adns_processany().

adns__findlabel_next()

adns_status adns__findlabel_next	(	findlabel_state *	fls,
		int *	lablen_r,
		int *	labstart_r
	)

Definition at line 74 of file parse.c.

                                                 {
  int lablen, jumpto;
  const char *dgram;
 
  dgram= (char*)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;
}

Referenced by adns__findrr_anychk(), adns__mkquery_frdgram(), adns__parse_domain_more(), pa_ptr(), and pap_mailbox822().

adns__findlabel_start()

void adns__findlabel_start	(	findlabel_state *	fls,
		adns_state	ads,
		int	serv,
		adns_query	qu,
		const byte *	dgram,
		int	dglen,
		int	max,
		int	dmbegin,
		int *	dmend_rlater
	)

Definition at line 59 of file parse.c.

                                               {
  fls->ads= ads;
  fls->qu= qu;
  fls->serv= serv;
  fls->dgram= dgram;
  fls->dglen= dglen;
  fls->max= max;
  fls->cbyte= dmbegin;
  fls->namelen= 0;
  fls->dmend_r= dmend_rlater;
}

Referenced by adns__findrr_anychk(), adns__mkquery_frdgram(), adns__parse_domain(), pa_ptr(), and pap_mailbox822().

adns__findrr()

adns_status adns__findrr	(	adns_query	qu,
		int	serv,
		const byte *	dgram,
		int	dglen,
		int *	cbyte_io,
		int *	type_r,
		int *	class_r,
		unsigned long *	ttl_r,
		int *	rdlen_r,
		int *	rdstart_r,
		int *	ownermatchedquery_r
	)

Definition at line 227 of file parse.c.

                                       {
  if (!ownermatchedquery_r) {
    return adns__findrr_anychk(qu,serv,
                   dgram,dglen,cbyte_io,
                   type_r,class_r,ttl_r,rdlen_r,rdstart_r,
                   0,0,0, 0);
  } else if (!qu->cname_dgram) {
    return adns__findrr_anychk(qu,serv,
                   dgram,dglen,cbyte_io,
                   type_r,class_r,ttl_r,rdlen_r,rdstart_r,
                   qu->query_dgram,qu->query_dglen,DNS_HDRSIZE,
                   ownermatchedquery_r);
  } else {
    return adns__findrr_anychk(qu,serv,
                   dgram,dglen,cbyte_io,
                   type_r,class_r,ttl_r,rdlen_r,rdstart_r,
                   qu->cname_dgram,qu->cname_dglen,qu->cname_begin,
                   ownermatchedquery_r);
  }
}

Referenced by adns__procdgram().

adns__findrr_anychk()

adns_status adns__findrr_anychk	(	adns_query	qu,
		int	serv,
		const byte *	dgram,
		int	dglen,
		int *	cbyte_io,
		int *	type_r,
		int *	class_r,
		unsigned long *	ttl_r,
		int *	rdlen_r,
		int *	rdstart_r,
		const byte *	eo_dgram,
		int	eo_dglen,
		int	eo_cbyte,
		int *	eo_matched_r
	)

Definition at line 163 of file parse.c.

                                   {
  findlabel_state fls, eo_fls;
  int cbyte;
 
  int tmp, rdlen, mismatch;
  unsigned long ttl;
  int lablen, labstart, ch;
  int eo_lablen, eo_labstart, eo_ch;
  adns_status st;
 
  cbyte= *cbyte_io;
 
  adns__findlabel_start(&fls,qu->ads, serv,qu, dgram,dglen,dglen,cbyte,&cbyte);
  if (eo_dgram) {
    adns__findlabel_start(&eo_fls,qu->ads, -1,0, eo_dgram,eo_dglen,eo_dglen,eo_cbyte,0);
    mismatch= 0;
  } else {
    mismatch= 1;
  }
 
  for (;;) {
    st= adns__findlabel_next(&fls,&lablen,&labstart);
    if (st) return st;
    if (lablen<0) goto x_truncated;
 
    if (!mismatch) {
      st= adns__findlabel_next(&eo_fls,&eo_lablen,&eo_labstart);
      assert(!st); assert(eo_lablen>=0);
      if (lablen != eo_lablen) mismatch= 1;
      while (!mismatch && eo_lablen-- > 0) {
    ch= dgram[labstart++]; if (ctype_alpha(ch)) ch &= ~32;
    eo_ch= eo_dgram[eo_labstart++]; if (ctype_alpha(eo_ch)) eo_ch &= ~32;
    if (ch != eo_ch) mismatch= 1;
      }
    }
    if (!lablen) break;
  }
  if (eo_matched_r) *eo_matched_r= !mismatch;
 
  if (cbyte+10>dglen) goto x_truncated;
  GET_W(cbyte,tmp); *type_r= tmp;
  GET_W(cbyte,tmp); *class_r= tmp;
 
  GET_L(cbyte,ttl);
  if (ttl > MAXTTLBELIEVE) ttl= MAXTTLBELIEVE;
  *ttl_r= ttl;
 
  GET_W(cbyte,rdlen); if (rdlen_r) *rdlen_r= rdlen;
  if (rdstart_r) *rdstart_r= cbyte;
  cbyte+= rdlen;
  if (cbyte>dglen) goto x_truncated;
  *cbyte_io= cbyte;
  return adns_s_ok;
 
 x_truncated:
  *type_r= -1;
  return 0;
}

Referenced by adns__findrr(), and pap_findaddrs().

adns__findtype()

const typeinfo * adns__findtype

(

adns_rrtype

type

)

Definition at line 1025 of file types.c.

                                                 {
  const typeinfo *begin, *end, *mid;
 
  begin= typeinfos;  end= typeinfos+(sizeof(typeinfos)/sizeof(typeinfo));
 
  while (begin < end) {
    mid= begin + ((end-begin)>>1);
    if (mid->type == type) return mid;
    if (type > mid->type) begin= mid+1;
    else end= mid;
  }
  return 0;
}

Referenced by adns_rr_info(), adns_submit(), pa_ptr(), and pap_hostaddr().

adns__internal_check()

int adns__internal_check	(	adns_state	ads,
		adns_query *	query_io,
		adns_answer **	answer,
		void **	context_r
	)

Definition at line 670 of file event.c.

                               {
  adns_query qu;
 
  qu= *query_io;
  if (!qu) {
    if (ads->output.head) {
      qu= ads->output.head;
    } else if (ads->udpw.head || ads->tcpw.head) {
      return EAGAIN;
    } else {
      return ESRCH;
    }
  } else {
    if (qu->id>=0) return EAGAIN;
  }
  LIST_UNLINK(ads->output,qu);
  *answer= qu->answer;
  if (context_r) *context_r= qu->ctx.ext;
  *query_io= qu;
  free(qu);
  return 0;
}

Referenced by adns_check(), and adns_wait().

adns__internal_submit()

adns_status adns__internal_submit	(	adns_state	ads,
		adns_query *	query_r,
		const typeinfo *	typei,
		vbuf *	qumsg_vb,
		int	id,
		adns_queryflags	flags,
		struct timeval	now,
		const qcontext *	ctx
	)

Definition at line 111 of file query.c.

                                       {
  adns_query qu;
 
  qu= query_alloc(ads,typei,flags,now);
  if (!qu) { adns__vbuf_free(qumsg_vb); return adns_s_nomemory; }
  *query_r= qu;
 
  memcpy(&qu->ctx,ctx,(size_t) sizeof(qu->ctx));
  query_submit(ads,qu, typei,qumsg_vb,id,flags,now);
 
  return adns_s_ok;
}

Referenced by pa_ptr(), and pap_hostaddr().

adns__isort()

void adns__isort	(	void *	array,
		int	nobjs,
		int	sz,
		void *	tempbuf,
		int(*)(void *context, const void *a, const void *b)	needswap,
		void *	context
	)

Definition at line 319 of file general.c.

                        {
  byte *data= array;
  int i, place;
 
  for (i=0; i<nobjs; i++) {
    for (place= i;
     place>0 && needswap(context, data + (place-1)*sz, data + i*sz);
     place--);
    if (place != i) {
      memcpy(tempbuf, data + i*sz, (size_t) sz);
      memmove(data + (place+1)*sz, data + place*sz, (size_t) (i-place)*sz);
      memcpy(data + place*sz, tempbuf, (size_t) sz);
    }
  }
}

Referenced by adns__query_done(), and pap_findaddrs().

adns__makefinal_block()

void adns__makefinal_block	(	adns_query	qu,
		void **	blpp,
		size_t	sz
	)

Definition at line 565 of file query.c.

                                                                  {
  void *before, *after;
 
  before= *blpp;
  if (!before) return;
  after= adns__alloc_final(qu,sz);
  memcpy(after,before, (size_t) sz);
  *blpp= after;
}

Referenced by makefinal_query(), mf_manyistr(), and mfp_hostaddr().

adns__makefinal_str()

void adns__makefinal_str	(	adns_query	qu,
		char **	strp
	)

Definition at line 553 of file query.c.

                                                     {
  int l;
  char *before, *after;
 
  before= *strp;
  if (!before) return;
  l= strlen(before)+1;
  after= adns__alloc_final(qu, (size_t) l);
  memcpy(after,before,(size_t) l);
  *strp= after;
}

Referenced by makefinal_query(), mf_intstr(), mf_intstrpair(), mf_manyistr(), mf_soa(), mf_str(), mf_strpair(), and mfp_hostaddr().

adns__mkquery()

adns_status adns__mkquery	(	adns_state	ads,
		vbuf *	vb,
		int *	id_r,
		const char *	owner,
		int	ol,
		const typeinfo *	typei,
		adns_queryflags	flags
	)

Definition at line 81 of file transmit.c.

                                                            {
  int ll, c, nbytes;
  byte label[255], *rqp;
  const char *p, *pe;
  adns_status st;
 
  st= mkquery_header(ads,vb,id_r,ol+2); if (st) return st;
 
  MKQUERY_START(vb);
 
  p= owner; pe= owner+ol;
  nbytes= 0;
  while (p!=pe) {
    ll= 0;
    while (p!=pe && (c= *p++)!='.') {
      if (c=='\\') {
    if (!(flags & adns_qf_quoteok_query)) return adns_s_querydomaininvalid;
    if (ctype_digit(p[0])) {
      if (ctype_digit(p[1]) && ctype_digit(p[2])) {
        c= (p[0] - '0')*100 + (p[1] - '0')*10 + (p[2] - '0');
        p += 3;
        if (c >= 256) return adns_s_querydomaininvalid;
      } else {
        return adns_s_querydomaininvalid;
      }
    } else if (!(c= *p++)) {
      return adns_s_querydomaininvalid;
    }
      }
      if (!(flags & adns_qf_quoteok_query)) {
    if (c == '-') {
      if (!ll) return adns_s_querydomaininvalid;
    } else if (!ctype_alpha(c) && !ctype_digit(c)) {
      return adns_s_querydomaininvalid;
    }
      }
      if (ll == sizeof(label)) return adns_s_querydomaininvalid;
      label[ll++]= c;
    }
    if (!ll) return adns_s_querydomaininvalid;
    if (ll > DNS_MAXLABEL) return adns_s_querydomaintoolong;
    nbytes+= ll+1;
    if (nbytes >= DNS_MAXDOMAIN) return adns_s_querydomaintoolong;
    MKQUERY_ADDB(ll);
    memcpy(rqp,label,(size_t) ll); rqp+= ll;
  }
  MKQUERY_ADDB(0);
 
  MKQUERY_STOP(vb);
 
  st= mkquery_footer(vb,typei->type);
 
  return adns_s_ok;
}

Referenced by query_simple().

adns__mkquery_frdgram()

adns_status adns__mkquery_frdgram	(	adns_state	ads,
		vbuf *	vb,
		int *	id_r,
		const byte *	qd_dgram,
		int	qd_dglen,
		int	qd_begin,
		adns_rrtype	type,
		adns_queryflags	flags
	)

Definition at line 138 of file transmit.c.

                                                           {
  byte *rqp;
  findlabel_state fls;
  int lablen, labstart;
  adns_status st;
 
  st= mkquery_header(ads,vb,id_r,qd_dglen); if (st) return st;
 
  MKQUERY_START(vb);
 
  adns__findlabel_start(&fls,ads,-1,0,qd_dgram,qd_dglen,qd_dglen,qd_begin,0);
  for (;;) {
    st= adns__findlabel_next(&fls,&lablen,&labstart); assert(!st);
    if (!lablen) break;
    assert(lablen<255);
    MKQUERY_ADDB(lablen);
    memcpy(rqp,qd_dgram+labstart, (size_t) lablen);
    rqp+= lablen;
  }
  MKQUERY_ADDB(0);
 
  MKQUERY_STOP(vb);
 
  st= mkquery_footer(vb,type);
 
  return adns_s_ok;
}

Referenced by adns__procdgram(), pa_ptr(), and pap_hostaddr().

adns__must_gettimeofday()

void adns__must_gettimeofday	(	adns_state	ads,
		const struct timeval **	now_io,
		struct timeval *	tv_buf
	)

Definition at line 149 of file event.c.

                                         {
  const struct timeval *now;
  int r;
 
  now= *now_io;
  if (now) return;
  r= gettimeofday(tv_buf,0); if (!r) { *now_io= tv_buf; return; }
  adns__diag(ads,-1,0,"gettimeofday failed: %s",strerror(errno));
  adns_globalsystemfailure(ads);
  return;
}

Referenced by adns_afterselect(), adns_beforeselect(), and adns_processtimeouts().

adns__parse_domain()

adns_status adns__parse_domain	(	adns_state	ads,
		int	serv,
		adns_query	qu,
		vbuf *	vb,
		adns_queryflags	flags,
		const byte *	dgram,
		int	dglen,
		int *	cbyte_io,
		int	max
	)

Definition at line 117 of file parse.c.

                                                                         {
  findlabel_state fls;
 
  adns__findlabel_start(&fls,ads, serv,qu, dgram,dglen,max, *cbyte_io,cbyte_io);
  vb->used= 0;
  return adns__parse_domain_more(&fls,ads,qu, vb,flags,dgram);
}

Referenced by adns__diag_domain(), adns__procdgram(), and pap_domain().

adns__parse_domain_more()

adns_status adns__parse_domain_more	(	findlabel_state *	fls,
		adns_state	ads,
		adns_query	qu,
		vbuf *	vb,
		parsedomain_flags	flags,
		const byte *	dgram
	)

Definition at line 127 of file parse.c.

                                       {
  int lablen, labstart, i, ch, first;
  adns_status st;
 
  first= 1;
  for (;;) {
    st= adns__findlabel_next(fls,&lablen,&labstart);
    if (st) return st;
    if (lablen<0) { vb->used=0; return adns_s_ok; }
    if (!lablen) break;
    if (first) {
      first= 0;
    } else {
      if (!adns__vbuf_append(vb,(byte*)".",1)) return adns_s_nomemory;
    }
    if (flags & pdf_quoteok) {
      if (!vbuf__append_quoted1035(vb,dgram+labstart,lablen))
    return adns_s_nomemory;
    } else {
      ch= dgram[labstart];
      if (!ctype_alpha(ch) && !ctype_digit(ch)) return adns_s_answerdomaininvalid;
      for (i= labstart+1; i<labstart+lablen; i++) {
    ch= dgram[i];
    if (ch != '-' && !ctype_alpha(ch) && !ctype_digit(ch))
      return adns_s_answerdomaininvalid;
      }
      if (!adns__vbuf_append(vb,dgram+labstart,lablen))
    return adns_s_nomemory;
    }
  }
  if (!adns__vbuf_append(vb,(byte*)"",1)) return adns_s_nomemory;
  return adns_s_ok;
}

Referenced by adns__parse_domain(), and pap_mailbox822().

adns__pollfds()

int adns__pollfds	(	adns_state	ads,
		struct pollfd	pollfds_buf[MAX_POLLFDS]
	)

Definition at line 312 of file event.c.

                                                                          {
  /* Returns the number of entries filled in.  Always zeroes revents. */
 
  assert(MAX_POLLFDS==2);
 
  pollfds_buf[0].fd= ads->udpsocket;
  pollfds_buf[0].events= POLLIN;
  pollfds_buf[0].revents= 0;
 
  switch (ads->tcpstate) {
  case server_disconnected:
  case server_broken:
    return 1;
  case server_connecting:
    pollfds_buf[1].events= POLLOUT;
    break;
  case server_ok:
    pollfds_buf[1].events= ads->tcpsend.used ? POLLIN|POLLOUT|POLLPRI : POLLIN|POLLPRI;
    break;
  default:
    abort();
  }
  pollfds_buf[1].fd= ads->tcpsocket;
  return 2;
}

Referenced by adns_afterselect(), adns_beforeselect(), and adns_processany().

adns__procdgram()

void adns__procdgram	(	adns_state	ads,
		const byte *	dgram,
		int	len,
		int	serv,
		int	viatcp,
		struct timeval	now
	)

Definition at line 36 of file reply.c.

                                                       {
  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,
         (size_t) 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) LIST_UNLINK(ads->tcpw,qu);
      else LIST_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,(size_t) l);
    if (!qu->answer->cname) { adns__query_fail(qu,adns_s_nomemory); return; }
 
    qu->cname_dgram= adns__alloc_mine(qu, (size_t) dglen);
    memcpy(qu->cname_dgram,dgram,(size_t) dglen);
 
    memcpy(qu->answer->cname,qu->vb.buf, (size_t) 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 == ((INT)qu->typei->type & (INT)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,(size_t) 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 != ((INT)qu->typei->type & (INT)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;
    LIST_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= realloc(qu->query_dgram, (size_t) qu->vb.used);
    if (!newquery) { adns__query_fail(qu,adns_s_nomemory); return; }
 
    qu->query_dgram= newquery;
    qu->query_dglen= qu->vb.used;
    memcpy(newquery,qu->vb.buf, (size_t) qu->vb.used);
  }
 
  if (qu->state == query_tcpw) qu->state= query_tosend;
  qu->retries= 0;
  adns__reset_preserved(qu);
  adns__query_send(qu,now);
}

Referenced by adns_processreadable().

adns__query_done()

void adns__query_done

(

adns_query

qu

)

Definition at line 503 of file query.c.

                                     {
  adns_answer *ans;
  adns_query parent;
 
  cancel_children(qu);
 
  qu->id= -1;
  ans= qu->answer;
 
  if (qu->flags & adns_qf_owner && qu->flags & adns_qf_search &&
      ans->status != adns_s_nomemory) {
    if (!save_owner(qu, (char*)qu->search_vb.buf, qu->search_vb.used)) {
      adns__query_fail(qu,adns_s_nomemory);
      return;
    }
  }
 
  if (ans->nrrs && qu->typei->diff_needswap) {
    if (!adns__vbuf_ensure(&qu->vb,qu->typei->rrsz)) {
      adns__query_fail(qu,adns_s_nomemory);
      return;
    }
    adns__isort(ans->rrs.bytes, ans->nrrs, ans->rrsz,
        qu->vb.buf,
        (int(*)(void*, const void*, const void*))qu->typei->diff_needswap,
        qu->ads);
  }
 
  ans->expires= qu->expires;
  parent= qu->parent;
  if (parent) {
    LIST_UNLINK_PART(parent->children,qu,siblings.);
    LIST_UNLINK(qu->ads->childw,parent);
    qu->ctx.callback(parent,qu);
    free_query_allocs(qu);
    free(qu->answer);
    free(qu);
  } else {
    makefinal_query(qu);
    LIST_LINK_TAIL(qu->ads->output,qu);
    qu->state= query_done;
  }
}

Referenced by adns__procdgram(), adns__query_fail(), icb_hostaddr(), and icb_ptr().

adns__query_fail()

void adns__query_fail	(	adns_query	qu,
		adns_status	stat
	)

Definition at line 547 of file query.c.

                                                       {
  adns__reset_preserved(qu);
  qu->answer->status= stat;
  adns__query_done(qu);
}

Referenced by adns__procdgram(), adns__query_done(), adns__query_send(), adns__search_next(), adns_globalsystemfailure(), adns_submit(), icb_ptr(), query_simple(), query_submit(), tcp_events(), and timeouts_queue().

adns__query_send()

void adns__query_send	(	adns_query	qu,
		struct timeval	now
	)

Definition at line 232 of file transmit.c.

                                                         {
  struct sockaddr_in servaddr;
  int serv, r;
  adns_state ads;
 
  assert(qu->state == query_tosend);
  if ((qu->flags & adns_qf_usevc) || (qu->query_dglen > DNS_MAXUDP)) {
    query_usetcp(qu,now);
    return;
  }
 
  if (qu->retries >= UDPMAXRETRIES) {
    adns__query_fail(qu,adns_s_timeout);
    return;
  }
 
  serv= qu->udpnextserver;
  memset(&servaddr,0,sizeof(servaddr));
 
  ads= qu->ads;
  servaddr.sin_family= AF_INET;
  servaddr.sin_addr= ads->servers[serv].addr;
  servaddr.sin_port= htons(DNS_PORT);
 
  ADNS_CLEAR_ERRNO;
  r= sendto(ads->udpsocket,(char*)qu->query_dgram,qu->query_dglen,0,
        (const struct sockaddr*)&servaddr,sizeof(servaddr));
  ADNS_CAPTURE_ERRNO;
  if (r<0 && errno == EMSGSIZE) { qu->retries= 0; query_usetcp(qu,now); return; }
  if (r<0 && ((errno != EAGAIN) && (errno != EWOULDBLOCK))) adns__warn(ads,serv,0,"sendto failed: %s (%d)",strerror(errno), errno);
 
  qu->timeout= now;
  timevaladd(&qu->timeout,UDPRETRYMS);
  qu->udpsent |= (1<<serv);
  qu->udpnextserver= (serv+1)%ads->nservers;
  qu->retries++;
  LIST_LINK_TAIL(ads->udpw,qu);
}

Referenced by adns__procdgram(), query_submit(), and timeouts_queue().

adns__querysend_tcp()

void adns__querysend_tcp	(	adns_query	qu,
		struct timeval	now
	)

Definition at line 168 of file transmit.c.

                                                            {
  byte length[2];
  struct iovec iov[2];
  int wr, r;
  adns_state ads;
 
  if (qu->ads->tcpstate != server_ok) return;
 
  assert(qu->state == query_tcpw);
 
  length[0]= (qu->query_dglen&0x0ff00U) >>8;
  length[1]= (qu->query_dglen&0x0ff);
 
  ads= qu->ads;
  if (!adns__vbuf_ensure(&ads->tcpsend,ads->tcpsend.used+qu->query_dglen+2)) return;
 
  qu->retries++;
 
  /* Reset idle timeout. */
  ads->tcptimeout.tv_sec= ads->tcptimeout.tv_usec= 0;
 
  if (ads->tcpsend.used) {
    wr= 0;
  } else {
    iov[0].iov_base= (char*)length;
    iov[0].iov_len= 2;
    iov[1].iov_base= (char*)qu->query_dgram;
    iov[1].iov_len= qu->query_dglen;
    adns__sigpipe_protect(qu->ads);
 
    ADNS_CLEAR_ERRNO;
    wr= writev(qu->ads->tcpsocket,iov,2);
    ADNS_CAPTURE_ERRNO;
    adns__sigpipe_unprotect(qu->ads);
    if (wr < 0) {
      if (!(errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR || errno == ENOSPC ||
        errno == ENOBUFS || errno == ENOMEM)) {
    adns__tcp_broken(ads,"write",strerror(errno));
    return;
      }
      wr= 0;
    }
  }
 
  if (wr<2) {
    r= adns__vbuf_append(&ads->tcpsend,length,2-wr); assert(r);
    wr= 0;
  } else {
    wr-= 2;
  }
  if (wr<qu->query_dglen) {
    r= adns__vbuf_append(&ads->tcpsend,qu->query_dgram+wr,qu->query_dglen-wr); assert(r);
  }
}

Referenced by query_usetcp(), and tcp_connected().

adns__reset_preserved()

void adns__reset_preserved

(

adns_query

qu

)

Definition at line 410 of file query.c.

                                          {
  assert(!qu->final_allocspace);
  cancel_children(qu);
  qu->answer->nrrs= 0;
  qu->answer->rrs.untyped= 0;
  qu->interim_allocd= qu->preserved_allocd;
}

Referenced by adns__procdgram(), adns__query_fail(), and makefinal_query().

adns__search_next()

void adns__search_next	(	adns_state	ads,
		adns_query	qu,
		struct timeval	now
	)

Definition at line 151 of file query.c.

                                                                          {
  const char *nextentry;
  adns_status stat;
 
  if (qu->search_doneabs<0) {
    nextentry= 0;
    qu->search_doneabs= 1;
  } else {
    if (qu->search_pos >= ads->nsearchlist) {
      if (qu->search_doneabs) {
    stat= adns_s_nxdomain; goto x_fail;
    return;
      } else {
    nextentry= 0;
    qu->search_doneabs= 1;
      }
    } else {
      nextentry= ads->searchlist[qu->search_pos++];
    }
  }
 
  qu->search_vb.used= qu->search_origlen;
  if (nextentry) {
    if (!adns__vbuf_append(&qu->search_vb,(byte*)".",1) ||
    !adns__vbuf_appendstr(&qu->search_vb,nextentry)) {
      stat= adns_s_nomemory; goto x_fail;
    }
  }
 
  free(qu->query_dgram);
  qu->query_dgram= 0; qu->query_dglen= 0;
 
  query_simple(ads,qu, (char*)qu->search_vb.buf, qu->search_vb.used, qu->typei, qu->flags, now);
  return;
 
x_fail:
  adns__query_fail(qu,stat);
}

Referenced by adns__procdgram(), adns_submit(), and query_simple().

adns__setnonblock()

int adns__setnonblock	(	adns_state	ads,
		ADNS_SOCKET	fd
	)

Definition at line 457 of file setup.c.

                                                      {
#ifdef ADNS_JGAA_WIN32
   unsigned long Val = 1;
   return (ioctlsocket (fd, FIONBIO, &Val) == 0) ? 0 : -1;
#else
  int r;
 
  r= fcntl(fd,F_GETFL,0); if (r<0) return errno;
  r |= O_NONBLOCK;
  r= fcntl(fd,F_SETFL,r); if (r<0) return errno;
  return 0;
#endif
}

Referenced by adns__tcp_tryconnect(), and init_finish().

adns__sigpipe_protect()

void adns__sigpipe_protect

(

adns_state

ads

)

Definition at line 340 of file general.c.

                                           {
#ifndef ADNS_JGAA_WIN32
  sigset_t toblock;
  struct sigaction sa;
  int r;
 
  if (ads->iflags & adns_if_nosigpipe) return;
 
  sigfillset(&toblock);
  sigdelset(&toblock,SIGPIPE);
 
  sa.sa_handler= SIG_IGN;
  sigfillset(&sa.sa_mask);
  sa.sa_flags= 0;
 
  r= sigprocmask(SIG_SETMASK,&toblock,&ads->stdsigmask); assert(!r);
  r= sigaction(SIGPIPE,&sa,&ads->stdsigpipe); assert(!r);
#endif
}

Referenced by adns__querysend_tcp(), and adns_processwriteable().

adns__sigpipe_unprotect()

void adns__sigpipe_unprotect

(

adns_state

ads

)

Definition at line 360 of file general.c.

                                             {
#ifndef ADNS_JGAA_WIN32
  int r;
 
  if (ads->iflags & adns_if_nosigpipe) return;
 
  r= sigaction(SIGPIPE,&ads->stdsigpipe,0); assert(!r);
  r= sigprocmask(SIG_SETMASK,&ads->stdsigmask,0); assert(!r);
#endif
}

Referenced by adns__querysend_tcp(), and adns_processwriteable().

adns__tcp_broken()

void adns__tcp_broken	(	adns_state	ads,
		const char *	what,
		const char *	why
	)

Definition at line 59 of file event.c.

                                                                         {
  int serv;
  adns_query qu;
 
  assert(ads->tcpstate == server_connecting || ads->tcpstate == server_ok);
  serv= ads->tcpserver;
  if (what) adns__warn(ads,serv,0,"TCP connection failed: %s: %s",what,why);
 
  if (ads->tcpstate == server_connecting) {
    /* Counts as a retry for all the queries waiting for TCP. */
    for (qu= ads->tcpw.head; qu; qu= qu->next)
      qu->retries++;
  }
 
  tcp_close(ads);
  ads->tcpstate= server_broken;
  ads->tcpserver= (serv+1)%ads->nservers;
}

Referenced by adns__querysend_tcp(), adns__tcp_tryconnect(), adns_globalsystemfailure(), adns_processexceptional(), adns_processreadable(), adns_processwriteable(), and tcp_events().

adns__tcp_tryconnect()

void adns__tcp_tryconnect	(	adns_state	ads,
		struct timeval	now
	)

Definition at line 90 of file event.c.

                                                              {
  int r, tries;
  ADNS_SOCKET fd;
  struct sockaddr_in addr;
  struct protoent *proto;
 
  for (tries=0; tries<ads->nservers; tries++) {
    switch (ads->tcpstate) {
    case server_connecting:
    case server_ok:
    case server_broken:
      return;
    case server_disconnected:
      break;
    default:
      abort();
    }
 
    assert(!ads->tcpsend.used);
    assert(!ads->tcprecv.used);
    assert(!ads->tcprecv_skip);
 
    proto= getprotobyname("tcp");
    if (!proto) { adns__diag(ads,-1,0,"unable to find protocol no. for TCP !"); return; }
    ADNS_CLEAR_ERRNO
    fd= socket(AF_INET,SOCK_STREAM,proto->p_proto);
    ADNS_CAPTURE_ERRNO;
    if (fd<0) {
      adns__diag(ads,-1,0,"cannot create TCP socket: %s",strerror(errno));
      return;
    }
    r= adns__setnonblock(ads,fd);
    if (r) {
      adns__diag(ads,-1,0,"cannot make TCP socket nonblocking: %s",strerror(r));
      adns_socket_close(fd);
      return;
    }
    memset(&addr,0,sizeof(addr));
    addr.sin_family= AF_INET;
    addr.sin_port= htons(DNS_PORT);
    addr.sin_addr= ads->servers[ads->tcpserver].addr;
    ADNS_CLEAR_ERRNO;
    r= connect(fd,(const struct sockaddr*)&addr,sizeof(addr));
    ADNS_CAPTURE_ERRNO;
    ads->tcpsocket= fd;
    ads->tcpstate= server_connecting;
    if (r==0) { tcp_connected(ads,now); return; }
    if (errno == EWOULDBLOCK || errno == EINPROGRESS) {
      ads->tcptimeout= now;
      timevaladd(&ads->tcptimeout,TCPCONNMS);
      return;
    }
    adns__tcp_broken(ads,"connect",strerror(errno));
    ads->tcpstate= server_disconnected;
  }
}

Referenced by query_usetcp(), and tcp_events().

adns__timeouts()

void adns__timeouts	(	adns_state	ads,
		int	act,
		struct timeval **	tv_io,
		struct timeval *	tvbuf,
		struct timeval	now
	)

Definition at line 283 of file event.c.

                                {
  timeouts_queue(ads,act,tv_io,tvbuf,now, &ads->udpw);
  timeouts_queue(ads,act,tv_io,tvbuf,now, &ads->tcpw);
  tcp_events(ads,act,tv_io,tvbuf,now);
}

Referenced by adns_beforeselect(), adns_firsttimeout(), and adns_processtimeouts().

adns__transfer_interim()

void adns__transfer_interim	(	adns_query	from,
		adns_query	to,
		void *	block,
		size_t	sz
	)

Definition at line 366 of file query.c.

                                                                                    {
  allocnode *an;
 
  if (!block) return;
  an= (void*)((byte*)block - MEM_ROUND(sizeof(*an)));
 
  assert(!to->final_allocspace);
  assert(!from->final_allocspace);
 
  LIST_UNLINK(from->allocations,an);
  LIST_LINK_TAIL(to->allocations,an);
 
  sz= MEM_ROUND(sz);
  from->interim_allocd -= sz;
  to->interim_allocd += sz;
 
  if (to->expires > from->expires) to->expires= from->expires;
}

Referenced by icb_hostaddr().

adns__update_expires()

void adns__update_expires	(	adns_query	qu,
		unsigned long	ttl,
		struct timeval	now
	)

Definition at line 458 of file query.c.

                                                                                {
  time_t max;
 
  assert(ttl <= MAXTTLBELIEVE);
  max= now.tv_sec + ttl;
  if (qu->expires < max) return;
  qu->expires= max;
}

Referenced by adns__procdgram(), and pap_findaddrs().

adns__vbuf_append()

int adns__vbuf_append	(	vbuf *	vb,
		const byte *	data,
		int	len
	)

Definition at line 131 of file general.c.

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

Referenced by adns__diag_domain(), adns__parse_domain_more(), adns__querysend_tcp(), adns__search_next(), adns__vbuf_appendstr(), adns_rr_info(), adns_submit(), csp_qstring(), pap_mailbox822(), and vbuf__append_quoted1035().

adns__vbuf_appendq()

void adns__vbuf_appendq	(	vbuf *	vb,
		const byte *	data,
		int	len
	)

Definition at line 126 of file general.c.

                                                             {
  memcpy(vb->buf+vb->used,data, (size_t) len);
  vb->used+= len;
}

Referenced by adns__vbuf_append(), and pap_mailbox822().

adns__vbuf_appendstr()

int adns__vbuf_appendstr	(	vbuf *	vb,
		const char *	data
	)

Definition at line 149 of file general.c.

                                                     {
  int l;
  l= strlen(data);
  return adns__vbuf_append(vb,(byte*)data,l);
}

Referenced by adns__diag_domain(), adns__search_next(), and pap_mailbox822().

adns__vbuf_ensure()

void void void int adns__vbuf_ensure	(	vbuf *	vb,
		int	want
	)

Definition at line 116 of file general.c.

                                          {
  void *nb;
 
  if (vb->avail >= want) return 1;
  nb= realloc(vb->buf, (size_t) want); if (!nb) return 0;
  vb->buf= nb;
  vb->avail= want;
  return 1;
}

Referenced by adns__query_done(), adns__querysend_tcp(), adns_processreadable(), adns_processwriteable(), mkquery_header(), pap_findaddrs(), and pap_mailbox822().

adns__vbuf_free()

void adns__vbuf_free

(

vbuf *

vb

)

Definition at line 155 of file general.c.

                               {
  free(vb->buf);
  adns__vbuf_init(vb);
}

Referenced by adns__internal_submit(), adns__procdgram(), adns__vdiag(), adns_finish(), adns_rr_info(), and free_query_allocs().

adns__vbuf_init()

void adns__vbuf_init

(

vbuf *

vb

)

Definition at line 112 of file general.c.

                               {
  vb->used= vb->avail= 0; vb->buf= 0;
}

Referenced by adns__procdgram(), adns__vbuf_free(), adns__vdiag(), adns_rr_info(), init_begin(), query_alloc(), query_simple(), and query_submit().

adns__vdiag()

void adns__vdiag	(	adns_state	ads,
		const char *	pfx,
		adns_initflags	prevent,
		int	serv,
		adns_query	qu,
		const char *	fmt,
		va_list	al
	)

Definition at line 45 of file general.c.

                                                               {
  const char *bef, *aft;
  vbuf vb;
 
  if (!ads->diagfile ||
      (!(ads->iflags & adns_if_debug) && (!prevent || (ads->iflags & prevent))))
    return;
 
  if (ads->iflags & adns_if_logpid) {
    fprintf(ads->diagfile,"adns%s [%ld]: ",pfx,(long)getpid());
  } else {
    fprintf(ads->diagfile,"adns%s: ",pfx);
  }
 
  vfprintf(ads->diagfile,fmt,al);
 
  bef= " (";
  aft= "\n";
 
  if (qu && qu->query_dgram) {
    adns__vbuf_init(&vb);
    fprintf(ads->diagfile,"%sQNAME=%s, QTYPE=%s",
        bef,
        adns__diag_domain(qu->ads,-1,0, &vb,
                  qu->query_dgram,qu->query_dglen,DNS_HDRSIZE),
        qu->typei ? qu->typei->rrtname : "<unknown>");
    if (qu->typei && qu->typei->fmtname)
      fprintf(ads->diagfile,"(%s)",qu->typei->fmtname);
    bef=", "; aft=")\n";
    adns__vbuf_free(&vb);
  }
 
  if (serv>=0) {
    fprintf(ads->diagfile,"%sNS=%s",bef,inet_ntoa(ads->servers[serv].addr));
    bef=", "; aft=")\n";
  }
 
  fputs(aft,ads->diagfile);
}

Referenced by adns__debug(), adns__diag(), and adns__warn().

adns__warn()

void void adns__warn	(	adns_state	ads,
		int	serv,
		adns_query	qu,
		const char *	fmt,
			...
	)

ctype_822special()

static int ctype_822special ( int  c )

inlinestatic

Definition at line 702 of file internal.h.

{ return strchr("()<>@,;:\\\".[]",c) != 0; }

Referenced by pap_mailbox822().

ctype_alpha()

static int ctype_alpha ( int  c )

inlinestatic

Definition at line 699 of file internal.h.

                                     {
  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
}

Referenced by adns__findrr_anychk(), adns__mkquery(), adns__parse_domain_more(), and ctype_domainunquoted().

ctype_digit()

static int ctype_digit ( int  c )

inlinestatic

Definition at line 698 of file internal.h.

{ return c>='0' && c<='9'; }

Referenced by adns__mkquery(), adns__parse_domain_more(), and ctype_domainunquoted().

ctype_domainunquoted()

static int ctype_domainunquoted ( int  c )

inlinestatic

Definition at line 703 of file internal.h.

                                              {
  return ctype_alpha(c) || ctype_digit(c) || (strchr("-_/+",c) != 0);
}

Referenced by vbuf__append_quoted1035().

ctype_whitespace()

static int ctype_whitespace ( int  c )

inlinestatic

Definition at line 697 of file internal.h.

{ return c==' ' || c=='\n' || c=='\t'; }

Referenced by nextword(), and readconfiggeneric().

errno_resources()

static int errno_resources ( int  e )

inlinestatic

Definition at line 707 of file internal.h.

{ return e==ENOMEM || e==ENOBUFS; }

Referenced by adns_processreadable(), and adns_processwriteable().

vbuf__append_quoted1035()

int vbuf__append_quoted1035	(	vbuf *	vb,
		const byte *	buf,
		int	len
	)

Definition at line 34 of file parse.c.

                                                                {
  char qbuf[10];
  int i, ch;
 
  while (len) {
    qbuf[0]= 0;
    for (i=0; i<len; i++) {
      ch= buf[i];
      if (ch <= ' ' || ch >= 127) {
    sprintf(qbuf,"\\%03o",ch);
    break;
      } else if (!ctype_domainunquoted(ch)) {
    sprintf(qbuf,"\\%c",ch);
    break;
      }
    }
    if (!adns__vbuf_append(vb,buf,i) || !adns__vbuf_append(vb,(byte*)qbuf,(int)  strlen(qbuf)))
      return 0;
    if (i<len) i++;
    buf+= i;
    len-= i;
  }
  return 1;
}

Referenced by adns__parse_domain_more().