Provided by: libudns-dev_0.0.9-3_amd64 bug

NAME

       udns - stub DNS resolver library

SYNOPSYS

       #include <udns.h>
       struct dns_ctx;
       struct dns_query;
       extern struct dns_ctx dns_defctx;
       struct dns_ctx *ctx;
       typedef void dns_query_fn(ctx, void *result, void *data);
       typedef int
       dns_parse_fn(const unsigned char *qnd,
              const unsigned char *pkt,
              const unsigned char *cur,
              const unsigned char *end,
              void **resultp);

       cc ... -ludns

DESCRIPTION

       The  DNS  library, udns, implements thread-safe stub DNS resolver functionality, which may
       be used both traditional, syncronous  way  and  asyncronously,  with  application-supplied
       event loop.

       While  DNS  works with both TCP and UDP, performing UDP query first and if the result does
       not fit in UDP buffer (512 bytes max for original DNS protocol), retrying the  query  over
       TCP,  the  library  uses UDP only, but uses EDNS0 (RFC2671) extensions which allows larger
       UDP buffers.

       The library uses single UDP socket to perform all operations  even  when  asking  multiple
       nameservers.   This  way,  it  is very simple to use the library in asyncronous event-loop
       applications: an application should add only single socket to the set  of  filedescriptors
       it monitors for I/O.

       The  library  uses  two  main  objects, resolver context of type struct dns_ctx, and query
       structure of type struct dns_query, both are opaque for an application.  Resolver  context
       holds  global  information about the resolver, such as list of nameservers to use, list of
       active requests and the like.  Query objects holds information about a single DNS query in
       progress  and  are  allocated/processed/freed by the library.   Pointer to query structure
       may be treated as an identifier of an in-progress query and may  be  used  to  cancel  the
       asyncronous query or to wait for it to complete.

       Asyncronous  interface  works  as  follows.   An application initializes resolver context,
       submits any number of queries for it using one of supplied dns_submit_XXX() routines (each
       return  the  query  identifier  as pointer to query structure), waits for input on the UDP
       socket used by the library, and gives some control to the library by calling dns_ioevent()
       and  dns_timeouts()  routines  when  appropriate.   The  library  performs  all  necessary
       processing and executes application supplied  callback  routine  when  a  query  completes
       (either  successefully  or  not),  giving  it  the  result if any, pointer to the resolver
       context (from which completion status may be obtained), and the data pointer  supplied  by
       an application when the query has been submitted.  When submitting a query, an application
       requests how to handle the reply -- to either return raw DNS reply packet for its own low-
       level  processing, or it may provide an address of parsing routine of type dns_parse_fn to
       perform conversion of on-wire format into easy to use data structure (the library provides
       parsing  routines  for  several  commonly used resource record types, as well as type-safe
       higher-level inteface that  requests  parsing  automatically).   The  I/O  monitoring  and
       timeout  handling  may  be  either  traditional select() or poll() based, or any callback-
       driven technique may be used.

       Additionally,  the  library  provides  traditional  syncronous  interface,  which  may  be
       intermixed  with  asyncronous calls (during syncronous query processing, other asyncronous
       queries for the same resolver context continued to be processed as usual).  An application
       uses  one  of  numerous  dns_resolve_XXX()  routines  provided by the library to perform a
       query.  As with asyncronous interface, an application may either request to return raw DNS
       packet  or  type-specific  data  structure  by providing the parsing routine to handle the
       reply.  Every routine from dns_resolve_XXX() series return pointer to result  or  NULL  in
       case of any error.  Query completion status (or length of the raw DNS packet) is available
       from the resolver context using dns_status() routine, the same way as for the  asyncronous
       interface.

       Internally,  library uses on-wire format of domain names, referred to as DN format in this
       manual page.  This is a series of domain labels whith preceeding length  byte,  terminated
       by  zero-length  label wich is integral part of the DN format.  There are several routines
       provided to convert from traditional asciiz string to DN  and  back.   Higher-level  type-
       specific query interface hides the DN format from an application.

COMMON DEFINITIONS

       Every  DNS  Resource  Record  (RR)  has  a  type and a class.  The library defines several
       integer constants, DNS_C_XXX and DNS_T_XXX, to use as symbolic names for  RR  classes  and
       types,  such  as  DNS_C_IN for Internet class, DNS_T_A for IPv4 address record type and so
       on.  See udns.h header file for complete list of all such constants.

       The following constants are defined in udns.h header file:

       DNS_MAXDN (255 bytes)
              Maximum length of the domain name in internal (on-wire) DN format.

       DNS_MAXLABEL (63 bytes)
              Maximum length of a single label in DN format.

       DNS_MAXNAME (1024 bytes)
              Maximum length of asciiz format of a domain name.

       DNS_HSIZE (12 bytes)
              Size of header in DNS packet.

       DNS_PORT (53)
              Default port to use when contacting a DNS server.

       DNS_MAXSERV (6 servers)
              Maximum number of DNS servers to use.

       DNS_MAXPACKET (512 bytes)
              Maximum length of DNS UDP packet as specified by original DNS protocol

       DNS_EDNS0PACKET (4096 bytes)
              Default length of DNS UDP packet (with EDNS0 extensions) the  library  uses.   Note
              that  recursive  nameservers usually resides near the client asking them to resolve
              names, e.g. on the same LAN segment or  even  on  the  same  host,  so  UDP  packet
              fragmentation  isn't  a  problem  in most cases.  Note also that the size of actual
              packets will be as many bytes as actual reply size requires, which is smaller  than
              this value in almost all cases.

       Additionally, several constants are defined to simplify work with raw DNS packets, such as
       DNS response codes (DNS_R_XXX), DNS header layout  (DNS_H_XXX)  and  others.   Again,  see
       udns.h  for  complete  list.   Library error codes (DNS_E_XXX) are described later in this
       manual page.

RESOLVER CONTEXT

       Resolver context, of type struct dns_ctx, is an object which is opaque to an  application.
       Several  routines  provided by the library to initialize, copy and free resolver contexts.
       Most other high-level routines in this library expects a pointer to resolver context, ctx,
       as  the  first argument.  There is a default resolver context available, named dns_defctx.
       When the context pointer ctx passed to a routine is NULL,  dns_defctx  is  used.   Several
       resolver  contexts  may  be  active  at the same time, for example, when an application is
       multi-threaded and each thread uses resolver.

       In order to use the library, an  application  should  initialize  and  open  one  or  more
       resolver  context  objects.   These  are two separate actions, performed by dns_init() (or
       dns_reset()), and dns_open().  Between the two calls, an application is  free  to  pefrorm
       additional  initialisation,  such  as setting custom nameservers, options or domain search
       lists.  Optionally, in case no additional custom initialisation  is  required,  dns_init()
       may open the context if do_open argument (see below) is non-zero.

       When  initializing  resolver  context,  the  library  uses  information  from  system file
       /etc/resolv.conf  (see  resolv.conf(5)),  consults  environment  variables   $LOCALDOMAIN,
       $DNSCACHEIP,  $NAMESERVERS  and  $RES_OPTIONS, and local host name to obtain list of local
       nameservers, domain name search list and various resolver options.

       The following routines to initialize resolver context are available:

       void dns_reset(ctx)
       int dns_init(ctx, int do_open)
              dns_reset() resets a given resolver context to default values, preparing it  to  be
              opened  by  dns_open().   It  is  ok to call this routine against opened and active
              context - all active queries will be dropped, sockets will be  closed  and  so  on.
              This  routine  does  not initialize any parameters from system configuration files,
              use dns_init() for this.  There's no error  return  -  operation  always  succeeds.
              dns_init() does everything dns_reset() does, plus initializes various parameters of
              the context according to system configuration and  process  environment  variables.
              If  do_open  is  non-zero,  dns_init()  calls dns_open(), so that the whole library
              initialisation is performed in a single step.

       struct dns_ctx *dns_new(struct dns_ctx *copy)
       void dns_free(ctx)
              dns_new() allocates new resolver context and copies  all  parameters  for  a  given
              resolver  context  copy, or default context if copy is NULL, and returns pointer to
              the newly allocated context.  The  context  being  copied  should  be  initialized.
              dns_new()  may fail if there's no memory available to make a copy of copy, in which
              case the routine will return NULL pointer.  dns_free() is used to close  assotiated
              socket  and  free resolver context resources and cancelling (abandoming) all active
              queries assotiated with it.  It's an error to  free  dns_defctx,  only  dynamically
              allocated contexts returned by dns_new() are allowed to be freed by dns_free().

       int dns_add_serv(ctx, const char *servaddr)
       int dns_add_serv_s(ctx, const struct sockaddr *sa)
       int dns_add_srch(ctx, const char *srch)
              Add  an  element  to list of nameservers (dns_add_serv(), as asciiz-string servaddr
              with an IP address of the nameserver, and dns_add_serv_s(), as  initialized  socket
              address  sa),  or search list (dns_add_srch(), as a pointer to domain name) for the
              given context ctx.  If the last argument is a NULL pointer, the corresponding  list
              (search or nameserver) is reset instead.  Upon successeful completion, each routine
              returns new number of elements in the list in question.  On error,  negative  value
              is returned and global variable errno is set appropriately.  It is an error to call
              any of this functions if the context is opened (after dns_open() or dns_init() with
              non-zero argument).

       int dns_set_opts(ctx, const char *opts)
              set  resolver  context  options  from  opts  string,  in the same way as processing
              options statement in resolv.conf and $RES_OPTIONS environment variable.

       void dns_set_opt(ctx, int opt, val)
              TODO The flags argument is a bitmask with the following bits defined:

              DNS_NOSRCH
                     do not perform domain name search in search list.

              DNS_NORD
                     do not request recursion when performing queries (i.e. don't set RD flag  in
                     querues).

              DNS_AAONLY
                     request authoritative answers only (i.e. set AA flag in queries).

       int dns_open(ctx)
       int dns_sock(const ctx)
       void dns_close(ctx)
              dns_open()  opens  the  UDP socket used for queries if not already open, and return
              assotiated filedescriptor (or negative value in case of error).  Before  any  query
              can  be  submitted,  the  context  should be opened using this routine.  And before
              opening, the context should be initialized.  dns_sock() return the  UDP  socket  if
              open,  or  -1  if not.  dns_close() closes the UDP socket if it was open, and drops
              all active queries if any.

       int dns_active(const ctx)
              return number of active queries queued for the given context ctx, or zero if none.

       int dns_status(const ctx)
              return status code from last operation.  When using syncronous interface,  this  is
              the  query  completion  status of the last query.  With asyncronous interface, from
              within the callback routine, this is the query completion status of the  query  for
              which the callback is being called.  When query submission fails, this is the error
              code indicating failure reason.  All error codes are negative and  are  represented
              by DNS_E_XXX constants described below.

       void dns_ioevent(ctx, time_t now)
              this  routine  may  be  called  by  an application to process I/O events on the UDP
              socket used by the library, as  returned  by  dns_sock().   The  routine  tries  to
              receive incoming UDP datagram from the socket and process it.  The socket is set up
              to be non-blocking, so it is safe to call the routine even if there's  no  data  to
              read.   The routine will process as many datagrams as are queued for the socket, so
              it is safe to use it with either level-triggered or edge-triggered  I/O  monitoring
              model.   The  now argument is either a current time as returned by time(), or 0, in
              which case the routine will obtain current time by it's own.

       int dns_timeouts(ctx, int maxwait, time_t now)
              process any pending timeouts and return number of secounds from current  time  (now
              if  it  is  not  0)  to  the time when the library wants the application to pass it
              control to process more queued requests.   In  case  when  there  are  no  requests
              pending,  this time is -1.  The routine will not request a time larger than maxwait
              secounds if it is greather or equal to zero.  If now is 0, the routine will  obtain
              current  time  by  it's  own;  when  it is not 0, it should contain current time as
              returned by time().

       typedef void dns_utm_fn(ctx, int timeout, void *data)
       void dns_set_cbck(ctx, dns_utm_fn *utmfn, void *data)
              An application may use custom callback-based I/O multiplexing  mechanism.   Usually
              such  a mechanism have concept of a timer, and an ability to register a timer event
              in a form of a callback routine which will be  executed  after  certain  amount  of
              time.   In  order  to  use  such  an  event  mechanism, udns provides an ability to
              register and de-register timer  events  necessary  for  internal  processing  using
              whatever  event mechanism an application uses.  For this to work, it is possible to
              assotiate  a  pointer  to  a  routine  that  will  perform   necessary   work   for
              (de)registering timer events with a given resolver context, and udns will call that
              routine at appropriate times.  Prototype of such a routine is shown  by  dns_utm_fn
              typedef  above.   Libudns  assotiates  single  timer  with resolver context.  User-
              supplied utmfn routine will be called by the library with the following arguments:

              ctx == NULL
                     delete user timer, at context free time or when an application changes  user
                     timer request routine using dns_set_cbck();

              ctx != NULL, timeout < 0
                     don't fire timer anymore, when there are no active requests;

              ctx != NULL, timeout == 0
                     fire timer at the next possibility, but not immediately;

              ctx != NULL, timeout > 0
                     fire timer after timeout seconds after now.

              The   data  argument  passed  to  the  routine  will  be  the  same  as  passed  to
              dns_set_cbck().

              When a timer expires, an application should call dns_tmeouts() routine (see below).
              Non-callback timer usage is provided too.

       XXXX TODO: some more resolver context routines, like dns_set_dbgfn() etc.

QUERY INTERFACE

       There  are two ways to perform DNS queries: traditional syncronous way, when udns performs
       all the necessary processing and return control to the application  only  when  the  query
       completes,  and  asyncronous  way,  when an application submits one or more queries to the
       library  using  given  resolver  context,  and  waits   for   completion   by   monitoring
       filedescriptor  used  by  library  and  calling  library routines to process input on that
       filedescriptor.  Asyncronous mode works with callback routines: an application supplies an
       address  of  a  routine  to execute when the query completes, and a data pointer, which is
       passed to the callback routine.

       Queries are  submitted  to  the  library  in  a  form  of  struct dns_query.   To  perform
       asyncronous query, an application calls one of the dns_submit_XXX() rounines, and provides
       necessary information for a callback, together with all the query  parameters.   When  the
       query  completes,  library  will call application-supplied callback routine, giving it the
       resolver context (wich holds query completion status), dynamically allocated result (which
       will be either raw DNS packet or, if applicatin requested parsing the result by specifying
       non-NULL parse routine, ready-to-use type-specific structure), and a data pointer provided
       by  an  application  when it submitted the query.  It is the application who's responsible
       for freeing the result memory.

       Generic query callback routine looks like this:
       typedef void
       dns_query_fn(ctx, void *result, void *data)
       Type-specific query interface expects similar form  of  callback  routine  with  the  only
       difference  in  type  of result argument, which will be pointer to specific data structure
       (decoded reply) instead of this void pointer to raw DNS packet data.

       Result parsing routine looks like this:
       typedef int
       dns_parse_fn(const unsigned char *qdn,
             const unsigned char *pkt,
             const unsigned char *cur,
             const unsigned char *end,
             void **resultp);
       When called by the library, the arguments are as follows: pkt points to the start  of  the
       packet received; end points past the end of the packet received; cur points past the query
       DN in the query section of the packet; qdn points to the original query DN.   The  routine
       should allocate a single buffer to hold the result, parse the reply filling in the buffer,
       and return the buffer using resultp argument.  It returns 0 in  case  of  error,  or  udns
       error  code  (DNS_E_XXX constants) in case of error.  Note that by the time when the parse
       routine is called by the library, packet is already verified to be a reply to the original
       query, by matching query DN, query class and query type.

       Type-specific query inteface supplies necessary parsing routines automatically.

       In case of error, query completion status as returned by dns_status(ctx), will contain one
       of the following values:

       positive value
              length of raw DNS packet if parsing is not requested.

       0      the query was successeful and the reply points to type-specific data structure.

       DNS_E_TEMPFAIL
              temporary error, the resolver nameserver was not able to process our query or timed
              out.

       DNS_E_PROTOCOL
              protocol error, a nameserver returned malformed reply.

       DNS_E_NXDOMAIN
              the domain name does not exist.

       DNS_E_NODATA
              there is no data of requested type found.

       DNS_E_NOMEM
              out of memory while processing request.

       DNS_E_BADQUERY
              some  aspect  of the query (most common is the domain name in question) is invalid,
              and the library can't even start a query.

       Library provides  two  series  of  routines  which  uses  similar  interface  --  one  for
       asyncronous  queries  and another for syncronous queries.  There are two general low-level
       routines in  each  series  to  submit  (asyncronous  interface)  and  resolve  (syncronous
       interface)  queries,  as  well  as  several  type-specific  routines with more easy-to-use
       interfaces.  To submit an asyncronous query, use one of dns_submit_XXX() routine, each  of
       which  accepts  query  parameters,  pointers to callback routine and to callback data, and
       optional current time hint.  Note type-specific dns_submit_XXX() routines expects specific
       type  of  the  callback routine as well, which accepts reply as a pointer to corresponding
       structure, not a void pointer).  Every dns_submit_XXX() routine return pointer to internal
       query structure of type struct dns_query, used as an identifier for the given query.

       To  resolve a query syncronously, use one of dns_resolve_XXX() routines, which accepts the
       same query parameters (but not the callback pointers) as  corresponding  dns_submit_XXX(),
       and  return  the query result, which is the same as passed to the callback routine in case
       of asyncronous interface.

       In either case, the result memory (if the query completed  successefully)  is  dynamically
       allocated  and should be freed by an application.  If the query failed for any reason, the
       result will be NULL, and error status will be available from  dns_status(ctx)  routine  as
       shown above.

       struct dns_query *
       dns_submit_dn(ctx,
            const unsigned char *dn, qcls, qtyp, flags,
            parse, cbck, data)
       struct dns_query *
       dns_submit_p(ctx,
            const char *name, qcls, qtyp, flags,
            parse, cbck, data)
          enum dns_class qcls;
          enum dns_type qtyp;
          int flags;
          dns_parse_fn *parse;
          dns_query_fn *cbck;
          void *data;
              submit  a  query  for  processing for the given resolver context ctx.  Two routines
              differs only in 3rd argument, which is domain name in  DN  format  (dn)  or  asciiz
              string  (name).   The  query will be performed for the given domain name, with type
              qtyp in class qcls, using option bits in flags, using RR parsing routine pointed by
              parse  if not-NULL, and upon completion, cbck function will be called with the data
              argument.  In case of successeful query submission, the routine return  pointer  to
              internal query structure which may be treated as an identifier of the query as used
              by the library, and may be used as an argument for dns_cancel() routine.   In  case
              of  error,  NULL  will  be  returned,  and  context  error  status (available using
              dns_status() routine) will be set to corresponding error code, which in  this  case
              may  be  DNS_E_BADQUERY  if  the  name  of dn is invalid, DNS_E_NOMEM if there's no
              memory available to allocate query structure,  or  DNS_E_TEMPFAIL  if  an  internal
              error occured.

       void *dns_resolve_dn(ctx,
            const unsigned char *dn, qcls, qtyp, flags, parse);
       void *dns_resolve_p(ctx,
            const char *name, qcls, qtyp, flags, parse)
          enum dns_class qcls;
          enum dns_type qtyp;
          int flags;
          dns_parse_fn *parse;
              syncronous  interface.  The routines perform all the steps necessary to resolve the
              given query and return the result.  If there's no positive result for  any  reason,
              all  the  routines  return  NULL,  and  set  context  error status (available using
              dns_status() routine) to indicate the error code.  If the  query  was  successeful,
              context  status  code will contain either the length of the raw DNS reply packet if
              parse argument was NULL (in which case the return value is pointer to the reply DNS
              packet),  or 0 (in which case the return value is the result of parse routine).  If
              the query  successeful  (return  value  is  not  NULL),  the  memory  returned  was
              dynamically  allocated  by  the  library and should be free()d by application after
              use.

       void *dns_resolve(ctx, struct dns_query *q)
              wait for the given query q, as returned by one of  dns_submit_XXX()  routines,  for
              completion,  and  return  the  result.  The callback routine will not be called for
              this  query.   After  completion,  the  query  identifier  q  is  not  valid.  Both
              dns_resolve_dn()  and dns_resolve_p() are just wrappers around corresponding submit
              routines and this dns_resolve() routine.

       void dns_cancel(ctx, struct dns_query *q)
              cancel an active query q, without calling a callback  routine.   After  completion,
              the query identifier q is not valid.

TYPE-SPECIFIC QUERIES

       In  addition  to  the  generic  low-level  query  interface, the library provides a set of
       routines to perform specific queries in a type-safe manner, as well as parsers for several
       well-known  resource  record  types.   The  library implements high-level interface for A,
       AAAA, PTR, MX and TXT records and DNSBL and RHSBL functionality.  These  routines  returns
       specific  types as result of a query, instead of raw DNS packets.  The following types and
       routines are available.

       struct dns_rr_null {
         char *dnsn_qname;     /* original query name */
         char *dnsn_cname;     /* canonical name */
         unsigned dnsn_ttl;    /* Time-To-Live (TTL) value */
         int dnsn_nrr;         /* number of records in the set */
       };

       NULL RR set, used as a base for all other RR type structures.  Every RR structure as  used
       by the library have four standard fields as in struct dns_rr_null.

   IN A Queries
       struct dns_rr_a4 {       /* IN A RRset */
         char *dnsa4_qname;     /* original query name */
         char *dnsa4_cname;     /* canonical name */
         unsigned dnsa4_ttl;    /* Time-To-Live (TTL) value */
         int dnsa4_nrr;         /* number of addresses in the set */
         struct in_addr dnsa4_addr[]; /* array of addresses */
       };
       typedef void
         dns_query_a4_fn(ctx, struct dns_rr_a4 *result, data)
       dns_parse_fn dns_parse_a4;
       struct dns_query *
       dns_submit_a4(ctx, const char *name, int flags,
          dns_query_a4_fn *cbck, data);
       struct dns_rr_a4 *
       dns_resolve_a4(ctx, const char *name, int flags);

       The  dns_rr_a4  structure  holds  a  result  of  an  IN A query, which is an array of IPv4
       addresses.  Callback routine for IN A queries expected  to  be  of  type  dns_query_a4_fn,
       which  expects  pointer  to dns_rr_a4 structure as query result instead of raw DNS packet.
       The dns_parse_a4() is used to convert raw DNS reply packet into dns_rr_a4 structure (it is
       used  internally  and  may  be  used directly too with generic query interface).  Routines
       dns_submit_a4() and dns_resolve_a4() are used to perform  A  IN  queries  in  a  type-safe
       manner.   The  name  parameter  is  the  domain name in question, and flags is query flags
       bitmask, with one bit, DNS_NOSRCH, of practical interest (if the name  is  absolute,  that
       is, it ends up with a dot, DNS_NOSRCH flag will be set automatically).

   IN AAAA Queries
       struct dns_rr_a6 {       /* IN AAAA RRset */
         char *dnsa6_qname;     /* original query name */
         char *dnsa6_cname;     /* canonical name */
         unsigned dnsa6_ttl;    /* Time-To-Live (TTL) value */
         int dnsa6_nrr;         /* number of addresses in the set */
         struct in6_addr dnsa6_addr[]; /* array of addresses */
       };
       typedef void
         dns_query_a6_fn(ctx, struct dns_rr_a6 *result, data)
       dns_parse_fn dns_parse_a6;
       struct dns_query *
       dns_submit_a6(ctx, const char *name, int flags,
          dns_query_a6_fn *cbck, data);
       struct dns_rr_a6 *
       dns_resolve_a6(ctx, const char *name, int flags);

       The  dns_rr_a6  structure  holds  a  result of an IN AAAA query, which is an array of IPv6
       addresses.  Callback routine for IN AAAA queries expected to be of  type  dns_query_a6_fn,
       which  expects  pointer  to dns_rr_a6 structure as query result instead of raw DNS packet.
       The dns_parse_a6() is used to convert raw DNS reply packet into dns_rr_a6 structure (it is
       used  internally  and  may  be  used directly too with generic query interface).  Routines
       dns_submit_a6() and dns_resolve_a6() are used to perform AAAA IN queries  in  a  type-safe
       manner.   The  name  parameter  is  the  domain name in question, and flags is query flags
       bitmask, with one bit, DNS_NOSRCH, of practical interest (if the name  is  absolute,  that
       is, it ends up with a dot, DNS_NOSRCH flag will be set automatically).

   IN PTR Queries
       struct dns_rr_ptr {       /* IN PTR RRset */
         char *dnsptr_qname;     /* original query name */
         char *dnsptr_cname;     /* canonical name */
         unsigned dnsptr_ttl;    /* Time-To-Live (TTL) value */
         int dnsptr_nrr;         /* number of domain name pointers */
         char *dnsptr_ptr[];     /* array of domain name pointers */
       };
       typedef void
         dns_query_ptr_fn(ctx, struct dns_rr_ptr *result, data)
       dns_parse_fn dns_parse_ptr;
       struct dns_query *
       dns_submit_a4ptr(ctx, const struct in_addr *addr,
          dns_query_ptr_fn *cbck, data);
       struct dns_rr_ptr *
       dns_resolve_a4ptr(ctx, const struct in_addr *addr);
       struct dns_query *
       dns_submit_a6ptr(ctx, const struct in6_addr *addr,
          dns_query_ptr_fn *cbck, data);
       struct dns_rr_ptr *
       dns_resolve_a6ptr(ctx, const struct in6_addr *addr);

       The  dns_rr_ptr  structure  holds a result of an IN PTR query, which is an array of domain
       name pointers for a given IPv4 or IPv6 address.   Callback  routine  for  IN  PTR  queries
       expected  to be of type dns_query_ptr_fn, which expects pointer to dns_rr_ptr structure as
       query result instead of raw DNS packet.  The dns_parse_ptr() is used to  convert  raw  DNS
       reply packet into dns_rr_ptr structure (it is used internally and may be used directly too
       with generic query interface).  Routines dns_submit_a4ptr()  and  dns_resolve_a4ptr()  are
       used  to  perform  IN  PTR  queries  for  IPv4  addresses  in a type-safe manner. Routines
       dns_submit_a6ptr() and dns_resolve_a6ptr() are used to perform IN  PTR  queries  for  IPv6
       addresses.

   IN MX Queries
       struct dns_mx {          /* single MX record */
         int priority;          /* priority value of this MX */
         char *name;            /* domain name of this MX */
       };
       struct dns_rr_mx {       /* IN MX RRset */
         char *dnsmx_qname;     /* original query name */
         char *dnsmx_cname;     /* canonical name */
         unsigned dnsmx_ttl;    /* Time-To-Live (TTL) value */
         int dnsmx_nrr;         /* number of mail exchangers in the set */
         struct dns_mx dnsmx_mx[]; /* array of mail exchangers */
       };
       typedef void
         dns_query_mx_fn(ctx, struct dns_rr_mx *result, data)
       dns_parse_fn dns_parse_mx;
       struct dns_query *
       dns_submit_mx(ctx, const char *name, int flags,
          dns_query_mx_fn *cbck, data);
       struct dns_rr_mx *
       dns_resolve_mx(ctx, const char *name, int flags);

       The  dns_rr_mx  structure  holds  a  result  of  an IN MX query, which is an array of mail
       exchangers for a given domain.  Callback routine for IN MX queries expected to be of  type
       dns_query_mx_fn,  which  expects pointer to dns_rr_mx structure as query result instead of
       raw DNS packet.  The dns_parse_mx() is used to convert raw DNS reply packet into dns_rr_mx
       structure  (it  is  used  internally  and  may  be  used  directly  too with generic query
       interface).  Routines dns_submit_mx() and dns_resolve_mx()  are  used  to  perform  IN  MX
       queries  in  a  type-safe  manner.  The name parameter is the domain name in question, and
       flags is query flags bitmask, with one bit, DNS_NOSRCH, of practical interest (if the name
       is absolute, that is, it ends up with a dot, DNS_NOSRCH flag will be set automatically).

   TXT Queries
       struct dns_txt {          /* single TXT record */
         int len;                /* length of the text */
         unsigned char *txt;     /* pointer to the text */
       };
       struct dns_rr_txt {       /* TXT RRset */
         char *dnstxt_qname;     /* original query name */
         char *dnstxt_cname;     /* canonical name */
         unsigned dnstxt_ttl;    /* Time-To-Live (TTL) value */
         int dnstxt_nrr;         /* number of text records in the set */
         struct dns_txt dnstxt_txt[]; /* array of TXT records */
       };
       typedef void
         dns_query_txt_fn(ctx, struct dns_rr_txt *result, data)
       dns_parse_fn dns_parse_txt;
       struct dns_query *
       dns_submit_txt(ctx, const char *name, enum dns_class qcls,
          int flags, dns_query_txt_fn *cbck, data);
       struct dns_rr_txt *
       dns_resolve_txt(ctx, const char *name,
                    enum dns_class qcls, int flags);

       The  dns_rr_txt structure holds a result of a TXT query, which is an array of text records
       for a given domain name.  Callback  routine  for  TXT  queries  expected  to  be  of  type
       dns_query_txt_fn, which expects pointer to dns_rr_txt structure as query result instead of
       raw DNS packet.  The dns_parse_txt()  is  used  to  convert  raw  DNS  reply  packet  into
       dns_rr_txt  structure  (it  is  used  internally and may be used directly too with generic
       query interface).  Routines dns_submit_txt() and dns_resolve_txt() are used to perform  IN
       MX  queries in a type-safe manner.  The name parameter is the domain name in question, and
       flags is query flags bitmask, with one bit, DNS_NOSRCH, of practical interest (if the name
       is  absolute,  that is, it ends up with a dot, DNS_NOSRCH flag will be set automatically).
       Note that each TXT string is represented by struct dns_txt, while zero-terminated (and the
       len  field  of  the  structure does not include the terminator), may contain embedded null
       characters -- content of TXT records is not interpreted by the library in any way.

   SRV Queries
       struct dns_srv {          /* single SRV record */
         int priority;           /* priority of the record */
         int weight;             /* weight of the record */
         int port;               /* the port number to connect to */
         char *name;             /* target host name */
       };
       struct dns_rr_srv {       /* SRV RRset */
         char *dnssrv_qname;     /* original query name */
         char *dnssrv_cname;     /* canonical name */
         unsigned dnssrv_ttl;    /* Time-To-Live (TTL) value */
         int dnssrv_nrr;         /* number of text records in the set */
         struct dns_srv dnssrv_srv[]; /* array of SRV records */
       };
       typedef void
         dns_query_srv_fn(ctx, struct dns_rr_srv *result, data)
       dns_parse_fn dns_parse_srv;
       struct dns_query *
       dns_submit_srv(ctx, const char *name, const char *service, const char *protocol,
          int flags, dns_query_txt_fn *cbck, data);
       struct dns_rr_srv *
       dns_resolve_srv(ctx, const char *name, const char *service, const char *protocol,
                    int flags);

       The dns_rr_srv structure holds a result of an IN SRV (rfc2782) query, which is an array of
       servers  (together  with port numbers) which are performing operations for a given service
       using given protocol on a target  domain  name.   Callback  routine  for  IN  SRV  queries
       expected  to be of type dns_query_srv_fn, which expects pointer to dns_rr_srv structure as
       query result instead of raw DNS packet.  The dns_parse_srv() is used to  convert  raw  DNS
       reply packet into dns_rr_srv structure (it is used internally and may be used directly too
       with generic query interface).  Routines dns_submit_srv() and dns_resolve_srv()  are  used
       to perform IN SRV queries in a type-safe manner.  The name parameter is the domain name in
       question, service and protocl specifies the service and  the  protocol  in  question  (the
       library  will construct query DN according to rfc2782 rules) and may be NULL (in this case
       the library assumes name parameter holds the complete SRV query), and flags is query flags
       bitmask,  with  one  bit, DNS_NOSRCH, of practical interest (if the name is absolute, that
       is, it ends up with a dot, DNS_NOSRCH flag will be set automatically).

   NAPTR Queries
       struct dns_naptr {        /* single NAPTR record */
         int order;              /* record order */
         int preference;         /* preference of this record */
         char *flags;            /* application-specific flags */
         char *services;         /* service parameters */
         char *regexp;           /* substitutional regular expression */
         char *replacement;      /* replacement string */
       };
       struct dns_rr_naptr {     /* NAPTR RRset */
         char *dnsnaptr_qname;   /* original query name */
         char *dnsnaptr_cname;   /* canonical name */
         unsigned dnsnaptr_ttl;  /* Time-To-Live (TTL) value */
         int dnsnaptr_nrr;       /* number of text records in the set */
         struct dns_naptr dnsnaptr_naptr[]; /* array of NAPTR records */
       };
       typedef void
         dns_query_naptr_fn(ctx, struct dns_rr_naptr *result, data)
       dns_parse_fn dns_parse_naptr;
       struct dns_query *
       dns_submit_naptr(ctx, const char *name, int flags,
          dns_query_txt_fn *cbck, data);
       struct dns_rr_naptr *
       dns_resolve_naptr(ctx, const char *name, int flags);

       The dns_rr_naptr structure holds a result  of  an  IN  NAPTR  (rfc3403)  query.   Callback
       routine for IN NAPTR queries expected to be of type dns_query_naptr_fn, expects pointer to
       dns_rr_naptr structure as query result instead of raw DNS packet.   The  dns_parse_naptr()
       is used to convert raw DNS reply packet into dns_rr_naptr structure (it is used internally
       and may be used directly too with generic query interface).   Routines  dns_submit_naptr()
       and  dns_resolve_naptr()  are used to perform IN NAPTR queries in a type-safe manner.  The
       name parameter is the domain name in question, and flags is query flags bitmask, with  one
       bit,  DNS_NOSRCH, of practical interest (if the name is absolute, that is, it ends up with
       a dot, DNS_NOSRCH flag will be set automatically).

   DNSBL Interface
       A DNS-based blocklists, or a DNSBLs, are in  wide  use  nowadays,  especially  to  protect
       mailservers  from  spammers.   The  library provides DNSBL interface, a set of routines to
       perform queries against DNSBLs.  Routines accepts an IP address (IPv4 and  IPv6  are  both
       supported)  and  a  base  DNSBL  zone as query parameters, and returns either dns_rr_a4 or
       dns_rr_txt structure.  Note that IPv6 interface return IPv4 RRset.

       struct dns_query *
       dns_submit_a4dnsbl(ctx,
         const struct in_addr *addr, const char *dnsbl,
         dns_query_a4_fn *cbck, void *data);
       struct dns_query *
       dns_submit_a4dnsbl_txt(ctx,
         const struct in_addr *addr, const char *dnsbl,
         dns_query_txt_fn *cbck, void *data);
       struct dns_query *
       dns_submit_a6dnsbl(ctx,
         const struct in6_addr *addr, const char *dnsbl,
         dns_query_a4_fn *cbck, void *data);
       struct dns_query *
       dns_submit_a6dnsbl_txt(ctx,
         const struct in6_addr *addr, const char *dnsbl,
         dns_query_txt_fn *cbck, void *data);
       struct dns_rr_a4 *dns_resolve_a4dnsbl(ctx,
         const struct in_addr *addr, const char *dnsbl)
       struct dns_rr_txt *dns_resolve_a4dnsbl_txt(ctx,
         const struct in_addr *addr, const char *dnsbl)
       struct dns_rr_a4 *dns_resolve_a6dnsbl(ctx,
         const struct in6_addr *addr, const char *dnsbl)
       struct dns_rr_txt *dns_resolve_a6dnsbl_txt(ctx,
         const struct in6_addr *addr, const char *dnsbl)
       Perform (submit or resolve) a DNSBL query for the given dnsbl domain and  an  IP  addr  in
       question, requesting either A or TXT records.

   RHSBL Interface
       RHSBL is similar to DNSBL, but instead of an IP address, the parameter is a domain name.

       struct dns_query *
       dns_submit_rhsbl(ctx, const char *name, const char *rhsbl,
         dns_query_a4_fn *cbck, void *data);
       struct dns_query *
       dns_submit_rhsbl_txt(ctx, const char *name, const char *rhsbl,
         dns_query_txt_fn *cbck, void *data);
       struct dns_rr_a4 *
       dns_resolve_rhsbl(ctx, const char *name, const char *rhsbl);
       struct dns_rr_txt *
       dns_resolve_rhsbl_txt(ctx, const char *name, const char *rhsbl);
       Perform (submit or resolve) a RHSBL query for the given rhsbl domain and name in question,
       requesting either A or TXT records.

LOW-LEVEL INTERFACE

   Domain Names (DNs)
       A DN is a series of domain name labels each starts with length  byte,  followed  by  empty
       label (label with zero length).  The following routines to work with DNs are provided.

       unsigned dns_dnlen(const unsigned char *dn)
              return length of the domain name dn, including the terminating label.

       unsigned dns_dnlabels(const unsigned char *dn)
              return number of non-zero labels in domain name dn.

       unsigned dns_dnequal(dn1, dn2)
         const unsigned char *dn1, *dn2;
              test  whenever  the  two  domain  names, dn1 and dn2, are equal (case-insensitive).
              Return domain name length if equal or 0 if not.

       unsigned dns_dntodn(sdn, ddn, dnsiz)
         const unsigned char *sdn;
         unsigned char *ddn;
         unsigned dnsiz;
              copies the source domain name sdn to destination buffer ddn of size dnsiz.   Return
              domain name length or 0 if ddn is too small.

       int dns_ptodn(name, namelen, dn, dnsiz, isabs)
       int dns_sptodn(name, dn, dnsiz)
         const char *name; unsigned namelen;
         unsigned char *dn; unsigned dnsiz;
         int *isabs;
              convert asciiz name name of length namelen to DN format, placing result into buffer
              dn of size dnsiz.  Return length of the DN if  successeful,  0  if  the  dn  buffer
              supplied  is too small, or negative value if name is invalid.  If isabs is non-NULL
              and conversion was successeful, *isabs will be set  to  either  1  or  0  depending
              whenever  name  was  absolute  (i.e.  ending  with  a  dot)  or  not.  Name length,
              namelength, may be zero, in which case strlen(name) will  be  used.   Second  form,
              dns_sptodn(), is a simplified form of dns_ptodn(), equivalent to
              dns_ptodn(name, 0, dn, dnlen, 0).

       extern const unsigned char dns_inaddr_arpa_dn[]
       int dns_a4todn(const struct in_addr *addr, const unsigned char *tdn,
             unsigned char *dn, unsigned dnsiz)
       int dns_a4ptodn(const struct in_addr *addr, const char *tname,
             unsigned char *dn, unsigned dnsiz)
       extern const unsigned char dns_ip6_arpa_dn[]
       int dns_a6todn(const struct in6_addr *addr, const unsigned char *tdn,
             unsigned char *dn, unsigned dnsiz)
       int dns_a6ptodn(const struct in6_addr *addr, const char *tname,
             unsigned char *dn, unsigned dnsiz)
              several variants of routines to convert IPv4 and IPv6 address addr into reverseDNS-
              like domain name in DN format, storing result in dn of size dnsiz.  tdn (or  tname)
              is the base zone name, like in-addr.arpa for IPv4 or in6.arpa for IPv6.  If tdn (or
              tname) is NULL, dns_inaddr_arpa_dn (or dns_ip6_arpa_dn) will be used.  The routines
              may  be used to construct a DN for a DNSBL lookup for example.  All routines return
              length of the resulting DN on success, -1 if resulting DN is invalid, or 0  if  the
              dn  buffer  (dnsiz)  is  too  small.   To  hold  standard rDNS DN, a buffer of size
              DNS_A4RSIZE (30 bytes) for  IPv4  address,  or  DNS_A6RSIZE  (74  bytes)  for  IPv6
              address, is sufficient.

       int dns_dntop(dn, name, namesiz)
          const unsigned char *dn;
          const char *name; unsigned namesiz;
              convert  domain  name  dn  in  DN format to asciiz string, placing result into name
              buffer of size namesiz.  Maximum length of asciiz representation of domain name  is
              DNS_MAXNAME  (1024)  bytes.   Root  domain  is represented as empty string.  Return
              length of the resulting name (including terminating character, i.e. strlen(name)+1)
              on  success,  0 if the name buffer is too small, or negative value if dn is invalid
              (last case should never happen since all routines in  this  library  which  produce
              domain names ensure the DNs generated are valid).

       const char *dns_dntosp(const unsigned char *dn)
              convert  domain  name dn in DN format to asciiz string using static buffer.  Return
              the resulting asciiz string on success or NULL on failure.  Note since this routine
              uses static buffer, it is not thread-safe.

       unsigned dns_dntop_size(const unsigned char *dn)
              return  the buffer size needed to convert the dn domain name in DN format to asciiz
              string, for dns_dntop().  The routine return either the size  of  buffer  required,
              including the trailing zero byte, or 0 if dn is invalid.

   Working with DNS Packets
       The  following  routines  are  provided to encode and decode DNS on-wire packets.  This is
       low-level interface.

       DNS response codes (returned by dns_rcode() routine) are  defined  as  constants  prefixed
       with  DNS_R_.   See  udns.h  header  file for the complete list.  In particular, constants
       DNS_R_NOERROR (0), DNS_R_SERVFAIL, DNS_R_NXDOMAIN may be of interest to an application.

       unsigned dns_get16(const unsigned char *p)
       unsigned dns_get32(const unsigned char *p)
              helper routines, convert 16-bit or 32-bit integer in on-wire format pointed to by p
              to unsigned.

       unsigned char *dns_put16(unsigned char *d, unsigned n)
       unsigned char *dns_put32(unsigned char *d, unsigned n)
              helper  routine,  convert  unsigned 16-bit or 32-bit integer n to on-wire format to
              buffer pointed to by d, return d+2 or d+4.

       DNS_HSIZE (12)
              defines size of DNS header.  Data section in the DNS packet immediately follows the
              header.   In  the header, there are query identifier (id), various flags and codes,
              and number of resource records in various data sections.  See  udns.h  header  file
              for complete list of DNS header definitions.

       unsigned dns_qid(const unsigned char *pkt)
       int dns_rd(const unsigned char *pkt)
       int dns_tc(const unsigned char *pkt)
       int dns_aa(const unsigned char *pkt)
       int dns_qr(const unsigned char *pkt)
       int dns_ra(const unsigned char *pkt)
       unsigned dns_opcode(const unsigned char *pkt)
       unsigned dns_rcode(const unsigned char *pkt)
       unsigned dns_numqd(const unsigned char *pkt)
       unsigned dns_numan(const unsigned char *pkt)
       unsigned dns_numns(const unsigned char *pkt)
       unsigned dns_numar(const unsigned char *pkt)
       const unsigned char *dns_payload(const unsigned char *pkt)
              return  various  parts  from  the  DNS  packet  header pkt: query identifier (qid),
              recursion desired (rd) flag, truncation occured  (tc)  flag,  authoritative  answer
              (aa)  flag, query response (qr) flag, recursion available (ra) flag, operation code
              (opcode), result code (rcode), number  of  entries  in  question  section  (numqd),
              number  of  answers  (numan),  number  of  authority  records  (numns),  number  of
              additional records (numar), and the pointer to the packet data (payload).

       int dns_getdn(pkt, curp, pkte, dn, dnsiz)
       const unsigned char *dns_skipdn(cur, pkte)
          const unsigned char *pkt, *pkte, **curp, *cur;
          unsigned char *dn; unsigned dnsiz;
              dns_getdn() extract DN from DNS packet pkt  which  ends  before  pkte  starting  at
              position  *curp  into  buffer  pointed  to  by  dn of size dnsiz.  Upon successeful
              completion, *curp will point to the next byte in the  packet  after  the  extracted
              domain  name.   It return positive number (length of the DN if dn) upon successeful
              completion, negative value on error (when the packet  contains  invalid  data),  or
              zero  if  the  dnsiz  is  too small (maximum length of a domain name is DNS_MAXDN).
              dns_skipdn() return pointer to the next byte in DNS packet  which  ends  up  before
              pkte  after  a  domain  name which starts at the cur byte, or NULL if the packet is
              invalid.  dns_skipdn() is more or less equivalent to what dns_getdn() does,  except
              it  does  not  actually  extract  the  domain  name  in  question, and uses simpler
              interface.

       struct dns_rr {
         unsigned char dnsrr_dn[DNS_MAXDN]; /* the RR DN name */
         enum dns_class dnsrr_cls;          /* class of the RR */
         enum dns_type  dnsrr_typ;          /* type of the RR */
         unsigned dnsrr_ttl;                /* TTL value */
         unsigned dnsrr_dsz;                /* size of data in bytes */
         const unsigned char *dnsrr_dptr;   /* pointer to the first data byte */
         const unsigned char *dnsrr_dend;   /* next byte after RR */
       };
              The dns_rr structure is used to hold information about single DNS  Resource  Record
              (RR) in an easy to use form.

       struct dns_parse {
         const unsigned char *dnsp_pkt; /* pointer to the packet being parsed */
         const unsigned char *dnsp_end; /* end of the packet pointer */
         const unsigned char *dnsp_cur; /* current packet positionn */
         const unsigned char *dnsp_ans; /* pointer to the answer section */
         int dnsp_rrl;                  /* number of RRs left */
         int dnsp_nrr;                  /* number of relevant RRs seen so far */
         unsigned dnsp_ttl;             /* TTL value so far */
         const unsigned char *dnsp_qdn; /* the domain of interest or NULL */
         enum dns_class dnsp_qcls;      /* class of interest or 0 for any */
         enum dns_type  dnsp_qtyp;      /* type of interest or 0 for any */
         unsigned char dnsp_dnbuf[DNS_MAXDN]; /* domain name buffer */
       };
              The  dns_parse  structure  is used to parse DNS reply packet.  It holds information
              about the packet being parsed (dnsp_pkt, dnsp_end and dnsp_cur fields),  number  of
              RRs  in the current section left to do, and the information about specific RR which
              we're looking for (dnsp_qdn, dnsp_qcls and dnsp_qtyp fields).

       int dns_initparse(struct dns_parse *p,
         const unsigned char *qdn,
         const unsigned char *pkt,
         const unsigned char *cur,
         const unsigned char *end)
              initializes the RR parsing structure p.  Arguments pkt, cur and end should describe
              the  received  packet:  pkt is the start of the packet, end points to the next byte
              after the end of the packet, and cur points past the query DN in query section  (to
              query  class+type  information).   And  qdn  points  to  the query DN.  This is the
              arguments passed to dns_parse_fn() routine. dns_initparse()  initializes  dnsp_pkt,
              dnsp_end   and  dnsp_qdn  fields  to  the  corresponding  arguments,  extracts  and
              initializes dnsp_qcls and dnsp_qtyp fields to the  values  found  at  cur  pointer,
              initializes  dnsp_cur  and  dnsp_ans  fields  to  be  cur+4 (to the start of answer
              section), and initializes dnsp_rrl field to be number of entries in answer section.
              dnsp_ttl will be set to max TTL value, 0xffffffff, and dnsp_nrr to 0.

       int dns_nextrr(struct dns_parse *p, struct dns_rr *rr);
              searches  for  next  RR  in  the  packet  based  on  the criteria provided in the p
              structure, filling in the rr structure and advancing p->dnsp_cur to the next RR  in
              the  packet.   RR selection is based on dnsp_qdn, dnsp_qcls and dnsp_qtyp fields in
              the dns_parse structure.  Any (or all) of the 3 fields may be 0,  which  means  any
              actual value from the packet is acceptable.  In case the field isn't 0 (or NULL for
              dnsp_qdn),  only   RRs   with   corresponding   characteristics   are   acceptable.
              Additionally,  when  dnsp_qdn  is  non-NULL,  dns_nextrr() performs automatic CNAME
              expansion.  Routine will return positive value on success, 0 in case it reached the
              end  of  current  section in the packet (p->dnsp_rrl is zero), or negative value if
              next RR can not be  decoded  (packet  format  is  invalid).   The  routine  updates
              p->dnsp_qdn automatically when this field is non-NULL and it encounters appropriate
              CNAME RRs (saving CNAME target in p->dnsp_dnbuf), so  after  end  of  the  process,
              p->dnsp_qdn  will  point  to canonical name of the domain in question.  The routine
              updates p->dnsp_ttl value to be the minimum TTL of all RRs found.

       void dns_rewind(struct dns_parse *p, const unsigned char *qdn)
              this routine "rewinds" the packet parse state structure to be at the same state  as
              after a call to dns_initparse(), i.e. reposition the parse structure p to the start
              of answer section and initialize p->dnsp_rrl to the number  of  entries  in  answer
              section.

       int dns_stdrr_size(const struct dns_parse *p);
              return  size  to hold standard RRset structure information, as shown in dns_rr_null
              structure (for the query and canonical names).  Used to calculate amount of  memory
              to allocate for common part of type-specific RR structures in parsing routines.

       void *dns_stdrr_finish(struct dns_rr_null *ret, char *cp,
         const struct dns_parse *p);
              initializes  standard  RRset fields in ret structure using buffer pointed to by cp,
              which should have at least as many bytes as dns_stdrr_size(p)  returned.   Used  to
              finalize common part of type-specific RR structures in parsing routines.

       See  library  source  for  usage  examples of all the above low-level routines, especially
       source of the parsing routines.

   Auxilary Routines
       int dns_pton(int af, const char *src, void *dst);
              privides  functionality  similar  to  standard  inet_pton()  routine,  to   convert
              printable representation of an IP address of family af (either AF_INET or AF_INET6)
              pointed to by src into binary form suitable for socket addresses  and  transmission
              over  network,  in  buffer  pointed to by dst.  The destination buffer should be of
              size 4 for AF_INET family or 16 for AF_INET6.  The  return  value  is  positive  on
              success, 0 if src is not a valid text representation of an address of family af, or
              negative if the given address family is not supported.

       const char *dns_ntop(int af, const void *src,
           char *dst, int dstsize)
              privides functionality similar to standard inet_ntop() routine, to  convert  binary
              representation  of  an IP address of family af (either AF_INET or AF_INET6) pointed
              to by src (either 4 or 16 bytes) into printable form in buffer in buffer pointed to
              by dst of size dstsize.  The destination buffer should be at least of size 16 bytes
              for AF_INET family or 46 bytes for AF_INET6.  The return value is  either  dst,  or
              NULL  pointer  if dstsize is too small to hold this address or if the given address
              family is not supported.

AUTHOR

       The udns library has been written by Michael Tokarev, mjt@corpit.ru.

VERSION

       This manual page corresponds to udns version 0.0.9, released Jan-2007.