adns.h File Reference

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>

Include dependency graph for adns.h:

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

Go to the source code of this file.

Classes
struct	adns_rr_addr
struct	adns_rr_hostaddr
struct	adns_rr_strpair
struct	adns_rr_inthostaddr
struct	adns_rr_intstr
struct	adns_rr_intstrpair
struct	adns_rr_soa
struct	adns_answer

Macros
#define	ADNS_API
#define	ADNS_SOCKET   int
#define	adns_socket_close(sck)   close(sck)
#define	adns_socket_read(sck, data, len)   read(sck, data, len)
#define	adns_socket_write(sck, data, len)   write(sck, data, len)
#define	ADNS_CAPTURE_ERRNO   {}
#define	ADNS_CLEAR_ERRNO   {}
#define	ADNS_POLLFDS_RECOMMENDED   2

Typedefs
typedef struct adns__state *	adns_state
typedef struct adns__query *	adns_query

Enumerations
enum	adns_initflags {   adns_if_noenv = 0x0001 , adns_if_noerrprint = 0x0002 , adns_if_noserverwarn = 0x0004 , adns_if_debug = 0x0008 ,   adns_if_logpid = 0x0080 , adns_if_noautosys = 0x0010 , adns_if_eintr = 0x0020 , adns_if_nosigpipe = 0x0040 ,   adns_if_checkc_entex = 0x0100 , adns_if_checkc_freq = 0x0300 }
enum	adns_queryflags {   adns_qf_search = 0x00000001 , adns_qf_usevc = 0x00000002 , adns_qf_owner = 0x00000004 , adns_qf_quoteok_query = 0x00000010 ,   adns_qf_quoteok_cname = 0x00000000 , adns_qf_quoteok_anshost = 0x00000040 , adns_qf_quotefail_cname = 0x00000080 , adns_qf_cname_loose = 0x00000100 ,   adns_qf_cname_forbid = 0x00000200 , adns__qf_internalmask = 0x0ff00000 }
enum	adns_rrtype {   adns__rrt_typemask = 0x0ffff , adns__qtf_deref = 0x10000 , adns__qtf_mail822 = 0x20000 , adns_r_none = 0 ,   adns_r_a = 1 , adns_r_ns_raw = 2 , adns_r_ns = adns_r_ns_raw|adns__qtf_deref , adns_r_cname = 5 ,   adns_r_soa_raw = 6 , adns_r_soa = adns_r_soa_raw|adns__qtf_mail822 , adns_r_ptr_raw = 12 , adns_r_ptr = adns_r_ptr_raw|adns__qtf_deref ,   adns_r_hinfo = 13 , adns_r_mx_raw = 15 , adns_r_mx = adns_r_mx_raw|adns__qtf_deref , adns_r_txt = 16 ,   adns_r_rp_raw = 17 , adns_r_rp = adns_r_rp_raw|adns__qtf_mail822 , adns_r_addr = adns_r_a|adns__qtf_deref }
enum	adns_status {   adns_s_ok , adns_s_nomemory , adns_s_unknownrrtype , adns_s_systemfail ,   adns_s_max_localfail = 29 , adns_s_timeout , adns_s_allservfail , adns_s_norecurse ,   adns_s_invalidresponse , adns_s_unknownformat , adns_s_max_remotefail = 59 , adns_s_rcodeservfail ,   adns_s_rcodeformaterror , adns_s_rcodenotimplemented , adns_s_rcoderefused , adns_s_rcodeunknown ,   adns_s_max_tempfail = 99 , adns_s_inconsistent , adns_s_prohibitedcname , adns_s_answerdomaininvalid ,   adns_s_answerdomaintoolong , adns_s_invaliddata , adns_s_max_misconfig = 199 , adns_s_querydomainwrong ,   adns_s_querydomaininvalid , adns_s_querydomaintoolong , adns_s_max_misquery = 299 , adns_s_nxdomain ,   adns_s_nodata , adns_s_max_permfail = 499 }

Functions
ADNS_API int	adns_init (adns_state *newstate_r, adns_initflags flags, FILE *diagfile)
ADNS_API void	adns_addserver (adns_state state, struct in_addr server)
ADNS_API void	adns_ccf_search (adns_state state, const char *fn, int lno, const char *buf)
ADNS_API int	adns_numservers (adns_state state)
ADNS_API int	adns_init_strcfg (adns_state *newstate_r, adns_initflags flags, FILE *diagfile, const char *configtext)
ADNS_API int	adns_synchronous (adns_state ads, const char *owner, adns_rrtype type, adns_queryflags flags, adns_answer **answer_r)
ADNS_API int	adns_submit (adns_state ads, const char *owner, adns_rrtype type, adns_queryflags flags, void *context, adns_query *query_r)
ADNS_API int	adns_check (adns_state ads, adns_query *query_io, adns_answer **answer_r, void **context_r)
ADNS_API int	adns_wait (adns_state ads, adns_query *query_io, adns_answer **answer_r, void **context_r)
ADNS_API int	adns_wait_poll (adns_state ads, adns_query *query_io, adns_answer **answer_r, void **context_r)
ADNS_API void	adns_cancel (adns_query query)
ADNS_API int	adns_submit_reverse (adns_state ads, const struct sockaddr *addr, adns_rrtype type, adns_queryflags flags, void *context, adns_query *query_r)
ADNS_API int	adns_submit_reverse_any (adns_state ads, const struct sockaddr *addr, const char *rzone, adns_rrtype type, adns_queryflags flags, void *context, adns_query *query_r)
ADNS_API void	adns_finish (adns_state ads)
ADNS_API void	adns_forallqueries_begin (adns_state ads)
ADNS_API adns_query	adns_forallqueries_next (adns_state ads, void **context_r)
ADNS_API void	adns_checkconsistency (adns_state ads, adns_query qu)
ADNS_API int	adns_processany (adns_state ads)
ADNS_API int	adns_processreadable (adns_state ads, ADNS_SOCKET fd, const struct timeval *now)
ADNS_API int	adns_processwriteable (adns_state ads, ADNS_SOCKET fd, const struct timeval *now)
ADNS_API int	adns_processexceptional (adns_state ads, ADNS_SOCKET fd, const struct timeval *now)
ADNS_API void	adns_processtimeouts (adns_state ads, const struct timeval *now)
ADNS_API void	adns_firsttimeout (adns_state ads, struct timeval **tv_mod, struct timeval *tv_buf, struct timeval now)
ADNS_API void	adns_globalsystemfailure (adns_state ads)
ADNS_API void	adns_beforeselect (adns_state ads, int *maxfd, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval **tv_mod, struct timeval *tv_buf, const struct timeval *now)
ADNS_API void	adns_afterselect (adns_state ads, int maxfd, const fd_set *readfds, const fd_set *writefds, const fd_set *exceptfds, const struct timeval *now)
ADNS_API int	adns_beforepoll (adns_state ads, struct pollfd *fds, int *nfds_io, int *timeout_io, const struct timeval *now)
ADNS_API void	adns_afterpoll (adns_state ads, const struct pollfd *fds, int nfds, const struct timeval *now)
ADNS_API adns_status	adns_rr_info (adns_rrtype type, const char **rrtname_r, const char **fmtname_r, int *len_r, const void *datap, char **data_r)
ADNS_API const char *	adns_strerror (adns_status st)
ADNS_API const char *	adns_errabbrev (adns_status st)
ADNS_API const char *	adns_errtypeabbrev (adns_status st)

Macro Definition Documentation

ADNS_API

#define ADNS_API

Definition at line 69 of file adns.h.

ADNS_CAPTURE_ERRNO

#define ADNS_CAPTURE_ERRNO   {}

Definition at line 74 of file adns.h.

ADNS_CLEAR_ERRNO

#define ADNS_CLEAR_ERRNO   {}

Definition at line 75 of file adns.h.

ADNS_POLLFDS_RECOMMENDED

#define ADNS_POLLFDS_RECOMMENDED   2

Definition at line 777 of file adns.h.

ADNS_SOCKET

#define ADNS_SOCKET   int

Definition at line 70 of file adns.h.

adns_socket_close

#define adns_socket_close

(

sck

)

close(sck)

Definition at line 71 of file adns.h.

adns_socket_read

#define adns_socket_read	(		sck,
			data,
			len
	)		read(sck, data, len)

Definition at line 72 of file adns.h.

adns_socket_write

#define adns_socket_write	(		sck,
			data,
			len
	)		write(sck, data, len)

Definition at line 73 of file adns.h.

Typedef Documentation

adns_query

typedef struct adns__query* adns_query

Definition at line 85 of file adns.h.

adns_state

typedef struct adns__state* adns_state

Definition at line 84 of file adns.h.

Enumeration Type Documentation

adns_initflags

enum adns_initflags

Enumerator
adns_if_noenv
adns_if_noerrprint
adns_if_noserverwarn
adns_if_debug
adns_if_logpid
adns_if_noautosys
adns_if_eintr
adns_if_nosigpipe
adns_if_checkc_entex
adns_if_checkc_freq

Definition at line 87 of file adns.h.

             {
  adns_if_noenv=        0x0001, /* do not look at environment */
  adns_if_noerrprint=   0x0002, /* never print output to stderr (_debug overrides) */
  adns_if_noserverwarn= 0x0004, /* do not warn to stderr about duff nameservers etc */
  adns_if_debug=        0x0008, /* enable all output to stderr plus debug msgs */
  adns_if_logpid=       0x0080, /* include pid in diagnostic output */
  adns_if_noautosys=    0x0010, /* do not make syscalls at every opportunity */
  adns_if_eintr=        0x0020, /* allow _wait and _synchronous to return EINTR */
  adns_if_nosigpipe=    0x0040, /* applic has SIGPIPE set to SIG_IGN, do not protect */
  adns_if_checkc_entex= 0x0100, /* do consistency checks on entry/exit to adns funcs */
  adns_if_checkc_freq=  0x0300  /* do consistency checks very frequently (slow!) */
} adns_initflags;

adns_queryflags

enum adns_queryflags

Enumerator
adns_qf_search
adns_qf_usevc
adns_qf_owner
adns_qf_quoteok_query
adns_qf_quoteok_cname
adns_qf_quoteok_anshost
adns_qf_quotefail_cname
adns_qf_cname_loose
adns_qf_cname_forbid
adns__qf_internalmask

Definition at line 100 of file adns.h.

             {
  adns_qf_search=          0x00000001, /* use the searchlist */
  adns_qf_usevc=           0x00000002, /* use a virtual circuit (TCP connection) */
  adns_qf_owner=           0x00000004, /* fill in the owner field in the answer */
  adns_qf_quoteok_query=   0x00000010, /* allow special chars in query domain */
  adns_qf_quoteok_cname=   0x00000000, /* allow ... in CNAME we go via - now default */
  adns_qf_quoteok_anshost= 0x00000040, /* allow ... in things supposed to be hostnames */
  adns_qf_quotefail_cname= 0x00000080, /* refuse if quote-req chars in CNAME we go via */
  adns_qf_cname_loose=     0x00000100, /* allow refs to CNAMEs - without, get _s_cname */
  adns_qf_cname_forbid=    0x00000200, /* don't follow CNAMEs, instead give _s_cname */
  adns__qf_internalmask=   0x0ff00000
} adns_queryflags;

adns_rrtype

enum adns_rrtype

Enumerator
adns__rrt_typemask
adns__qtf_deref
adns__qtf_mail822
adns_r_none
adns_r_a
adns_r_ns_raw
adns_r_ns
adns_r_cname
adns_r_soa_raw
adns_r_soa
adns_r_ptr_raw
adns_r_ptr
adns_r_hinfo
adns_r_mx_raw
adns_r_mx
adns_r_txt
adns_r_rp_raw
adns_r_rp
adns_r_addr

Definition at line 113 of file adns.h.

             {
  adns__rrt_typemask=  0x0ffff,
  adns__qtf_deref=     0x10000, /* dereference domains and perhaps produce extra data */
  adns__qtf_mail822=   0x20000, /* make mailboxes be in RFC822 rcpt field format */
 
  adns_r_none=               0,
 
  adns_r_a=                  1,
 
  adns_r_ns_raw=             2,
  adns_r_ns=                    adns_r_ns_raw|adns__qtf_deref,
 
  adns_r_cname=              5,
 
  adns_r_soa_raw=            6,
  adns_r_soa=                   adns_r_soa_raw|adns__qtf_mail822,
 
  adns_r_ptr_raw=           12,
  adns_r_ptr=                   adns_r_ptr_raw|adns__qtf_deref,
 
  adns_r_hinfo=             13,
 
  adns_r_mx_raw=            15,
  adns_r_mx=                    adns_r_mx_raw|adns__qtf_deref,
 
  adns_r_txt=               16,
 
  adns_r_rp_raw=            17,
  adns_r_rp=                    adns_r_rp_raw|adns__qtf_mail822,
 
  adns_r_addr=                  adns_r_a|adns__qtf_deref
 
} adns_rrtype;

adns_status

enum adns_status

Enumerator
adns_s_ok
adns_s_nomemory
adns_s_unknownrrtype
adns_s_systemfail
adns_s_max_localfail
adns_s_timeout
adns_s_allservfail
adns_s_norecurse
adns_s_invalidresponse
adns_s_unknownformat
adns_s_max_remotefail
adns_s_rcodeservfail
adns_s_rcodeformaterror
adns_s_rcodenotimplemented
adns_s_rcoderefused
adns_s_rcodeunknown
adns_s_max_tempfail
adns_s_inconsistent
adns_s_prohibitedcname
adns_s_answerdomaininvalid
adns_s_answerdomaintoolong
adns_s_invaliddata
adns_s_max_misconfig
adns_s_querydomainwrong
adns_s_querydomaininvalid
adns_s_querydomaintoolong
adns_s_max_misquery
adns_s_nxdomain
adns_s_nodata
adns_s_max_permfail

Definition at line 215 of file adns.h.

             {
  adns_s_ok,
 
  /* locally induced errors */
  adns_s_nomemory,
  adns_s_unknownrrtype,
  adns_s_systemfail,
 
  adns_s_max_localfail= 29,
 
  /* remotely induced errors, detected locally */
  adns_s_timeout,
  adns_s_allservfail,
  adns_s_norecurse,
  adns_s_invalidresponse,
  adns_s_unknownformat,
 
  adns_s_max_remotefail= 59,
 
  /* remotely induced errors, reported by remote server to us */
  adns_s_rcodeservfail,
  adns_s_rcodeformaterror,
  adns_s_rcodenotimplemented,
  adns_s_rcoderefused,
  adns_s_rcodeunknown,
 
  adns_s_max_tempfail= 99,
 
  /* remote configuration errors */
  adns_s_inconsistent, /* PTR gives domain whose A does not exist and match */
  adns_s_prohibitedcname, /* CNAME found where eg A expected (not if _qf_loosecname) */
  adns_s_answerdomaininvalid,
  adns_s_answerdomaintoolong,
  adns_s_invaliddata,
 
  adns_s_max_misconfig= 199,
 
  /* permanent problems with the query */
  adns_s_querydomainwrong,
  adns_s_querydomaininvalid,
  adns_s_querydomaintoolong,
 
  adns_s_max_misquery= 299,
 
  /* permanent errors */
  adns_s_nxdomain,
  adns_s_nodata,
 
  adns_s_max_permfail= 499
 
} adns_status;

Function Documentation

adns_addserver()

ADNS_API void adns_addserver	(	adns_state	state,
		struct in_addr	server
	)

Definition at line 712 of file setup.c.

                                                         {
    addserver(ads, addr);
}

Referenced by Query_Main().

adns_afterpoll()

ADNS_API void adns_afterpoll	(	adns_state	ads,
		const struct pollfd *	fds,
		int	nfds,
		const struct timeval *	now
	)

adns_afterselect()

ADNS_API void adns_afterselect	(	adns_state	ads,
		int	maxfd,
		const fd_set *	readfds,
		const fd_set *	writefds,
		const fd_set *	exceptfds,
		const struct timeval *	now
	)

Definition at line 595 of file event.c.

                                         {
  struct timeval tv_buf;
  struct pollfd pollfds[MAX_POLLFDS];
  int npollfds, i;
 
  adns__consistency(ads,0,cc_entex);
  adns__must_gettimeofday(ads,&now,&tv_buf);
  if (!now) goto xit;
  adns_processtimeouts(ads,now);
 
  npollfds= adns__pollfds(ads,pollfds);
  for (i=0; i<npollfds; i++) pollfds[i].revents= POLLIN|POLLOUT|POLLPRI;
  adns__fdevents(ads,
         pollfds,npollfds,
         maxfd,readfds,writefds,exceptfds,
         *now, 0);
xit:
  adns__consistency(ads,0,cc_entex);
}

Referenced by adns_wait(), and main().

adns_beforepoll()

ADNS_API int adns_beforepoll	(	adns_state	ads,
		struct pollfd *	fds,
		int *	nfds_io,
		int *	timeout_io,
		const struct timeval *	now
	)

adns_beforeselect()

ADNS_API void adns_beforeselect	(	adns_state	ads,
		int *	maxfd,
		fd_set *	readfds,
		fd_set *	writefds,
		fd_set *	exceptfds,
		struct timeval **	tv_mod,
		struct timeval *	tv_buf,
		const struct timeval *	now
	)

Definition at line 562 of file event.c.

                                          {
  struct timeval tv_nowbuf;
  struct pollfd pollfds[MAX_POLLFDS];
  int i, maxfd, npollfds;
  ADNS_SOCKET fd;
 
  adns__consistency(ads,0,cc_entex);
 
  if (tv_mod && (!*tv_mod || (*tv_mod)->tv_sec || (*tv_mod)->tv_usec)) {
    /* The caller is planning to sleep. */
    adns__must_gettimeofday(ads,&now,&tv_nowbuf);
    if (!now) { inter_immed(tv_mod,tv_tobuf); goto xit; }
    adns__timeouts(ads, 0, tv_mod,tv_tobuf, *now);
  }
 
  npollfds= adns__pollfds(ads,pollfds);
  maxfd= *maxfd_io;
  for (i=0; i<npollfds; i++) {
    fd= pollfds[i].fd;
    if ((int)fd >= maxfd) maxfd= fd+1;
    if (pollfds[i].events & POLLIN) FD_SET(fd,readfds_io);
    if (pollfds[i].events & POLLOUT) FD_SET(fd,writefds_io);
    if (pollfds[i].events & POLLPRI) FD_SET(fd,exceptfds_io);
  }
  *maxfd_io= maxfd;
 
xit:
  adns__consistency(ads,0,cc_entex);
}

Referenced by adns_wait(), and main().

adns_cancel()

ADNS_API void adns_cancel

(

adns_query

query

)

Definition at line 430 of file query.c.

                                {
  adns_state ads;
 
  ads= qu->ads;
  adns__consistency(ads,qu,cc_entex);
  if (qu->parent) LIST_UNLINK_PART(qu->parent->children,qu,siblings.);
  switch (qu->state) {
  case query_tosend:
    LIST_UNLINK(ads->udpw,qu);
    break;
  case query_tcpw:
    LIST_UNLINK(ads->tcpw,qu);
    break;
  case query_childw:
    LIST_UNLINK(ads->childw,qu);
    break;
  case query_done:
    LIST_UNLINK(ads->output,qu);
    break;
  default:
    abort();
  }
  free_query_allocs(qu);
  free(qu->answer);
  free(qu);
  adns__consistency(ads,0,cc_entex);
}

Referenced by adns_finish(), adns_synchronous(), cancel_children(), and of_cancel_id().

adns_ccf_search()

ADNS_API void adns_ccf_search	(	adns_state	state,
		const char *	fn,
		int	lno,
		const char *	buf
	)

Definition at line 715 of file setup.c.

                                                                               {
    ccf_search(ads, fn, lno, buf);
}

Referenced by Query_Main().

adns_check()

ADNS_API int adns_check	(	adns_state	ads,
		adns_query *	query_io,
		adns_answer **	answer_r,
		void **	context_r
	)

Definition at line 731 of file event.c.

                             {
  struct timeval now;
  int r;
 
  adns__consistency(ads,*query_io,cc_entex);
  r= gettimeofday(&now,0);
  if (!r) adns__autosys(ads,now);
 
  r= adns__internal_check(ads,query_io,answer_r,context_r);
  adns__consistency(ads,0,cc_entex);
  return r;
}

Referenced by checkadnsqueries(), main(), and proclog().

adns_checkconsistency()

ADNS_API void adns_checkconsistency	(	adns_state	ads,
		adns_query	qu
	)

Definition at line 30 of file check.c.

                                                          {
  adns__consistency(ads,qu,cc_user);
}

adns_errabbrev()

ADNS_API const char * adns_errabbrev

(

adns_status

st

)

Definition at line 275 of file general.c.

                                           {
  const struct sinfo *si;
 
  si= findsinfo(st);
  return si->abbrev;
}

Referenced by csp_hostaddr(), main(), and print_status().

adns_errtypeabbrev()

ADNS_API const char * adns_errtypeabbrev

(

adns_status

st

)

Definition at line 311 of file general.c.

                                               {
  const struct stinfo *sti;
 
  sti= bsearch(&st,stinfos,sizeof(stinfos)/sizeof(*stinfos),sizeof(*stinfos),sti_compar);
  return sti->abbrev;
}

Referenced by csp_hostaddr(), and print_status().

adns_finish()

ADNS_API void adns_finish

(

adns_state

ads

)

Definition at line 650 of file setup.c.

                                 {
  adns__consistency(ads,0,cc_entex);
  for (;;) {
    if (ads->udpw.head) adns_cancel(ads->udpw.head);
    else if (ads->tcpw.head) adns_cancel(ads->tcpw.head);
    else if (ads->childw.head) adns_cancel(ads->childw.head);
    else if (ads->output.head) adns_cancel(ads->output.head);
    else break;
  }
  adns_socket_close(ads->udpsocket);
  if (ads->tcpsocket != -1) adns_socket_close(ads->tcpsocket);
  adns__vbuf_free(&ads->tcpsend);
  adns__vbuf_free(&ads->tcprecv);
  freesearchlist(ads);
  free(ads);
#ifdef ADNS_JGAA_WIN32
  WSACleanup();
#endif /* WIN32 */
 
}

Referenced by DnsReleaseContextHandle(), main(), proclog(), Query_Main(), and quitnow().

adns_firsttimeout()

ADNS_API void adns_firsttimeout	(	adns_state	ads,
		struct timeval **	tv_mod,
		struct timeval *	tv_buf,
		struct timeval	now
	)

Definition at line 291 of file event.c.

                                   {
  adns__consistency(ads,0,cc_entex);
  adns__timeouts(ads, 0, tv_io,tvbuf, now);
  adns__consistency(ads,0,cc_entex);
}

adns_forallqueries_begin()

ADNS_API void adns_forallqueries_begin

(

adns_state

ads

)

Definition at line 671 of file setup.c.

                                              {
  adns__consistency(ads,0,cc_entex);
  ads->forallnext=
    ads->udpw.head ? ads->udpw.head :
    ads->tcpw.head ? ads->tcpw.head :
    ads->childw.head ? ads->childw.head :
    ads->output.head;
}

Referenced by main().

adns_forallqueries_next()

ADNS_API adns_query adns_forallqueries_next	(	adns_state	ads,
		void **	context_r
	)

Definition at line 680 of file setup.c.

                                                                     {
  adns_query qu, nqu;
 
  adns__consistency(ads,0,cc_entex);
  nqu= ads->forallnext;
  for (;;) {
    qu= nqu;
    if (!qu) return 0;
    if (qu->next) {
      nqu= qu->next;
    } else if (qu == ads->udpw.tail) {
      nqu=
    ads->tcpw.head ? ads->tcpw.head :
    ads->childw.head ? ads->childw.head :
    ads->output.head;
    } else if (qu == ads->tcpw.tail) {
      nqu=
    ads->childw.head ? ads->childw.head :
    ads->output.head;
    } else if (qu == ads->childw.tail) {
      nqu= ads->output.head;
    } else {
      nqu= 0;
    }
    if (!qu->parent) break;
  }
  ads->forallnext= nqu;
  if (context_r) *context_r= qu->ctx.ext;
  return qu;
}

Referenced by main().

adns_globalsystemfailure()

ADNS_API void adns_globalsystemfailure

(

adns_state

ads

)

Definition at line 619 of file event.c.

                                              {
  adns__consistency(ads,0,cc_entex);
 
  while (ads->udpw.head) adns__query_fail(ads->udpw.head, adns_s_systemfail);
  while (ads->tcpw.head) adns__query_fail(ads->tcpw.head, adns_s_systemfail);
 
  switch (ads->tcpstate) {
  case server_connecting:
  case server_ok:
    adns__tcp_broken(ads,0,0);
    break;
  case server_disconnected:
  case server_broken:
    break;
  default:
    abort();
  }
  adns__consistency(ads,0,cc_entex);
}

Referenced by adns__must_gettimeofday(), adns_wait(), and fd_event().

adns_init()

ADNS_API int adns_init	(	adns_state *	newstate_r,
		adns_initflags	flags,
		FILE *	diagfile
	)

Definition at line 568 of file setup.c.

                                                                       {
  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];
#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);
#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;
}

Referenced by DnsAcquireContextHandle_W(), ensure_adns_init(), main(), proclog(), Query_Main(), and startup().

adns_init_strcfg()

ADNS_API int adns_init_strcfg	(	adns_state *	newstate_r,
		adns_initflags	flags,
		FILE *	diagfile,
		const char *	configtext
	)

Definition at line 629 of file setup.c.

                                                     {
  adns_state ads;
  int r;
 
  r= init_begin(&ads, flags, diagfile);  if (r) return r;
 
  readconfigtext(ads,configtext,"<supplied configuration text>");
  if (ads->configerrno) {
    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;
}

Referenced by ensure_adns_init(), main(), proclog(), and startup().

adns_numservers()

ADNS_API int adns_numservers

(

adns_state

state

)

Definition at line 718 of file setup.c.

                                    {
    return ads->nservers;
}

Referenced by Query_Main().

adns_processany()

ADNS_API int adns_processany

(

adns_state

ads

)

Definition at line 639 of file event.c.

                                    {
  int r, i;
  struct timeval now;
  struct pollfd pollfds[MAX_POLLFDS];
  int npollfds;
 
  adns__consistency(ads,0,cc_entex);
 
  r= gettimeofday(&now,0);
  if (!r) adns_processtimeouts(ads,&now);
 
  /* We just use adns__fdevents to loop over the fd's trying them.
   * This seems more sensible than calling select, since we're most
   * likely just to want to do a adns_socket_read on one or two fds anyway.
   */
  npollfds= adns__pollfds(ads,pollfds);
  for (i=0; i<npollfds; i++) pollfds[i].revents= pollfds[i].events & ~POLLPRI;
  adns__fdevents(ads,
         pollfds,npollfds,
         0,0,0,0,
         now,&r);
 
  adns__consistency(ads,0,cc_entex);
  return 0;
}

Referenced by adns__autosys().

adns_processexceptional()

ADNS_API int adns_processexceptional	(	adns_state	ads,
		ADNS_SOCKET	fd,
		const struct timeval *	now
	)

Definition at line 504 of file event.c.

                                                                                       {
  adns__consistency(ads,0,cc_entex);
  switch (ads->tcpstate) {
  case server_disconnected:
  case server_broken:
    break;
  case server_connecting:
  case server_ok:
    if (fd != ads->tcpsocket) break;
    adns__tcp_broken(ads,"poll/select","exceptional condition detected");
    break;
  default:
    abort();
  }
  adns__consistency(ads,0,cc_entex);
  return 0;
}

Referenced by adns__fdevents().

adns_processreadable()

ADNS_API int adns_processreadable	(	adns_state	ads,
		ADNS_SOCKET	fd,
		const struct timeval *	now
	)

Definition at line 338 of file event.c.

                                                                                    {
  int want, dgramlen, r, udpaddrlen, serv, old_skip;
  byte udpbuf[DNS_MAXUDP];
  struct sockaddr_in udpaddr;
 
  adns__consistency(ads,0,cc_entex);
 
  switch (ads->tcpstate) {
  case server_disconnected:
  case server_broken:
  case server_connecting:
    break;
  case server_ok:
    if (fd != ads->tcpsocket) break;
    assert(!ads->tcprecv_skip);
    do {
      if (ads->tcprecv.used >= ads->tcprecv_skip+2) {
    dgramlen= ((ads->tcprecv.buf[ads->tcprecv_skip]<<8) |
               ads->tcprecv.buf[ads->tcprecv_skip+1]);
    if (ads->tcprecv.used >= ads->tcprecv_skip+2+dgramlen) {
      old_skip= ads->tcprecv_skip;
      ads->tcprecv_skip += 2+dgramlen;
      adns__procdgram(ads, ads->tcprecv.buf+old_skip+2,
              dgramlen, ads->tcpserver, 1,*now);
      continue;
    } else {
      want= 2+dgramlen;
    }
      } else {
    want= 2;
      }
      ads->tcprecv.used -= ads->tcprecv_skip;
      memmove(ads->tcprecv.buf,ads->tcprecv.buf+ads->tcprecv_skip, (size_t) ads->tcprecv.used);
      ads->tcprecv_skip= 0;
      if (!adns__vbuf_ensure(&ads->tcprecv,want)) { r= ENOMEM; goto xit; }
      assert(ads->tcprecv.used <= ads->tcprecv.avail);
      if (ads->tcprecv.used == ads->tcprecv.avail) continue;
      ADNS_CLEAR_ERRNO;
      r= adns_socket_read(ads->tcpsocket,
          ads->tcprecv.buf+ads->tcprecv.used,
          ads->tcprecv.avail-ads->tcprecv.used);
      ADNS_CAPTURE_ERRNO;
      if (r>0) {
    ads->tcprecv.used+= r;
      } else {
    if (r) {
      if (errno==EAGAIN || errno==EWOULDBLOCK) { r= 0; goto xit; }
      if (errno==EINTR) continue;
      if (errno_resources(errno)) { r= errno; goto xit; }
    }
    adns__tcp_broken(ads,"adns_socket_read",r?strerror(errno):"closed");
      }
    } while (ads->tcpstate == server_ok);
    r= 0; goto xit;
  default:
    abort();
  }
  if (fd == ads->udpsocket) {
    for (;;) {
      udpaddrlen= sizeof(udpaddr);
      ADNS_CLEAR_ERRNO;
      r= recvfrom(ads->udpsocket,(char*)udpbuf,sizeof(udpbuf),0,
          (struct sockaddr*)&udpaddr,&udpaddrlen);
      ADNS_CAPTURE_ERRNO;
      if (r<0) {
    if (errno == EAGAIN || errno == EWOULDBLOCK || errno == ECONNRESET) { r= 0; goto xit; }
    if (errno == EINTR) continue;
    if (errno_resources(errno)) { r= errno; goto xit; }
    adns__warn(ads,-1,0,"datagram receive error: %s (%d)",strerror(errno), errno);
    r= 0; goto xit;
      }
      if (udpaddrlen != sizeof(udpaddr)) {
    adns__diag(ads,-1,0,"datagram received with wrong address length %d"
           " (expected %lu)", udpaddrlen,
           (unsigned long)sizeof(udpaddr));
    continue;
      }
      if (udpaddr.sin_family != AF_INET) {
    adns__diag(ads,-1,0,"datagram received with wrong protocol family"
           " %u (expected %u)",udpaddr.sin_family,AF_INET);
    continue;
      }
      if (ntohs(udpaddr.sin_port) != DNS_PORT) {
    adns__diag(ads,-1,0,"datagram received from wrong port %u (expected %u)",
           ntohs(udpaddr.sin_port),DNS_PORT);
    continue;
      }
      for (serv= 0;
       serv < ads->nservers &&
         ads->servers[serv].addr.s_addr != udpaddr.sin_addr.s_addr;
       serv++);
      if (serv >= ads->nservers) {
    adns__warn(ads,-1,0,"datagram received from unknown nameserver %s",
           inet_ntoa(udpaddr.sin_addr));
    continue;
      }
      adns__procdgram(ads,udpbuf,r,serv,0,*now);
    }
  }
  r= 0;
xit:
  adns__consistency(ads,0,cc_entex);
  return r;
}

Referenced by adns__fdevents().

adns_processtimeouts()

ADNS_API void adns_processtimeouts	(	adns_state	ads,
		const struct timeval *	now
	)

Definition at line 299 of file event.c.

                                                                     {
  struct timeval tv_buf;
 
  adns__consistency(ads,0,cc_entex);
  adns__must_gettimeofday(ads,&now,&tv_buf);
  if (now) adns__timeouts(ads, 1, 0,0, *now);
  adns__consistency(ads,0,cc_entex);
}

Referenced by adns_afterselect(), and adns_processany().

adns_processwriteable()

ADNS_API int adns_processwriteable	(	adns_state	ads,
		ADNS_SOCKET	fd,
		const struct timeval *	now
	)

Definition at line 443 of file event.c.

                                                                                     {
  int r;
 
  adns__consistency(ads,0,cc_entex);
 
  switch (ads->tcpstate) {
  case server_disconnected:
  case server_broken:
    break;
  case server_connecting:
    if (fd != ads->tcpsocket) break;
    assert(ads->tcprecv.used==0);
    assert(ads->tcprecv_skip==0);
    for (;;) {
      if (!adns__vbuf_ensure(&ads->tcprecv,1)) { r= ENOMEM; goto xit; }
      ADNS_CLEAR_ERRNO;
      r= adns_socket_read(ads->tcpsocket,&ads->tcprecv.buf,1);
      ADNS_CAPTURE_ERRNO;
      if (r==0 || (r<0 && (errno==EAGAIN || errno==EWOULDBLOCK))) {
    tcp_connected(ads,*now);
    r= 0; goto xit;
      }
      if (r>0) {
    adns__tcp_broken(ads,"connect/adns_socket_read","sent data before first request");
    r= 0; goto xit;
      }
      if (errno==EINTR) continue;
      if (errno_resources(errno)) { r= errno; goto xit; }
      adns__tcp_broken(ads,"connect/adns_socket_read",strerror(errno));
      r= 0; goto xit;
    } /* not reached */
  case server_ok:
    if (fd != ads->tcpsocket) break;
    while (ads->tcpsend.used) {
      adns__sigpipe_protect(ads);
      ADNS_CLEAR_ERRNO;
      r= adns_socket_write(ads->tcpsocket,ads->tcpsend.buf,ads->tcpsend.used);
      ADNS_CAPTURE_ERRNO;
      adns__sigpipe_unprotect(ads);
      if (r<0) {
    if (errno==EINTR) continue;
    if (errno==EAGAIN || errno==EWOULDBLOCK) { r= 0; goto xit; }
    if (errno_resources(errno)) { r= errno; goto xit; }
    adns__tcp_broken(ads,"adns_socket_write",strerror(errno));
    r= 0; goto xit;
      } else if (r>0) {
    ads->tcpsend.used -= r;
    memmove(ads->tcpsend.buf,ads->tcpsend.buf+r, (size_t) ads->tcpsend.used);
      }
    }
    r= 0;
    goto xit;
  default:
    abort();
  }
  r= 0;
xit:
  adns__consistency(ads,0,cc_entex);
  return r;
}

Referenced by adns__fdevents().

adns_rr_info()

ADNS_API adns_status adns_rr_info	(	adns_rrtype	type,
		const char **	rrtname_r,
		const char **	fmtname_r,
		int *	len_r,
		const void *	datap,
		char **	data_r
	)

Definition at line 186 of file general.c.

                                               {
  const typeinfo *typei;
  vbuf vb;
  adns_status st;
 
  typei= adns__findtype(type);
  if (!typei) return adns_s_unknownrrtype;
 
  if (rrtname_r) *rrtname_r= typei->rrtname;
  if (fmtname_r) *fmtname_r= typei->fmtname;
  if (len_r) *len_r= typei->rrsz;
 
  if (!datap) return adns_s_ok;
 
  adns__vbuf_init(&vb);
  st= typei->convstring(&vb,datap);
  if (st) goto x_freevb;
  if (!adns__vbuf_append(&vb,(byte*)"",1)) { st= adns_s_nomemory; goto x_freevb; }
  assert((int)strlen((char*)vb.buf) == vb.used-1);
  *data_r= realloc(vb.buf, (size_t) vb.used);
  if (!*data_r) *data_r= (char*)vb.buf;
  return adns_s_ok;
 
 x_freevb:
  adns__vbuf_free(&vb);
  return st;
}

Referenced by main(), print_dnsfail(), and query_done().

adns_strerror()

ADNS_API const char * adns_strerror

(

adns_status

st

)

Definition at line 268 of file general.c.

                                          {
  const struct sinfo *si;
 
  si= findsinfo(st);
  return si->string;
}

Referenced by adns__diag_domain(), csp_hostaddr(), dumptype(), failure_status(), main(), print_dnsfail(), and print_status().

adns_submit()

ADNS_API int adns_submit	(	adns_state	ads,
		const char *	owner,
		adns_rrtype	type,
		adns_queryflags	flags,
		void *	context,
		adns_query *	query_r
	)

Definition at line 204 of file query.c.

                             {
  int r, ol, ndots;
  adns_status stat;
  const typeinfo *typei;
  struct timeval now;
  adns_query qu;
  const char *p;
 
  adns__consistency(ads,0,cc_entex);
 
  typei= adns__findtype(type);
  if (!typei) return ENOSYS;
 
  r= gettimeofday(&now,0); if (r) goto x_errno;
  qu= query_alloc(ads,typei,flags,now); if (!qu) goto x_errno;
 
  qu->ctx.ext= context;
  qu->ctx.callback= 0;
  memset(&qu->ctx.info,0,sizeof(qu->ctx.info));
 
  *query_r= qu;
 
  ol= strlen(owner);
  if (!ol) { stat= adns_s_querydomaininvalid; goto x_adnsfail; }
  if (ol>DNS_MAXDOMAIN+1) { stat= adns_s_querydomaintoolong; goto x_adnsfail; }
 
  if (ol>=1 && owner[ol-1]=='.' && (ol<2 || owner[ol-2]!='\\')) {
    flags &= ~adns_qf_search;
    qu->flags= flags;
    ol--;
  }
 
  if (flags & adns_qf_search) {
    r= adns__vbuf_append(&qu->search_vb,(byte*)owner,ol);
    if (!r) { stat= adns_s_nomemory; goto x_adnsfail; }
 
    for (ndots=0, p=owner; (p= strchr(p,'.')); p++, ndots++);
    qu->search_doneabs= (ndots >= ads->searchndots) ? -1 : 0;
    qu->search_origlen= ol;
    adns__search_next(ads,qu,now);
  } else {
    if (flags & adns_qf_owner) {
      if (!save_owner(qu,owner,ol)) { stat= adns_s_nomemory; goto x_adnsfail; }
    }
    query_simple(ads,qu, owner,ol, typei,flags, now);
  }
  adns__autosys(ads,now);
  adns__consistency(ads,qu,cc_entex);
  return 0;
 
 x_adnsfail:
  adns__query_fail(qu,stat);
  adns__consistency(ads,qu,cc_entex);
  return 0;
 
 x_errno:
  r= errno;
  assert(r);
  adns__consistency(ads,0,cc_entex);
  return r;
}

Referenced by adns_submit_reverse_any(), adns_synchronous(), main(), query_do(), and readline().

adns_submit_reverse()

ADNS_API int adns_submit_reverse	(	adns_state	ads,
		const struct sockaddr *	addr,
		adns_rrtype	type,
		adns_queryflags	flags,
		void *	context,
		adns_query *	query_r
	)

Definition at line 304 of file query.c.

                                 {
  if (type != adns_r_ptr && type != adns_r_ptr_raw) return EINVAL;
  return adns_submit_reverse_any(ads,addr,"in-addr.arpa",type,flags,context,query_r);
}

Referenced by of_ptr(), and procaddr().

adns_submit_reverse_any()

ADNS_API int adns_submit_reverse_any	(	adns_state	ads,
		const struct sockaddr *	addr,
		const char *	rzone,
		adns_rrtype	type,
		adns_queryflags	flags,
		void *	context,
		adns_query *	query_r
	)

Definition at line 271 of file query.c.

                                     {
  const unsigned char *iaddr;
  char *buf, *buf_free;
  char shortbuf[100];
  int r, lreq;
 
  flags &= ~adns_qf_search;
 
  if (addr->sa_family != AF_INET) return ENOSYS;
  iaddr= (const unsigned char*) &(((const struct sockaddr_in*)addr) -> sin_addr);
 
  lreq= strlen(zone) + 4*4 + 1;
  if (lreq > (int)sizeof(shortbuf)) {
    buf= malloc( strlen(zone) + 4*4 + 1 );
    if (!buf) return errno;
    buf_free= buf;
  } else {
    buf= shortbuf;
    buf_free= 0;
  }
  sprintf(buf, "%d.%d.%d.%d.%s", iaddr[3], iaddr[2], iaddr[1], iaddr[0], zone);
 
  r= adns_submit(ads,buf,type,flags,context,query_r);
  free(buf_free);
  return r;
}

Referenced by adns_submit_reverse(), and of_reverse().

adns_synchronous()

ADNS_API int adns_synchronous	(	adns_state	ads,
		const char *	owner,
		adns_rrtype	type,
		adns_queryflags	flags,
		adns_answer **	answer_r
	)

Definition at line 314 of file query.c.

                                     {
  adns_query qu;
  int r;
 
  r= adns_submit(ads,owner,type,flags,0,&qu);
  if (r) return r;
 
  r= adns_wait(ads,&qu,answer_r,0);
  if (r) adns_cancel(qu);
 
  return r;
}

Referenced by Query_Main().

adns_wait()

ADNS_API int adns_wait	(	adns_state	ads,
		adns_query *	query_io,
		adns_answer **	answer_r,
		void **	context_r
	)

Definition at line 696 of file event.c.

                            {
  int r, maxfd, rsel;
  fd_set readfds, writefds, exceptfds;
  struct timeval tvbuf, *tvp;
 
  adns__consistency(ads,*query_io,cc_entex);
  for (;;) {
    r= adns__internal_check(ads,query_io,answer_r,context_r);
    if (r != EAGAIN) break;
    maxfd= 0; tvp= 0;
    FD_ZERO(&readfds); FD_ZERO(&writefds); FD_ZERO(&exceptfds);
    adns_beforeselect(ads,&maxfd,&readfds,&writefds,&exceptfds,&tvp,&tvbuf,0);
    assert(tvp);
    ADNS_CLEAR_ERRNO;
    rsel= select(maxfd,&readfds,&writefds,&exceptfds,tvp);
    ADNS_CAPTURE_ERRNO;
    if (rsel==-1) {
      if (errno == EINTR) {
    if (ads->iflags & adns_if_eintr) { r= EINTR; break; }
      } else {
    adns__diag(ads,-1,0,"select failed in wait: %s",strerror(errno));
    adns_globalsystemfailure(ads);
      }
    } else {
      assert(rsel >= 0);
      adns_afterselect(ads,maxfd,&readfds,&writefds,&exceptfds,0);
    }
  }
  adns__consistency(ads,0,cc_entex);
  return r;
}

Referenced by adns_synchronous(), main(), and proclog().

adns_wait_poll()

ADNS_API int adns_wait_poll	(	adns_state	ads,
		adns_query *	query_io,
		adns_answer **	answer_r,
		void **	context_r
	)

Referenced by main(), and proclog().