sres.c

Bug Summary

File:	sresolv/sres.c
Warning:	line 3837, column 3 Address of stack memory associated with local variable 'sr0' returned to caller
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name sres.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -mdisable-fp-elim -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -resource-dir /usr/lib/llvm-7/lib/clang/7.0.1 -D HAVE_CONFIG_H -I . -I ../.. -I ../../libsofia-sip-ua/su/sofia-sip -I ./../url -I ../url -I ./../bnf -I ../bnf -I ./../su -I ../su -I ../../s2check -D SU_DEBUG=0 -D PIC -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.1/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fdebug-compilation-dir /drone/src/libsofia-sip-ua/sresolv -ferror-limit 19 -fmessage-length 0 -fobjc-runtime=gcc -fdiagnostics-show-option -analyzer-output=html -o /drone/src/scan-build/2021-08-26-202507-364-1 -x c sres.c -faddrsig
1/*
* This file is part of the Sofia-SIP package
*
* Copyright (C) 2006 Nokia Corporation.
* Copyright (C) 2006 Dimitri E. Prado.
*
* Contact: Pekka Pessi <pekka.pessi@nokia.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA
*
*/

26/**@CFILE sres.c
* @brief Sofia DNS Resolver implementation.
*
* @author Pekka Pessi <Pekka.Pessi@nokia.com>
* @author Teemu Jalava <Teemu.Jalava@nokia.com>
* @author Mikko Haataja
* @author Kai Vehmanen <kai.vehmanen@nokia.com>
*         (work on the win32 nameserver discovery)
* @author Dimitri E. Prado
*         (initial version of win32 nameserver discovery)
*
* @todo The resolver should allow handling arbitrary records, too.
*/

40#include "config.h"

42#if HAVE_STDINT_H1
43#include <stdint.h>
44#elif HAVE_INTTYPES_H1
45#include <inttypes.h>
46#else
47#if defined(HAVE_WIN32)
48typedef _int8 int8_t;
49typedef unsigned _int8 uint8_t;
50typedef unsigned _int16 uint16_t;
51typedef unsigned _int32 uint32_t;
52#endif
53#endif

55#if HAVE_NETINET_IN_H1
56#include <sys/types.h>
57#include <sys/socket.h>
58#include <netinet/in.h>
59#endif

61#if HAVE_ARPA_INET_H1
62#include <arpa/inet.h>
63#endif

65#if HAVE_WINSOCK2_H
66#include <winsock2.h>
67#include <ws2tcpip.h>
68#ifndef IPPROTO_IPV6IPPROTO_IPV6		/* socklen_t is used with @RFC2133 API */
69typedef int socklen_t;
70#endif
71#endif

73#if HAVE_IPHLPAPI_H
74#include <iphlpapi.h>
75#endif

77#if HAVE_IP_RECVERR1 || HAVE_IPV6_RECVERR1
78#include <linux1/types.h>
79#include <linux1/errqueue.h>
80#include <sys/uio.h>
81#endif

83#include <time.h>

85#include "sofia-resolv/sres.h"
86#include "sofia-resolv/sres_cache.h"
87#include "sofia-resolv/sres_record.h"
88#include "sofia-resolv/sres_async.h"

90#include <sofia-sip/su_alloc.h>
91#include <sofia-sip/su_strlst.h>
92#include <sofia-sip/su_string.h>
93#include <sofia-sip/su_errno.h>

95#include "sofia-sip/htable.h"

97#include <sys/types.h>
98#include <sys/stat.h>
99#include <fcntl.h>
100#include <unistd.h>

102#include <stdlib.h>
103#include <stdarg.h>
104#include <stddef.h>
105#include <string.h>
106#include <stdio.h>
107#include <errno(*__errno_location ()).h>

109#include <limits.h>

111#include <assert.h>

113#if HAVE_WINSOCK2_H
114/* Posix send() */
115su_inlinestatic inline
116ssize_t sres_send(sres_socket_t s, void *b, size_t length, int flags)send((sres_socket_t s),(void *b),(size_t length),(int flags))
117{
if (length > INT_MAX2147483647)
  length = INT_MAX2147483647;
return (ssize_t)send(s, b, (int)length, flags);
121}

123/* Posix recvfrom() */
124su_inlinestatic inline
125ssize_t sres_recvfrom(sres_socket_t s, void *buffer, size_t length, int flags,recvfrom((sres_socket_t s),(void *buffer),(size_t length),(int
 flags),(struct sockaddr *from),(socklen_t *fromlen))
      struct sockaddr *from, socklen_t *fromlen)recvfrom((sres_socket_t s),(void *buffer),(size_t length),(int
 flags),(struct sockaddr *from),(socklen_t *fromlen))
127{
int retval, ilen = 0;

if (fromlen)
  ilen = *fromlen;

if (length > INT_MAX2147483647)
  length = INT_MAX2147483647;

retval = recvfrom(s, buffer, (int)length, flags,
    (void *)from, fromlen ? &ilen : NULL((void*)0));

if (fromlen)
  *fromlen = ilen;

return (ssize_t)retval;
143}

145su_inlinestatic inline
146int sres_close(sres_socket_t s)close((sres_socket_t s))
147{
return closesocket(s);
149}

151#if !defined(IPPROTO_IPV6IPPROTO_IPV6) && (_WIN32_WINNT < 0x0600)
152#if HAVE_SIN61
153#include <tpipv6.h>
154#else
155#if !defined(__MINGW32__)
156struct sockaddr_storage {
  short ss_family;
  char ss_pad[126];
159};
160#endif
161#endif
162#endif
163#else

165#define sres_send(s,b,len,flags)send((s),(b),(len),(flags)) send((s),(b),(len),(flags))
166#define sres_recvfrom(s,b,len,flags,a,alen)recvfrom((s),(b),(len),(flags),(a),(alen)) \
recvfrom((s),(b),(len),(flags),(a),(alen))
168#define sres_close(s)close((s)) close((s))
169#define SOCKET_ERROR(-1)   (-1)
170#define INVALID_SOCKET((sres_socket_t)-1) ((sres_socket_t)-1)
171#endif

173#define SRES_TIME_MAX((time_t)9223372036854775807L) ((time_t)LONG_MAX9223372036854775807L)

175#if !HAVE_INET_PTON1
176int su_inet_ptoninet_pton(int af, char const *src, void *dst);
177#else
178#define su_inet_ptoninet_pton inet_pton
179#endif
180#if !HAVE_INET_NTOP1
181const char *su_inet_ntopinet_ntop(int af, void const *src, char *dst, size_t size);
182#else
183#define su_inet_ntopinet_ntop inet_ntop
184#endif

186#if defined(va_copy)
187#elif defined(__va_copy)
188#define va_copy(dst, src)__builtin_va_copy(dst, src) __va_copy((dst), (src))__builtin_va_copy((dst),(src))
189#else
190#define va_copy(dst, src)__builtin_va_copy(dst, src) (memcpy(&(dst), &(src), sizeof (va_list)))
191#endif

193/*
* 3571 is a prime =>
* we hash successive id values to different parts of hash tables
*/
197#define Q_PRIME3571 3571
198#define SRES_QUERY_HASH(q)((q)->q_hash) ((q)->q_hash)

200/**
* How often to recheck nameserver information (seconds).
*/
203#ifndef HAVE_WIN32
204#define SRES_UPDATE_INTERVAL_SECS5        5
205#else
206#define SRES_UPDATE_INTERVAL_SECS5        180
207#endif
208void sres_cache_clean(sres_cache_t *cache, time_t now);

210typedef struct sres_message    sres_message_t;
211typedef struct sres_config     sres_config_t;
212typedef struct sres_server     sres_server_t;
213typedef struct sres_nameserver sres_nameserver_t;

215/** Default path to resolv.conf */
216static char const sres_conf_file_path[] = "/etc/resolv.conf";

218/** EDNS0 support. @internal */
219enum edns {
edns_not_tried = -1,
edns_not_supported = 0,
edns0_configured = 1,
edns0_supported = 2,
224};

226struct sres_server {
sres_socket_t           dns_socket;

char                    dns_name[48];     /**< Server name */
struct sockaddr_storage dns_addr[1];  /**< Server node address */
ssize_t                 dns_addrlen;  /**< Size of address */

enum edns               dns_edns;	/**< Server supports edns. */

/** ICMP/temporary error received, zero when successful. */
time_t                  dns_icmp;
/** Persistent error, zero when successful or timeout.
 *
 * Never selected if dns_error is SRES_TIME_MAX.
 */
time_t                  dns_error;
242};

244HTABLE_DECLARE_WITH(sres_qtable, qt, sres_query_t, unsigned, size_t)typedef struct sres_qtable_s { unsigned qt_size; unsigned qt_used
; sres_query_t**qt_table; } sres_qtable_t;

246struct sres_resolver_s {
su_home_t           res_home[1];

void               *res_userdata;
sres_cache_t       *res_cache;

time_t              res_now;
sres_qtable_t       res_queries[1];   /**< Table of active queries */

char const         *res_cnffile;      /**< Configuration file name */
char const        **res_options;      /**< Option strings */

sres_config_t const *res_config;
time_t              res_checked;

unsigned long       res_updated;
sres_update_f      *res_updcb;
sres_async_t       *res_async;
sres_schedule_f    *res_schedulecb;
short               res_update_all;

uint16_t            res_id;
short               res_i_server;  /**< Current server to try
			(when doing round-robin) */
short               res_n_servers; /**< Number of servers */
sres_server_t     **res_servers;
272};

274/* Parsed configuration. @internal */
275struct sres_config {
su_home_t c_home[1];

time_t c_modified;
char const *c_filename;

/* domain and search */
char const *c_search[SRES_MAX_SEARCH(SRES_MAX_SEARCH) + 1];

/* nameserver */
struct sres_nameserver {
  struct sockaddr_storage ns_addr[1];
  ssize_t ns_addrlen;
} *c_nameservers[SRES_MAX_NAMESERVERS(SRES_MAX_NAMESERVERS) + 1];

/* sortlist */
struct sres_sortlist {
  struct sockaddr_storage addr[1];
  ssize_t addrlen;
  char const *name;
} *c_sortlist[SRES_MAX_SORTLIST(SRES_MAX_SORTLIST) + 1];

uint16_t    c_port;	     /**< Server port to use */

/* options */
struct sres_options {
  uint16_t timeout;
  uint16_t attempts;
  uint16_t ndots;
  enum edns edns;
  unsigned debug:1;
  unsigned rotate:1;
  unsigned check_names:1;
  unsigned inet6:1;
  unsigned ip6int:1;
  unsigned ip6bytestring:1;
} c_opt;
312};

314struct sres_query_s {
unsigned        q_hash;
sres_resolver_t*q_res;
sres_answer_f  *q_callback;
sres_context_t *q_context;
char           *q_name;
time_t          q_timestamp;
uint16_t        q_type;
uint16_t        q_class;
uint16_t        q_id;			/**< If nonzero, not answered */
uint16_t        q_retry_count;
uint8_t         q_n_servers;
uint8_t         q_i_server;
int8_t          q_edns;
uint8_t         q_n_subs;
sres_query_t   *q_subqueries[1 + SRES_MAX_SEARCH(SRES_MAX_SEARCH)];
sres_record_t **q_subanswers[1 + SRES_MAX_SEARCH(SRES_MAX_SEARCH)];
331};


334struct sres_message {
uint16_t m_offset;
uint16_t m_size;
char const *m_error;
union {
  struct {
    /* Header defined in RFC 1035 section 4.1.1 (page 26) */
    uint16_t mh_id;		/* Query ID */
    uint16_t mh_flags;	/* Flags */
    uint16_t mh_qdcount;	/* Question record count */
    uint16_t mh_ancount;	/* Answer record count */
    uint16_t mh_nscount;	/* Authority records count */
    uint16_t mh_arcount;	/* Additional records count */
  } mp_header;
  uint8_t mp_data[1500 - 40];	/**< IPv6 datagram */
} m_packet;
350#define m_idm_packet.mp_header.mh_id      m_packet.mp_header.mh_id
351#define m_flagsm_packet.mp_header.mh_flags   m_packet.mp_header.mh_flags
352#define m_qdcountm_packet.mp_header.mh_qdcount m_packet.mp_header.mh_qdcount
353#define m_ancountm_packet.mp_header.mh_ancount m_packet.mp_header.mh_ancount
354#define m_nscountm_packet.mp_header.mh_nscount m_packet.mp_header.mh_nscount
355#define m_arcountm_packet.mp_header.mh_arcount m_packet.mp_header.mh_arcount
356#define m_datam_packet.mp_data    m_packet.mp_data
357};

359#define sr_refcountsr_record->r_refcount sr_record->r_refcount
360#define sr_namesr_record->r_name     sr_record->r_name
361#define sr_statussr_record->r_status   sr_record->r_status
362#define sr_sizesr_record->r_size     sr_record->r_size
363#define sr_typesr_record->r_type     sr_record->r_type
364#define sr_classsr_record->r_class    sr_record->r_class
365#define sr_ttlsr_record->r_ttl      sr_record->r_ttl
366#define sr_rdlensr_record->r_rdlen    sr_record->r_rdlen
367#define sr_parsedsr_record->r_parsed   sr_record->r_parsed
368#define sr_rdatasr_generic->g_data    sr_generic->g_data

370enum {
SRES_HDR_QR = (1 << 15),
SRES_HDR_QUERY = (0 << 11),
SRES_HDR_IQUERY = (1 << 11),
SRES_HDR_STATUS = (2 << 11),
SRES_HDR_OPCODE = (15 << 11),	/* mask */
SRES_HDR_AA = (1 << 10),
SRES_HDR_TC = (1 << 9),
SRES_HDR_RD = (1 << 8),
SRES_HDR_RA = (1 << 7),
SRES_HDR_RCODE = (15 << 0)	/* mask of return code */
381};

383HTABLE_PROTOS_WITH(sres_qtable, qt, sres_query_t, unsigned, size_t)static inline int sres_qtable_resize(su_home_t *, sres_qtable_t
 qt[1], unsigned); static inline int sres_qtable_is_full(sres_qtable_t
 const *); static inline sres_query_t **sres_qtable_hash(sres_qtable_t
 const *, size_t hv); static inline sres_query_t **sres_qtable_next
(sres_qtable_t const *, sres_query_t * const *ee); static inline
 void sres_qtable_append(sres_qtable_t *qt, sres_query_t const
 *e); static inline void sres_qtable_insert(sres_qtable_t *qt
, sres_query_t const *e); static inline int sres_qtable_remove
(sres_qtable_t *, sres_query_t const *e);

385#define CHOME(cache)((su_home_t *)(cache)) ((su_home_t *)(cache))

387/** Get address from sockaddr storage. */
388#if HAVE_SIN61
389#define SS_ADDR(ss)((ss)->ss_family == 2 ? (void *)&((struct sockaddr_in *
)ss)->sin_addr : ((ss)->ss_family == 10 ? (void *)&
((struct sockaddr_in6 *)ss)->sin6_addr : (void *)&((struct
 sockaddr *)ss)->sa_data)) \
((ss)->ss_family == AF_INET2 ? \
 (void *)&((struct sockaddr_in *)ss)->sin_addr : \
((ss)->ss_family == AF_INET610 ? \
 (void *)&((struct sockaddr_in6 *)ss)->sin6_addr : \
 (void *)&((struct sockaddr *)ss)->sa_data))
395#else
396#define SS_ADDR(ss)((ss)->ss_family == 2 ? (void *)&((struct sockaddr_in *
)ss)->sin_addr : ((ss)->ss_family == 10 ? (void *)&
((struct sockaddr_in6 *)ss)->sin6_addr : (void *)&((struct
 sockaddr *)ss)->sa_data)) \
((ss)->ss_family == AF_INET2 ? \
 (void *)&((struct sockaddr_in *)ss)->sin_addr : \
 (void *)&((struct sockaddr *)ss)->sa_data)
400#endif

402static int sres_config_changed_servers(sres_config_t const *new_c,
		       sres_config_t const *old_c);
404static sres_server_t **sres_servers_new(sres_resolver_t *res,
			sres_config_t const *c);
406static sres_answer_f sres_resolving_cname;

408/** Generate new 16-bit identifier for DNS query. */
409static void
410sres_gen_id(sres_resolver_t *res, sres_query_t *query)
411{
if (res->res_id == 0) {
  res->res_id = 1;
}
query->q_id = res->res_id++;
query->q_hash = query->q_id * Q_PRIME3571;
417}

419/** Return true if we have a search list or a local domain name. */
420static int
421sres_has_search_domain(sres_resolver_t *res)
422{
return res->res_config->c_search[0] != NULL((void*)0);
424}

426static void sres_resolver_destructor(void *);

428sres_resolver_t *
429sres_resolver_new_with_cache_va(char const *conf_file_path,
		sres_cache_t *cache,
		char const *options,
		va_list va);
433static
434sres_resolver_t *
435sres_resolver_new_internal(sres_cache_t *cache,
	   sres_config_t const *config,
	   char const *conf_file_path,
	   char const **options);

440static void sres_servers_close(sres_resolver_t *res,
	       sres_server_t **servers);

443static int sres_servers_count(sres_server_t * const *servers);

445static sres_socket_t sres_server_socket(sres_resolver_t *res,
			sres_server_t *dns);

448static sres_query_t * sres_query_alloc(sres_resolver_t *res,
		       sres_answer_f *callback,
		       sres_context_t *context,
		       uint16_t type,
		       char const * domain);

454static void sres_free_query(sres_resolver_t *res, sres_query_t *q);

456static
457int sres_sockaddr2string(sres_resolver_t *,
	 char name[], size_t namelen,
	 struct sockaddr const *);

461static
462sres_config_t *sres_parse_resolv_conf(sres_resolver_t *res,
		      char const **options);

465static
466sres_server_t *sres_next_server(sres_resolver_t *res,
		uint8_t *in_out_i,
		int always);

470static
471int sres_send_dns_query(sres_resolver_t *res, sres_query_t *q);

473static
474void sres_answer_subquery(sres_context_t *context,
	  sres_query_t *query,
	  sres_record_t **answers);

478static
479sres_record_t **
480sres_combine_results(sres_resolver_t *res,
     sres_record_t **search_results[SRES_MAX_SEARCH(SRES_MAX_SEARCH) + 1]);

483static
484void sres_query_report_error(sres_query_t *q,
	     sres_record_t **answers);

487static void
488sres_resend_dns_query(sres_resolver_t *res, sres_query_t *q, int timeout);

490static
491sres_server_t *sres_server_by_socket(sres_resolver_t const *ts,
		     sres_socket_t socket);

494static
495int sres_resolver_report_error(sres_resolver_t *res,
	       sres_socket_t socket,
	       int errcode,
	       struct sockaddr_storage *remote,
	       socklen_t remotelen,
	       char const *info);

502static
503void sres_log_response(sres_resolver_t const *res,
       sres_message_t const *m,
       struct sockaddr_storage const *from,
       sres_query_t const *query,
       sres_record_t * const *reply);

509static int sres_decode_msg(sres_resolver_t *res,
	   sres_message_t *m,
	   sres_query_t **,
	   sres_record_t ***aanswers);

514static char const *sres_toplevel(char buf[], size_t bsize, char const *domain);

516static sres_record_t *sres_create_record(sres_resolver_t *,
			 sres_message_t *m,
			 int nth);

520static sres_record_t *sres_init_rr_soa(sres_cache_t *cache,
		       sres_soa_record_t *,
		       sres_message_t *m);
523static sres_record_t *sres_init_rr_a(sres_cache_t *cache,
		     sres_a_record_t *,
		     sres_message_t *m);
526static sres_record_t *sres_init_rr_a6(sres_cache_t *cache,
		      sres_a6_record_t *,
		      sres_message_t *m);
529static sres_record_t *sres_init_rr_aaaa(sres_cache_t *cache,
			sres_aaaa_record_t *,
			sres_message_t *m);
532static sres_record_t *sres_init_rr_cname(sres_cache_t *cache,
			 sres_cname_record_t *,
			 sres_message_t *m);
535static sres_record_t *sres_init_rr_ptr(sres_cache_t *cache,
		       sres_ptr_record_t *,
		       sres_message_t *m);
538static sres_record_t *sres_init_rr_srv(sres_cache_t *cache,
		       sres_srv_record_t *,
		       sres_message_t *m);
541static sres_record_t *sres_init_rr_naptr(sres_cache_t *cache,
			 sres_naptr_record_t *,
			 sres_message_t *m);
544static sres_record_t *sres_init_rr_unknown(sres_cache_t *cache,
			   sres_common_t *r,
			   sres_message_t *m);

548static sres_record_t *sres_create_error_rr(sres_cache_t *cache,
                                         sres_query_t const *q,
                                         uint16_t errcode);

552static void m_put_uint16(sres_message_t *m, uint16_t h);
553static void m_put_uint32(sres_message_t *m, uint32_t w);

555static uint16_t m_put_domain(sres_message_t *m,
                           char const *domain,
                           uint16_t top,
                           char const *topdomain);

560static uint32_t m_get_uint32(sres_message_t *m);
561static uint16_t m_get_uint16(sres_message_t *m);
562static uint8_t m_get_uint8(sres_message_t *m);

564static unsigned m_get_string(char *d, unsigned n, sres_message_t *m, uint16_t offset);
565static unsigned m_get_domain(char *d, unsigned n, sres_message_t *m, uint16_t offset);

567/* ---------------------------------------------------------------------- */

569#define SU_LOGsresolv_log sresolv_log

571#include <sofia-sip/su_debug.h>

573#ifdef HAVE_WIN32
574#include <winreg.h>
575#endif

577/**@ingroup sresolv_env
*
* Environment variable determining the debug log level for @b sresolv
* module.
*
* The SRESOLV_DEBUG environment variable is used to determine the debug
* logging level for @b sresolv module. The default level is 3.
*
* @sa <sofia-sip/su_debug.h>, sresolv_log, SOFIA_DEBUG
*/
587#ifdef DOXYGEN
588extern char const SRESOLV_DEBUG[]; /* dummy declaration for Doxygen */
589#endif

591#ifndef SU_DEBUG0
592#define SU_DEBUG0 3
593#endif

595/**Debug log for @b sresolv module.
*
* The sresolv_log is the log object used by @b sresolv module. The level of
* #sresolv_log is set using #SRESOLV_DEBUG environment variable.
*/
600su_log_t sresolv_log[] = { SU_LOG_INIT("sresolv", "SRESOLV_DEBUG", SU_DEBUG){ sizeof(su_log_t), "sresolv", "SRESOLV_DEBUG", 0, SU_LOG_MAX
, 0, ((void*)0), ((void*)0), } };

602/** Internal errors */
603enum {
SRES_EDNS0_ERR = 255		/**< Server did not support EDNS. */
605};

607/* ---------------------------------------------------------------------- */

609/**Create a resolver.
*
* Allocate and initialize a new sres resolver object. The resolver object
* contains the parsed resolv.conf file, a cache object containing past
* answers from DNS, and a list of active queries. The default resolv.conf
* file can be overriden by giving the name of the configuration file as @a
* conf_file_path.
*
* @param conf_file_path name of the resolv.conf configuration file
*
* @return A pointer to a newly created sres resolver object, or NULL upon
* an error.
*/
622sres_resolver_t *
623sres_resolver_new(char const *conf_file_path)
624{
return sres_resolver_new_internal(NULL((void*)0), NULL((void*)0), conf_file_path, NULL((void*)0));
626}

628/** Copy a resolver.
*
* Make a copy of resolver sharing the configuration and cache with old
* resolver.
*/
633sres_resolver_t *sres_resolver_copy(sres_resolver_t *res)
634{
char const *cnffile;
sres_config_t *config;
sres_cache_t *cache;
char const **options;

if (!res)
  return NULL((void*)0);

cnffile = res->res_cnffile;
config = su_home_ref(res->res_config->c_home);
cache = res->res_cache;
options = res->res_options;

return sres_resolver_new_internal(cache, config, cnffile, options);
649}

651/**New resolver object.
*
* Allocate and initialize a new sres resolver object. The resolver object
* contains the parsed resolv.conf file, a cache object containing past
* answers from DNS, and a list of active queries. The default resolv.conf
* file can be overriden by giving the name of the configuration file as @a
* conf_file_path.
*
* It is also possible to override the values in the resolv.conf and
* RES_OPTIONS by giving the directives in the NULL-terminated list.
*
* @param conf_file_path name of the resolv.conf configuration file
* @param cache          optional pointer to a resolver cache (may be NULL)
* @param option, ...    list of resolv.conf options directives
*                       (overriding options in conf_file)
*
* @par Environment Variables
* - #LOCALDOMAIN overrides @c domain or @c search directives
* - #RES_OPTIONS overrides values of @a options in resolv.conf
* - #SRES_OPTIONS overrides values of @a options in resolv.conf, #RES_OPTIONS,
*   and @a options, ... list given as argument for this function
*
* @return A pointer to a newly created sres resolver object, or NULL upon
* an error.
*/
676sres_resolver_t *
677sres_resolver_new_with_cache(char const *conf_file_path,
	     sres_cache_t *cache,
	     char const *option, ...)
680{
sres_resolver_t *retval;
va_list va;
va_start(va, option)__builtin_va_start(va, option);
retval = sres_resolver_new_with_cache_va(conf_file_path, cache, option, va);
va_end(va)__builtin_va_end(va);
return retval;
687}

689/**Create a resolver.
*
* Allocate and initialize a new sres resolver object.
*
* This is a stdarg version of sres_resolver_new_with_cache().
*/
695sres_resolver_t *
696sres_resolver_new_with_cache_va(char const *conf_file_path,
		sres_cache_t *cache,
		char const *option,
		va_list va)
700{
va_list va0;
size_t i;
char const *o, *oarray[16], **olist = oarray;
sres_resolver_t *res;

va_copy(va0, va)__builtin_va_copy(va0, va);

for (i = 0, o = option; o; o = va_arg(va0, char const *)__builtin_va_arg(va0, char const *)) {
  if (i < 16)
    olist[i] = o;
  i++;
}

if (i >= 16) {
  olist = malloc((i + 1) * sizeof *olist);
  if (!olist)
    return NULL((void*)0);
  for (i = 0, o = option; o; o = va_arg(va, char const *)__builtin_va_arg(va, char const *)) {
    olist[i++] = o;
    i++;
  }
}
olist[i] = NULL((void*)0);
res = sres_resolver_new_internal(cache, NULL((void*)0), conf_file_path, olist);
if (olist != oarray)
  free(olist);

va_end(va0)__builtin_va_end(va0);

return res;
731}

733sres_resolver_t *
734sres_resolver_new_internal(sres_cache_t *cache,
	   sres_config_t const *config,
	   char const *conf_file_path,
	   char const **options)
738{
sres_resolver_t *res;
size_t i, n, len;
char **array, *o, *end;

for (n = 0, len = 0; options && options[n]; n++)
  len += strlen(options[n]) + 1;

res = su_home_new(sizeof(*res) + (n + 1) * (sizeof *options) + len);

if (res == NULL((void*)0))
  return NULL((void*)0);

array = (void *)(res + 1);
o = (void *)(array + n + 1);
end = o + len;

for (i = 0; options && options[i]; i++)
  o = memccpy(array[i] = o, options[i], '\0', len - (end - o));
assert(o == end)((void) sizeof ((o == end) ? 1 : 0), __extension__ ({ if (o ==
 end) ; else __assert_fail ("o == end", "sres.c", 757, __extension__
 __PRETTY_FUNCTION__); }));

su_home_destructor(res->res_home, sres_resolver_destructor);

while (res->res_id == 0) {
762#if HAVE_DEV_URANDOM1
  int fd;
  if ((fd = open("/dev/urandom", O_RDONLY00, 0)) != -1) {
    size_t len = read(fd, &res->res_id, (sizeof res->res_id)); (void)len;
    close(fd);
  }
  else
769#endif
  res->res_id = time(NULL((void*)0));
}

time(&res->res_now);

if (cache)
  res->res_cache = sres_cache_ref(cache);
else
  res->res_cache = sres_cache_new(0);

res->res_config = config;

if (conf_file_path && conf_file_path != sres_conf_file_path)
  res->res_cnffile = su_strdup(res->res_home, conf_file_path);
else
  res->res_cnffile = conf_file_path = sres_conf_file_path;

if (!res->res_cache || !res->res_cnffile) {
  perror("sres: malloc");
}
else if (sres_qtable_resize(res->res_home, res->res_queries, 0) < 0) {
  perror("sres: res_qtable_resize");
}
else if (sres_resolver_update(res, config == NULL((void*)0)) < 0) {
  perror("sres: sres_resolver_update");
}
else {
  return res;
}

sres_resolver_unref(res);

return NULL((void*)0);
803}

805/** Increase reference count on a resolver object. */
806sres_resolver_t *
807sres_resolver_ref(sres_resolver_t *res)
808{
return su_home_ref(res->res_home);
810}

812/** Decrease the reference count on a resolver object.  */
813void
814sres_resolver_unref(sres_resolver_t *res)
815{
su_home_unref(res->res_home);
817}

819/** Set userdata pointer.
*
* @return New userdata pointer.
*
* @ERRORS
* @ERROR EFAULT @a res points outside the address space
*/
826void *
827sres_resolver_set_userdata(sres_resolver_t *res,
	   void *userdata)
829{
void *old;

if (!res)
  return su_seterrno(EFAULT14), (void *)NULL((void*)0);

old = res->res_userdata, res->res_userdata = userdata;

return old;
838}

840/**Get userdata pointer.
*
* @return Userdata pointer.
*
* @ERRORS
* @ERROR EFAULT @a res points outside the address space
*/
847void *
848sres_resolver_get_userdata(sres_resolver_t const *res)
849{
if (res == NULL((void*)0))
  return su_seterrno(EFAULT14), (void *)NULL((void*)0);
else
  return res->res_userdata;
854}

856/** Set async object.
*
* @return Set async object.
*
* @ERRORS
* @ERROR EFAULT @a res points outside the address space
* @ERROR EALREADY different async callback already set
*/
864sres_async_t *
865sres_resolver_set_async(sres_resolver_t *res,
	sres_update_f *callback,
	sres_async_t *async,
	int update_all)
869{
if (!res)
  return su_seterrno(EFAULT14), (void *)NULL((void*)0);

if (res->res_updcb && res->res_updcb != callback)
  return su_seterrno(EALREADY114), (void *)NULL((void*)0);

res->res_async = async;
res->res_updcb = callback;
res->res_update_all = callback && update_all != 0;

return async;
881}

883/** Get async object */
884sres_async_t *
885sres_resolver_get_async(sres_resolver_t const *res,
	sres_update_f *callback)
887{
if (res == NULL((void*)0))
  return su_seterrno(EFAULT14), (void *)NULL((void*)0);
else if (callback == NULL((void*)0))
  return res->res_async ? (sres_async_t *)-1 : 0;
else if (res->res_updcb != callback)
  return NULL((void*)0);
else
  return res->res_async;
896}

898/** Register resolver timer callback. */
899int sres_resolver_set_timer_cb(sres_resolver_t *res,
	       sres_schedule_f *callback,
	       sres_async_t *async)
902{
if (res == NULL((void*)0))
  return su_seterrno(EFAULT14);
if (res->res_async != async)
  return su_seterrno(EALREADY114);

res->res_schedulecb = callback;
return 0;
910}

912/**Send a DNS query.
*
* Sends a DNS query with specified @a type and @a domain to the DNS server.
* When an answer is received, the @a callback function is called with
* @a context and returned records as arguments.
*
* The sres resolver takes care of retransmitting the query if a root object
* is associate with the resolver or if sres_resolver_timer() is called in
* regular intervals. It generates an error record with nonzero status if no
* response is received.
*
* @param res pointer to resolver
* @param callback function called when query is answered or times out
* @param context pointer given as an extra argument to @a callback function
* @param type record type to query (see #sres_qtypes)
* @param domain name to query
*
* Query types also indicate the record type of the result.
* Any record can be queried with #sres_qtype_any.
* Well-known query types understood and decoded by @b sres include
* #sres_type_a,
* #sres_type_aaaa,
* #sres_type_cname,
* #sres_type_ptr
* #sres_type_soa,
* #sres_type_aaaa,
* #sres_type_srv, and
* #sres_type_naptr.
*
* Deprecated query type #sres_type_a6 is also decoded.
*
* @note The domain name is @b not concatenated with the domains from seach
* path or with the local domain. Use sres_search() in order to try domains
* in search path.
*
* @sa sres_search(), sres_blocking_query(), sres_cached_answers(),
* sres_query_sockaddr()
*
* @ERRORS
* @ERROR EFAULT @a res or @a domain point outside the address space
* @ERROR ENAMETOOLONG @a domain is longer than SRES_MAXDNAME
* @ERROR ENETDOWN no DNS servers configured
* @ERROR ENOMEM memory exhausted
*/
956sres_query_t *
957sres_query(sres_resolver_t *res,
  sres_answer_f *callback,
  sres_context_t *context,
  uint16_t type,
  char const *domain)
962{
sres_query_t *query = NULL((void*)0);
size_t dlen;

char b[8];
SU_DEBUG_9(("sres_query(%p, %p, %s, \"%s\") called\n",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 968, "sres_query(%p, %p, %s, \"%s\") called\n"
, (void *)res, (void *)context, sres_record_type(type, b), domain
)) : (void)0)
	  (void *)res, (void *)context, sres_record_type(type, b), domain))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 968, "sres_query(%p, %p, %s, \"%s\") called\n"
, (void *)res, (void *)context, sres_record_type(type, b), domain
)) : (void)0);

if (res == NULL((void*)0) || domain == NULL((void*)0))
  return su_seterrno(EFAULT14), (void *)NULL((void*)0);

dlen = strlen(domain);
if (dlen > SRES_MAXDNAME(SRES_MAXDNAME) ||
    (dlen == SRES_MAXDNAME(SRES_MAXDNAME) && domain[dlen - 1] != '.')) {
  su_seterrno(ENAMETOOLONG36);
  return NULL((void*)0);
}

/* Reread resolv.conf if needed */
sres_resolver_update(res, 0);

if (res->res_n_servers == 0)
  return (void)su_seterrno(ENETDOWN100), (sres_query_t *)NULL((void*)0);

query = sres_query_alloc(res, callback, context, type, domain);

if (query && sres_send_dns_query(res, query) != 0)
  sres_free_query(res, query), query = NULL((void*)0);

return query;
992}

994/**Search DNS.
*
* Sends DNS queries with specified @a type and @a name to the DNS server.
* If the @a name does not contain enought dots, the search domains are
* appended to the name and resulting domain name are also queried. When
* answer to all the search domains is received, the @a callback function
* is called with @a context and combined records from answers as arguments.
*
* The sres resolver takes care of retransmitting the queries if a root
* object is associate with the resolver or if sres_resolver_timer() is
* called in regular intervals. It generates an error record with nonzero
* status if no response is received.
*
* @param res pointer to resolver object
* @param callback pointer to completion function
* @param context argument given to the completion function
* @param type record type to search (or sres_qtype_any for any record)
* @param name host or domain name to search from DNS
*
* @ERRORS
* @ERROR EFAULT @a res or @a domain point outside the address space
* @ERROR ENAMETOOLONG @a domain is longer than SRES_MAXDNAME
* @ERROR ENETDOWN no DNS servers configured
* @ERROR ENOMEM memory exhausted
*
* @sa sres_query(), sres_blocking_search(), sres_search_cached_answers().
*/
1021sres_query_t *
1022sres_search(sres_resolver_t *res,
   sres_answer_f *callback,
   sres_context_t *context,
   uint16_t type,
   char const *name)
1027{
char const *domain = name;
sres_query_t *query = NULL((void*)0);
size_t dlen;
unsigned dots; char const *dot;
char b[8];

SU_DEBUG_9(("sres_search(%p, %p, %s, \"%s\") called\n",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 1035, "sres_search(%p, %p, %s, \"%s\") called\n"
, (void *)res, (void *)context, sres_record_type(type, b), domain
)) : (void)0)
	  (void *)res, (void *)context, sres_record_type(type, b), domain))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 1035, "sres_search(%p, %p, %s, \"%s\") called\n"
, (void *)res, (void *)context, sres_record_type(type, b), domain
)) : (void)0);

if (res == NULL((void*)0) || domain == NULL((void*)0))
  return su_seterrno(EFAULT14), (void *)NULL((void*)0);

dlen = strlen(domain);
if (dlen > SRES_MAXDNAME(SRES_MAXDNAME) ||
    (dlen == SRES_MAXDNAME(SRES_MAXDNAME) && domain[dlen - 1] != '.')) {
  su_seterrno(ENAMETOOLONG36);
  return NULL((void*)0);
}

sres_resolver_update(res, 0);

if (res->res_n_servers == 0)
  return (void)su_seterrno(ENETDOWN100), (sres_query_t *)NULL((void*)0);

if (domain[dlen - 1] == '.')
  /* Domain ends with dot - do not search */
  dots = res->res_config->c_opt.ndots;
else if (sres_has_search_domain(res))
  for (dots = 0, dot = strchr(domain, '.');
dots < res->res_config->c_opt.ndots && dot;
dots++, dot = strchr(dot + 1, '.'))
    ;
else
  dots = 0;

query = sres_query_alloc(res, callback, context, type, domain);

if (query) {
  /* Create sub-query for each search domain */
  if (dots < res->res_config->c_opt.ndots) {
    sres_query_t *sub;
    int i, subs;
    size_t len;
    char const *const *domains = res->res_config->c_search;
    char search[SRES_MAXDNAME(SRES_MAXDNAME) + 1];

    assert(dlen < SRES_MAXDNAME)((void) sizeof ((dlen < (SRES_MAXDNAME)) ? 1 : 0), __extension__
 ({ if (dlen < (SRES_MAXDNAME)) ; else __assert_fail ("dlen < SRES_MAXDNAME"
, "sres.c", 1074, __extension__ __PRETTY_FUNCTION__); }));

    memcpy(search, domain, dlen);
    search[dlen++] = '.';
    search[dlen] = '\0';

    for (i = 0, subs = 0; i <= SRES_MAX_SEARCH(SRES_MAX_SEARCH); i++) {
if (domains[i]) {
 len = strlen(domains[i]);

 if (dlen + len + 1 > SRES_MAXDNAME(SRES_MAXDNAME))
   continue;

 memcpy(search + dlen, domains[i], len);
 search[dlen + len] = '.';
 search[dlen + len + 1] = '\0';
 sub = sres_query_alloc(res, sres_answer_subquery, (void *)query,
		 type, search);

 if (sub == NULL((void*)0)) {
 }
 else if (sres_send_dns_query(res, sub) == 0) {
   query->q_subqueries[i] = sub;
 }
 else {
   sres_free_query(res, sub), sub = NULL((void*)0);
 }
 subs += sub != NULL((void*)0);
}
    }

    query->q_n_subs = subs;
  }

  if (sres_send_dns_query(res, query) != 0) {
    if (!query->q_n_subs)
sres_free_query(res, query), query = NULL((void*)0);
    else
query->q_id = 0;
  }
}

return query;
1117}

1119/** Make a reverse DNS query.
*
* Send a query to DNS server with specified @a type and domain name formed
* from the socket address @a addr. The sres resolver takes care of
* retransmitting the query if a root object is associate with the resolver or
* if sres_resolver_timer() is called in regular intervals. It generates an
* error record with nonzero status if no response is received.
*
* @param res pointer to resolver
* @param callback function called when query is answered or times out
* @param context pointer given as an extra argument to @a callback function
* @param type record type to query (or sres_qtype_any for any record)
* @param addr socket address structure
*
* The @a type should be #sres_type_ptr. The @a addr should contain either
* IPv4 (AF_INET) or IPv6 (AF_INET6) address.
*
* If the #SRES_OPTIONS environment variable, #RES_OPTIONS environment
* variable, or an "options" entry in resolv.conf file contains an option
* "ip6-dotint", the IPv6 addresses are resolved using suffix ".ip6.int"
* instead of the standard ".ip6.arpa" suffix.
*
* @ERRORS
* @ERROR EAFNOSUPPORT address family specified in @a addr is not supported
* @ERROR ENETDOWN no DNS servers configured
* @ERROR EFAULT @a res or @a addr point outside the address space
* @ERROR ENOMEM memory exhausted
*
* @sa sres_query(), sres_blocking_query_sockaddr(),
* sres_cached_answers_sockaddr()
*
*/
1151sres_query_t *
1152sres_query_sockaddr(sres_resolver_t *res,
    sres_answer_f *callback,
    sres_context_t *context,
    uint16_t type,
    struct sockaddr const *addr)
1157{
char name[80];

if (!res || !addr)
  return su_seterrno(EFAULT14), (void *)NULL((void*)0);

if (!sres_sockaddr2string(res, name, sizeof(name), addr))
  return NULL((void*)0);

return sres_query(res, callback, context, type, name);
1167}


1170/** Make a DNS query.
*
* @deprecated Use sres_query() instead.
*/
1174sres_query_t *
1175sres_query_make(sres_resolver_t *res,
sres_answer_f *callback,
sres_context_t *context,
int dummy,
uint16_t type,
char const *domain)
1181{
return sres_query(res, callback, context, type, domain);
1183}

1185/** Make a reverse DNS query.
*
* @deprecated Use sres_query_sockaddr() instead.
*/
1189sres_query_t *
1190sres_query_make_sockaddr(sres_resolver_t *res,
	 sres_answer_f *callback,
	 sres_context_t *context,
	 int dummy,
	 uint16_t type,
	 struct sockaddr const *addr)
1196{
char name[80];

if (!res || !addr)
  return su_seterrno(EFAULT14), (void *)NULL((void*)0);

if (!sres_sockaddr2string(res, name, sizeof(name), addr))
  return NULL((void*)0);

return sres_query_make(res, callback, context, dummy, type, name);
1206}


1209/** Bind a query with another callback and context pointer.
*
* @param query pointer to a query object to bind
* @param callback pointer to new callback function (may be NULL)
* @param context pointer to callback context (may be NULL)
1214*/
1215void sres_query_bind(sres_query_t *query,
                   sres_answer_f *callback,
                   sres_context_t *context)
1218{
if (query) {
  query->q_callback = callback;
  query->q_context = context;
}
1223}

1225/**Get a list of matching (type/domain) records from cache.
*
* @return
* pointer to an array of pointers to cached records, or
* NULL if no entry was found.
*
* @ERRORS
* @ERROR ENAMETOOLONG @a domain is longer than SRES_MAXDNAME
* @ERROR ENOENT no cached records were found
* @ERROR EFAULT @a res or @a domain point outside the address space
* @ERROR ENOMEM memory exhausted
*/
1237sres_record_t **
1238sres_cached_answers(sres_resolver_t *res,
    uint16_t type,
    char const *domain)
1241{
sres_record_t **result;
char rooted_domain[SRES_MAXDNAME(SRES_MAXDNAME)];

if (!res)
  return su_seterrno(EFAULT14), (void *)NULL((void*)0);

domain = sres_toplevel(rooted_domain, sizeof rooted_domain, domain);

if (!domain)
  return NULL((void*)0);

if (!sres_cache_get(res->res_cache, type, domain, &result))
  return su_seterrno(ENOENT2), (void *)NULL((void*)0);

return result;
1257}

1259/**Search for a list of matching (type/name) records from cache.
*
* @return
* pointer to an array of pointers to cached records, or
* NULL if no entry was found.
*
* @ERRORS
* @ERROR ENAMETOOLONG @a name or resulting domain is longer than SRES_MAXDNAME
* @ERROR ENOENT no cached records were found
* @ERROR EFAULT @a res or @a domain point outside the address space
* @ERROR ENOMEM memory exhausted
*
* @sa sres_search(), sres_cached_answers()
*/
1273sres_record_t **
1274sres_search_cached_answers(sres_resolver_t *res,
	   uint16_t type,
	   char const *name)
1277{
char const *domain = name;
sres_record_t **search_results[SRES_MAX_SEARCH(SRES_MAX_SEARCH) + 1] = { NULL((void*)0) };
char rooted_domain[SRES_MAXDNAME(SRES_MAXDNAME)];
unsigned dots; char const *dot;
size_t found = 0;
int i;

SU_DEBUG_9(("sres_search_cached_answers(%p, %s, \"%s\") called\n",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 1286, "sres_search_cached_answers(%p, %s, \"%s\") called\n"
, (void *)res, sres_record_type(type, rooted_domain), domain)
) : (void)0)
     (void *)res, sres_record_type(type, rooted_domain), domain))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 1286, "sres_search_cached_answers(%p, %s, \"%s\") called\n"
, (void *)res, sres_record_type(type, rooted_domain), domain)
) : (void)0);

if (!res || !name)
  return su_seterrno(EFAULT14), (void *)NULL((void*)0);

if (sres_has_search_domain(res))
  for (dots = 0, dot = strchr(domain, '.');
dots < res->res_config->c_opt.ndots && dot;
dots++, dot = strchr(dot + 1, '.'))
    ;
else
  dots = 0;

domain = sres_toplevel(rooted_domain, sizeof rooted_domain, domain);

if (!domain)
  return NULL((void*)0);

if (sres_cache_get(res->res_cache, type, domain, &search_results[0]))
  found = 1;

if (dots < res->res_config->c_opt.ndots) {
  char const *const *domains = res->res_config->c_search;
  size_t dlen = strlen(domain);

  for (i = 0; domains[i] && i < SRES_MAX_SEARCH(SRES_MAX_SEARCH); i++) {
    size_t len = strlen(domains[i]);
    if (dlen + len + 1 >= SRES_MAXDNAME(SRES_MAXDNAME))
continue;
    if (domain != rooted_domain)
domain = memcpy(rooted_domain, domain, dlen);
    memcpy(rooted_domain + dlen, domains[i], len);
    strcpy(rooted_domain + dlen + len, ".");
    if (sres_cache_get(res->res_cache, type, domain, search_results + i + 1))
found++;
  }
}

if (found == 0)
  return su_seterrno(ENOENT2), (void *)NULL((void*)0);

if (found == 1) {
  for (i = 0; i <= SRES_MAX_SEARCH(SRES_MAX_SEARCH); i++)
    if (search_results[i])
return search_results[i];
}

return sres_combine_results(res, search_results);
1334}

1336/**Get a list of matching (type/domain) reverse records from cache.
*
* @param res pointer to resolver
* @param type record type to query (or sres_qtype_any for any record)
* @param addr socket address structure
*
* The @a type should be #sres_type_ptr. The @a addr should contain either
* IPv4 (AF_INET) or IPv6 (AF_INET6) address.
*
* If the #SRES_OPTIONS environment variable, #RES_OPTIONS environment
* variable or an "options" entry in resolv.conf file contains an option
* "ip6-dotint", the IPv6 addresses are resolved using suffix ".ip6.int"
* instead of default ".ip6.arpa".
*
* @retval
* pointer to an array of pointers to cached records, or
* NULL if no entry was found.
*
* @ERRORS
* @ERROR EAFNOSUPPORT address family specified in @a addr is not supported
* @ERROR ENOENT no cached records were found
* @ERROR EFAULT @a res or @a addr point outside the address space
* @ERROR ENOMEM memory exhausted
*/
1360sres_record_t **
1361sres_cached_answers_sockaddr(sres_resolver_t *res,
	     uint16_t type,
	     struct sockaddr const *addr)
1364{
sres_record_t **result;
char name[80];

if (!res || !addr)
  return su_seterrno(EFAULT14), (void *)NULL((void*)0);

if (!sres_sockaddr2string(res, name, sizeof name, addr))
  return NULL((void*)0);

if (!sres_cache_get(res->res_cache, type, name, &result))
  return su_seterrno(ENOENT2), (void *)NULL((void*)0);

return result;
1378}

1380/** Set the priority of the matching cached SRV record.
*
* The SRV records with the domain name, target and port are matched and
* their priority value is adjusted. This function is used to implement
* greylisting of SIP servers.
*
* @param res      pointer to resolver
* @param domain   domain name of the SRV record(s) to modify
* @param target   SRV target of the SRV record(s) to modify
* @param port     port number of SRV record(s) to modify
*                 (in host byte order)
* @param ttl      new ttl for SRV records of the domain
* @param priority new priority value (0=highest, 65535=lowest)
*
* @sa sres_cache_set_srv_priority()
*
* @NEW_1_12_8
*/
1398int sres_set_cached_srv_priority(sres_resolver_t *res,
		 char const *domain,
		 char const *target,
		 uint16_t port,
		 uint32_t ttl,
		 uint16_t priority)
1404{
char rooted_domain[SRES_MAXDNAME(SRES_MAXDNAME)];

if (res == NULL((void*)0) || res->res_cache == NULL((void*)0))
  return su_seterrno(EFAULT14);

domain = sres_toplevel(rooted_domain, sizeof rooted_domain, domain);

if (!domain)
  return -1;

return sres_cache_set_srv_priority(res->res_cache,
		     domain, target, port,
		     ttl, priority);
1418}


1421/** Sort answers. */
1422int
1423sres_sort_answers(sres_resolver_t *res, sres_record_t **answers)
1424{
int i, j;

if (res == NULL((void*)0) || answers == NULL((void*)0))
  return su_seterrno(EFAULT14);

if (answers[0] == NULL((void*)0) || answers[1] == NULL((void*)0))
  return 0;

/* Simple insertion sorting */
/*
 * We do not use qsort because we want later extend this to sort
 * local A records first etc.
 */
for (i = 1; answers[i]; i++) {
  for (j = 0; j < i; j++) {
    if (sres_record_compare(answers[i], answers[j]) < 0)
break;
  }
  if (j < i) {
    sres_record_t *r = answers[i];
    for (; j < i; i--) {
answers[i] = answers[i - 1];
    }
    answers[j] = r;
  }
}

return 0;
1453}

1455/** Sort and filter query results */
1456int
1457sres_filter_answers(sres_resolver_t *res,
    sres_record_t **answers,
    uint16_t type)
1460{
int i, n;

if (res == NULL((void*)0) || answers == NULL((void*)0))
  return su_seterrno(EFAULT14);

for (n = 0, i = 0; answers[i]; i++) {
  if (answers[i]->sr_record->r_status ||
answers[i]->sr_record->r_class != sres_class_in ||
(type != 0 && answers[i]->sr_record->r_type != type)) {
    sres_free_answer(res, answers[i]);
    continue;
  }
  answers[n++] = answers[i];
}
answers[n] = NULL((void*)0);

sres_sort_answers(res, answers);

return n;
1480}


1483/** Free and zero one record. */
1484void sres_free_answer(sres_resolver_t *res, sres_record_t *answer)
1485{
if (res && answer)
  sres_cache_free_one(res->res_cache, answer);
1488}

1490/** Free and zero an array of records.
*
* The array of records can be returned by sres_cached_answers() or
* given by callback function.
*/
1495void
1496sres_free_answers(sres_resolver_t *res,
  sres_record_t **answers)
1498{
if (res && answers)
  sres_cache_free_answers(res->res_cache, answers);
1501}

1503/** Convert type to its name. */
1504char const *sres_record_type(int type, char buffer[8])
1505{
switch (type) {
case sres_type_a: return "A";
case sres_type_ns: return "NS";
case sres_type_mf: return "MF";
case sres_type_cname: return "CNAME";
case sres_type_soa: return "SOA";
case sres_type_mb: return "MB";
case sres_type_mg: return "MG";
case sres_type_mr: return "MR";
case sres_type_null: return "NULL";
case sres_type_wks: return "WKS";
case sres_type_ptr: return "PTR";
case sres_type_hinfo: return "HINFO";
case sres_type_minfo: return "MINFO";
case sres_type_mx: return "MX";
case sres_type_txt: return "TXT";
case sres_type_rp: return "RP";
case sres_type_afsdb: return "AFSDB";
case sres_type_x25: return "X25";
case sres_type_isdn: return "ISDN";
case sres_type_rt: return "RT";
case sres_type_nsap: return "NSAP";
case sres_type_nsap_ptr: return "NSAP_PTR";
case sres_type_sig: return "SIG";
case sres_type_key: return "KEY";
case sres_type_px: return "PX";
case sres_type_gpos: return "GPOS";
case sres_type_aaaa: return "AAAA";
case sres_type_loc: return "LOC";
case sres_type_nxt: return "NXT";
case sres_type_eid: return "EID";
case sres_type_nimloc: return "NIMLOC";
case sres_type_srv: return "SRV";
case sres_type_atma: return "ATMA";
case sres_type_naptr: return "NAPTR";
case sres_type_kx: return "KX";
case sres_type_cert: return "CERT";
case sres_type_a6: return "A6";
case sres_type_dname: return "DNAME";
case sres_type_sink: return "SINK";
case sres_type_opt: return "OPT";

case sres_qtype_tsig: return "TSIG";
case sres_qtype_ixfr: return "IXFR";
case sres_qtype_axfr: return "AXFR";
case sres_qtype_mailb: return "MAILB";
case sres_qtype_maila: return "MAILA";
case sres_qtype_any: return "ANY";

default:
  if (buffer)
    sprintf(buffer, "%u?", type & 65535);
  return buffer;
}
1560}

1562/** Convert record status to its name */
1563char const *sres_record_status(int status, char buffer[8])
1564{
switch (status) {
case SRES_OK: return "OK";
case SRES_FORMAT_ERR: return "FORMAT_ERR";
case SRES_SERVER_ERR: return "SERVER_ERR";
case SRES_NAME_ERR: return "NAME_ERR";
case SRES_UNIMPL_ERR: return "UNIMPL_ERR";
case SRES_AUTH_ERR: return "AUTH_ERR";

/* Errors generated by sresolv */
case SRES_TIMEOUT_ERR: return "TIMEOUT_ERR";
case SRES_RECORD_ERR: return "RECORD_ERR";
case SRES_INTERNAL_ERR: return "INTERNAL_ERR";
case SRES_NETWORK_ERR: return "NETWORK_ERR";

default:
  if (buffer)
    sprintf(buffer, "%u?", status & 255);
  return buffer;
}
1584}


1587/** Convert class to its name. */
1588static char const *
1589sres_record_class(int rclass, char buffer[8])
1590{
switch (rclass) {
case 1: return "IN";
case 2: return "2?";
case 3: return "CHAOS";
case 4: return "HS";
case 254: return "NONE";
case 255: return "ANY";

default:
  sprintf(buffer, "%u?", rclass & 65535);
  return buffer;
}
1603}

1605/** Compare two records. */
1606int
1607sres_record_compare(sres_record_t const *aa, sres_record_t const *bb)
1608{
int D;
sres_common_t const *a = aa->sr_record, *b = bb->sr_record;

D = a->r_status - b->r_status; if (D) return D;
D = a->r_class - b->r_class; if (D) return D;
D = a->r_type - b->r_type; if (D) return D;

if (a->r_status)
  return 0;

switch (a->r_type) {
case sres_type_soa:
  {
    sres_soa_record_t const *A = aa->sr_soa, *B = bb->sr_soa;
    D = A->soa_serial - B->soa_serial; if (D) return D;
    D = su_strcasecmp(A->soa_mname, B->soa_mname); if (D) return D;
    D = su_strcasecmp(A->soa_rname, B->soa_rname); if (D) return D;
    D = A->soa_refresh - B->soa_refresh; if (D) return D;
    D = A->soa_retry - B->soa_retry; if (D) return D;
    D = A->soa_expire - B->soa_expire; if (D) return D;
    D = A->soa_minimum - B->soa_minimum; if (D) return D;
    return 0;
  }
case sres_type_a:
  {
    sres_a_record_t const *A = aa->sr_a, *B = bb->sr_a;
    return memcmp(&A->a_addr, &B->a_addr, sizeof A->a_addr);
  }
case sres_type_a6:
  {
    sres_a6_record_t const *A = aa->sr_a6, *B = bb->sr_a6;
    D = A->a6_prelen - B->a6_prelen; if (D) return D;
    D = !A->a6_prename - !B->a6_prename;
    if (D == 0 && A->a6_prename && B->a6_prename)
      D = su_strcasecmp(A->a6_prename, B->a6_prename);
    if (D) return D;
    return memcmp(&A->a6_suffix, &B->a6_suffix, sizeof A->a6_suffix);
  }
case sres_type_aaaa:
  {
    sres_aaaa_record_t const *A = aa->sr_aaaa, *B = bb->sr_aaaa;
    return memcmp(&A->aaaa_addr, &B->aaaa_addr, sizeof A->aaaa_addr);
  }
case sres_type_cname:
  {
    sres_cname_record_t const *A = aa->sr_cname, *B = bb->sr_cname;
    return strcmp(A->cn_cname, B->cn_cname);
  }
case sres_type_ptr:
  {
    sres_ptr_record_t const *A = aa->sr_ptr, *B = bb->sr_ptr;
    return strcmp(A->ptr_domain, B->ptr_domain);
  }
case sres_type_srv:
  {
    sres_srv_record_t const *A = aa->sr_srv, *B = bb->sr_srv;
    D = A->srv_priority - B->srv_priority; if (D) return D;
    /* Record with larger weight first */
    D = B->srv_weight - A->srv_weight; if (D) return D;
    D = strcmp(A->srv_target, B->srv_target); if (D) return D;
    return A->srv_port - B->srv_port;
  }
case sres_type_naptr:
  {
    sres_naptr_record_t const *A = aa->sr_naptr, *B = bb->sr_naptr;
    D = A->na_order - B->na_order; if (D) return D;
    D = A->na_prefer - B->na_prefer; if (D) return D;
    D = strcmp(A->na_flags, B->na_flags); if (D) return D;
    D = strcmp(A->na_services, B->na_services); if (D) return D;
    D = strcmp(A->na_regexp, B->na_regexp); if (D) return D;
    return strcmp(A->na_replace, B->na_replace);
  }
default:
  return 0;
}
1684}

1686/* ---------------------------------------------------------------------- */
1687/* Private functions */

1689/** Destruct */
1690static
1691void
1692sres_resolver_destructor(void *arg)
1693{
sres_resolver_t *res = arg;

assert(res)((void) sizeof ((res) ? 1 : 0), __extension__ ({ if (res) ; else
 __assert_fail ("res", "sres.c", 1696, __extension__ __PRETTY_FUNCTION__
); }));
sres_cache_unref(res->res_cache);
res->res_cache = NULL((void*)0);

sres_servers_close(res, res->res_servers);

if (res->res_config)
  su_home_unref((su_home_t *)res->res_config->c_home);

if (res->res_updcb)
  res->res_updcb(res->res_async, INVALID_SOCKET((sres_socket_t)-1), INVALID_SOCKET((sres_socket_t)-1));
1707}

1709#ifdef __clang__1
1710#pragma clang diagnostic push
1711#pragma clang diagnostic ignored "-Wunused-function"
1712#endif

1714HTABLE_BODIES_WITH(sres_qtable, qt, sres_query_t, SRES_QUERY_HASH,static inline int sres_qtable_resize(su_home_t *home, sres_qtable_t
 qt[], unsigned new_size) { sres_query_t **new_hash; sres_query_t
 **old_hash = qt->qt_table; unsigned old_size; unsigned i,
 j, i0; unsigned again = 0; unsigned used = 0, collisions = 0
; if (new_size == 0) new_size = 2 * qt->qt_size + 1; if (new_size
 < 31) new_size = 31; if (new_size < 5 * qt->qt_used
 / 4) new_size = 5 * qt->qt_used / 4; if (!(new_hash = su_zalloc
(home, sizeof(*new_hash) * new_size))) return -1; old_size = qt
->qt_size; do for (j = 0; j < old_size; j++) { if (!old_hash
[j]) continue; if (again < 2 && ((old_hash[j])->
q_hash) % old_size > j) { again = 1; continue; } i0 = ((old_hash
[j])->q_hash) % new_size; for (i = i0; new_hash[i]; i = (i
 + 1) % new_size, ((void) sizeof ((i != i0) ? 1 : 0), __extension__
 ({ if (i != i0) ; else __assert_fail ("i != i0", "sres.c", 1715
, __extension__ __PRETTY_FUNCTION__); }))) collisions++; new_hash
[i] = old_hash[j], old_hash[j] = ((void*)0); used++; } while (
again++ == 1); qt->qt_table = new_hash, qt->qt_size = new_size
; ((void) sizeof ((qt->qt_used == used) ? 1 : 0), __extension__
 ({ if (qt->qt_used == used) ; else __assert_fail ("qt->qt_used == used"
, "sres.c", 1715, __extension__ __PRETTY_FUNCTION__); })); su_free
(home, old_hash); return 0; } static inline int sres_qtable_is_full
(sres_qtable_t const *qt) { return qt->qt_table == ((void*
)0) || 3 * qt->qt_used > 2 * qt->qt_size; } static inline
 sres_query_t **sres_qtable_hash(sres_qtable_t const *qt, size_t
 hv) { return qt->qt_table + hv % qt->qt_size; } static
 inline sres_query_t **sres_qtable_next(sres_qtable_t const *
qt, sres_query_t * const *ee) { if (++ee < qt->qt_table
 + qt->qt_size && ee >= qt->qt_table) return
 (sres_query_t **)ee; else return qt->qt_table; } static inline
 void sres_qtable_append(sres_qtable_t *qt, sres_query_t const
 *e) { sres_query_t **ee; qt->qt_used++; for (ee = sres_qtable_hash
(qt, ((e)->q_hash)); *ee; ee = sres_qtable_next(qt, ee)) ;
 *ee = (sres_query_t *)e; } static inline void sres_qtable_insert
(sres_qtable_t *qt, sres_query_t const *e) { sres_query_t *e0
, **ee; qt->qt_used++; for (ee = sres_qtable_hash(qt, ((e)
->q_hash)); (e0 = *ee); ee = sres_qtable_next(qt, ee)) *ee
 = (sres_query_t *)e, e = e0; *ee = (sres_query_t *)e; } static
 inline int sres_qtable_remove(sres_qtable_t *qt, sres_query_t
 const *e) { unsigned i, j, k; unsigned size = qt->qt_size
; sres_query_t **htable = qt->qt_table; if (!e) return -1;
 for (i = ((e)->q_hash) % size; htable[i]; i = (i + 1) % size
) if (e == htable[i]) break; if (!htable[i]) return -1; for (
j = (i + 1) % size; htable[j]; j = (j + 1) % size) { k = ((htable
[j])->q_hash) % size; if (k == j) continue; if (j > i ?
 (i < k && k < j) : (i < k || k < j)) continue
; htable[i] = htable[j], i = j; } qt->qt_used--; htable[i]
 = ((void*)0); return 0; } extern int sres_qtable_dummy
   unsigned, size_t)static inline int sres_qtable_resize(su_home_t *home, sres_qtable_t
 qt[], unsigned new_size) { sres_query_t **new_hash; sres_query_t
 **old_hash = qt->qt_table; unsigned old_size; unsigned i,
 j, i0; unsigned again = 0; unsigned used = 0, collisions = 0
; if (new_size == 0) new_size = 2 * qt->qt_size + 1; if (new_size
 < 31) new_size = 31; if (new_size < 5 * qt->qt_used
 / 4) new_size = 5 * qt->qt_used / 4; if (!(new_hash = su_zalloc
(home, sizeof(*new_hash) * new_size))) return -1; old_size = qt
->qt_size; do for (j = 0; j < old_size; j++) { if (!old_hash
[j]) continue; if (again < 2 && ((old_hash[j])->
q_hash) % old_size > j) { again = 1; continue; } i0 = ((old_hash
[j])->q_hash) % new_size; for (i = i0; new_hash[i]; i = (i
 + 1) % new_size, ((void) sizeof ((i != i0) ? 1 : 0), __extension__
 ({ if (i != i0) ; else __assert_fail ("i != i0", "sres.c", 1715
, __extension__ __PRETTY_FUNCTION__); }))) collisions++; new_hash
[i] = old_hash[j], old_hash[j] = ((void*)0); used++; } while (
again++ == 1); qt->qt_table = new_hash, qt->qt_size = new_size
; ((void) sizeof ((qt->qt_used == used) ? 1 : 0), __extension__
 ({ if (qt->qt_used == used) ; else __assert_fail ("qt->qt_used == used"
, "sres.c", 1715, __extension__ __PRETTY_FUNCTION__); })); su_free
(home, old_hash); return 0; } static inline int sres_qtable_is_full
(sres_qtable_t const *qt) { return qt->qt_table == ((void*
)0) || 3 * qt->qt_used > 2 * qt->qt_size; } static inline
 sres_query_t **sres_qtable_hash(sres_qtable_t const *qt, size_t
 hv) { return qt->qt_table + hv % qt->qt_size; } static
 inline sres_query_t **sres_qtable_next(sres_qtable_t const *
qt, sres_query_t * const *ee) { if (++ee < qt->qt_table
 + qt->qt_size && ee >= qt->qt_table) return
 (sres_query_t **)ee; else return qt->qt_table; } static inline
 void sres_qtable_append(sres_qtable_t *qt, sres_query_t const
 *e) { sres_query_t **ee; qt->qt_used++; for (ee = sres_qtable_hash
(qt, ((e)->q_hash)); *ee; ee = sres_qtable_next(qt, ee)) ;
 *ee = (sres_query_t *)e; } static inline void sres_qtable_insert
(sres_qtable_t *qt, sres_query_t const *e) { sres_query_t *e0
, **ee; qt->qt_used++; for (ee = sres_qtable_hash(qt, ((e)
->q_hash)); (e0 = *ee); ee = sres_qtable_next(qt, ee)) *ee
 = (sres_query_t *)e, e = e0; *ee = (sres_query_t *)e; } static
 inline int sres_qtable_remove(sres_qtable_t *qt, sres_query_t
 const *e) { unsigned i, j, k; unsigned size = qt->qt_size
; sres_query_t **htable = qt->qt_table; if (!e) return -1;
 for (i = ((e)->q_hash) % size; htable[i]; i = (i + 1) % size
) if (e == htable[i]) break; if (!htable[i]) return -1; for (
j = (i + 1) % size; htable[j]; j = (j + 1) % size) { k = ((htable
[j])->q_hash) % size; if (k == j) continue; if (j > i ?
 (i < k && k < j) : (i < k || k < j)) continue
; htable[i] = htable[j], i = j; } qt->qt_used--; htable[i]
 = ((void*)0); return 0; } extern int sres_qtable_dummy;

1717#ifdef __clang__1
1718#pragma clang diagnostic pop
1719#endif

1721/** Allocate a query structure */
1722static
1723sres_query_t *
1724sres_query_alloc(sres_resolver_t *res,
 sres_answer_f *callback,
 sres_context_t *context,
 uint16_t type,
 char const *domain)
1729{
sres_query_t *query;
size_t dlen = strlen(domain);

if (sres_qtable_is_full(res->res_queries))
  if (sres_qtable_resize(res->res_home, res->res_queries, 0) < 0)
    return NULL((void*)0);

query = su_alloc(res->res_home, sizeof(*query) + dlen + 1);

if (query) {
  memset(query, 0, sizeof *query);
  query->q_res = res;
  query->q_callback = callback;
  query->q_context = context;
  query->q_type = type;
  query->q_class = sres_class_in;
  query->q_timestamp = res->res_now;
  query->q_name = strcpy((char *)(query + 1), domain);

  sres_gen_id(res, query);
  assert(query->q_id)((void) sizeof ((query->q_id) ? 1 : 0), __extension__ ({ if
 (query->q_id) ; else __assert_fail ("query->q_id", "sres.c"
, 1750, __extension__ __PRETTY_FUNCTION__); }));

  query->q_i_server = res->res_i_server;
  query->q_n_servers = res->res_n_servers;

  sres_qtable_append(res->res_queries, query);

  if (res->res_schedulecb && res->res_queries->qt_used == 1)
    res->res_schedulecb(res->res_async, 2 * SRES_RETRANSMIT_INTERVAL(SRES_RETRANSMIT_INTERVAL));
}

return query;
1762}

1764su_inlinestatic inline
1765void
1766sres_remove_query(sres_resolver_t *res, sres_query_t *q, int all)
1767{
int i;

if (q->q_hash) {
  sres_qtable_remove(res->res_queries, q), q->q_hash = 0;

  if (all)
    for (i = 0; i <= SRES_MAX_SEARCH(SRES_MAX_SEARCH); i++) {
if (q->q_subqueries[i] && q->q_subqueries[i]->q_hash) {
 sres_qtable_remove(res->res_queries, q->q_subqueries[i]);
 q->q_subqueries[i]->q_hash = 0;
}
    }
}
1781}

1783/** Remove a query from hash table and free it. */
1784static
1785void sres_free_query(sres_resolver_t *res, sres_query_t *q)
1786{
int i;

if (q == NULL((void*)0))
  return;

if (q->q_hash)
  sres_qtable_remove(res->res_queries, q), q->q_hash = 0;

for (i = 0; i <= SRES_MAX_SEARCH(SRES_MAX_SEARCH); i++) {
  sres_query_t *sq;

  sq = q->q_subqueries[i];
  q->q_subqueries[i] = NULL((void*)0);
  if (sq)
    sres_free_query(res, sq);
  if (q->q_subanswers[i])
    sres_cache_free_answers(res->res_cache, q->q_subanswers[i]);
  q->q_subanswers[i] = NULL((void*)0);
}

su_free(res->res_home, q);
1808}

1810static
1811sres_record_t **
1812sres_combine_results(sres_resolver_t *res,
     sres_record_t **search_results[SRES_MAX_SEARCH(SRES_MAX_SEARCH) + 1])
1814{
sres_record_t **combined_result;
int i, j, found;

/* Combine the results into a single list. */
for (i = 0, found = 0; i <= SRES_MAX_SEARCH(SRES_MAX_SEARCH); i++)
  if (search_results[i])
    for (j = 0; search_results[i][j]; j++)
found++;

combined_result = su_alloc((su_home_t *)res->res_cache,
	     (found + 1) * (sizeof combined_result[0]));
if (combined_result) {
  for (i = 0, found = 0; i <= SRES_MAX_SEARCH(SRES_MAX_SEARCH); i++)
    if (search_results[i])
for (j = 0; search_results[i][j]; j++) {
 combined_result[found++] = search_results[i][j];
 search_results[i][j] = NULL((void*)0);
}

  combined_result[found] = NULL((void*)0);
  sres_sort_answers(res, combined_result);
}

for (i = 0; i <= SRES_MAX_SEARCH(SRES_MAX_SEARCH); i++)
  if (search_results[i])
    sres_free_answers(res, search_results[i]), search_results[i] = NULL((void*)0);

return combined_result;
1843}

1845static
1846int
1847sres_sockaddr2string(sres_resolver_t *res,
     char name[],
     size_t namelen,
     struct sockaddr const *addr)
1851{
name[0] = '\0';

if (addr->sa_family == AF_INET2) {
  struct sockaddr_in const *sin = (struct sockaddr_in *)addr;
  uint8_t const *in_addr = (uint8_t*)&sin->sin_addr;
  return snprintf(name, namelen, "%u.%u.%u.%u.in-addr.arpa.",
    in_addr[3], in_addr[2], in_addr[1], in_addr[0]);
}
1860#if HAVE_SIN61
else if (addr->sa_family == AF_INET610) {
  struct sockaddr_in6 const *sin6 = (struct sockaddr_in6 *)addr;
  size_t addrsize = sizeof(sin6->sin6_addr.s6_addr__in6_u.__u6_addr8);
  char *postfix;
  size_t required;
  size_t i;

  if (res->res_config->c_opt.ip6int)
    postfix = "ip6.int.";
  else
    postfix = "ip6.arpa.";

  required = addrsize * 4 + strlen(postfix);

  if (namelen <= required)
    return (int)required;

  for (i = 0; i < addrsize; i++) {
    uint8_t byte = sin6->sin6_addr.s6_addr__in6_u.__u6_addr8[addrsize - i - 1];
    uint8_t hex;

    hex = byte & 0xf;
    name[4 * i] = hex > 9 ? hex + 'a' - 10 : hex + '0';
    name[4 * i + 1] = '.';
    hex = (byte >> 4) & 0xf;
    name[4 * i + 2] = hex > 9 ? hex + 'a' - 10 : hex + '0';
    name[4 * i + 3] = '.';
  }

  strcpy(name + 4 * i, postfix);

  return (int)required;
}
1894#endif /* HAVE_SIN6 */
else {
  su_seterrno(EAFNOSUPPORT97);
  SU_DEBUG_3(("%s: %s\n", "sres_sockaddr2string",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 3 ? (_su_llog(sresolv_log, 3, "sres.c"
, (const char *)__func__, 1898, "%s: %s\n", "sres_sockaddr2string"
, su_strerror(97))) : (void)0)
              su_strerror(EAFNOSUPPORT)))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 3 ? (_su_llog(sresolv_log, 3, "sres.c"
, (const char *)__func__, 1898, "%s: %s\n", "sres_sockaddr2string"
, su_strerror(97))) : (void)0);
  return 0;
}
1901}

1903/** Make a domain name a top level domain name.
*
* The function sres_toplevel() returns a copies string @a domain and
* terminates it with a dot if it is not already terminated.
*/
1908static
1909char const *
1910sres_toplevel(char buf[], size_t blen, char const *domain)
1911{
size_t len;
int already;

if (!domain)
  return su_seterrno(EFAULT14), (void *)NULL((void*)0);

len = strlen(domain);

if (len >= blen)
  return su_seterrno(ENAMETOOLONG36), (void *)NULL((void*)0);

already = len > 0 && domain[len - 1] == '.';

if (already)
  return domain;

if (len + 1 >= blen)
  return su_seterrno(ENAMETOOLONG36), (void *)NULL((void*)0);

strcpy(buf, domain);
buf[len] = '.'; buf[len + 1] = '\0';

return buf;
1935}

1937/* ---------------------------------------------------------------------- */

1939static int sres_update_config(sres_resolver_t *res, int always, time_t now);
1940static int sres_parse_config(sres_config_t *, FILE *);
1941static int sres_parse_options(sres_config_t *c, char const *value);
1942static int sres_parse_nameserver(sres_config_t *c, char const *server);
1943static time_t sres_config_timestamp(sres_config_t const *c);

1945/** Update configuration
*
* @retval 0 when successful
* @retval -1 upon an error
*/
1950int sres_resolver_update(sres_resolver_t *res, int always)
1951{
sres_server_t **servers, **old_servers;
int updated;

updated = sres_update_config(res, always, time(&res->res_now));
if (updated < 0)
  return -1;

if (!res->res_servers || always || updated) {
  servers = sres_servers_new(res, res->res_config);
  old_servers = res->res_servers;

  res->res_i_server = 0;
  res->res_n_servers = sres_servers_count(servers);
  res->res_servers = servers;

  sres_servers_close(res, old_servers);
  su_free(res->res_home, old_servers);

  if (!servers)
    return -1;
}

return 0;
1975}

1977/** Update config file.
*
* @retval 1 if DNS server list is different from old one.
* @retval 0 when otherwise successful
* @retval -1 upon an error
*/
1983static
1984int sres_update_config(sres_resolver_t *res, int always, time_t now)
1985{
sres_config_t *c = NULL((void*)0);
sres_config_t const *previous;
int retval;

previous = res->res_config;

if (!always && previous && now < res->res_checked)
  return 0;
/* Try avoid checking for changes too often. */
res->res_checked = now + SRES_UPDATE_INTERVAL_SECS5;

if (!always && previous &&
    sres_config_timestamp(previous) == previous->c_modified)
  return 0;

c = sres_parse_resolv_conf(res, res->res_options);
if (!c)
  return -1;

res->res_config = c;

retval = sres_config_changed_servers(c, previous);

su_home_unref((su_home_t *)previous->c_home);

return retval;
2012}

2014#if HAVE_WIN32

2016/** Number of octets to read from a registry key at a time */
2017#define QUERY_DATALEN         1024
2018#define MAX_DATALEN           65535

2020/**
* Uses IP Helper IP to get DNS servers list.
*/
2023static int sres_parse_win32_ip(sres_config_t *c)
2024{
int ret = -1;

2027#if HAVE_IPHLPAPI_H
DWORD dw;
su_home_t *home = c->c_home;
ULONG size = sizeof(FIXED_INFO);

do {
  FIXED_INFO *info = (FIXED_INFO *)su_alloc(home, size);
  dw = GetNetworkParams(info, &size);
  if (dw == ERROR_SUCCESS) {
    IP_ADDR_STRING* addr = &info->DnsServerList;
    for (; addr; addr = addr->Next) {
     SU_DEBUG_3(("Adding nameserver: %s\n", addr->IpAddress.String))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 3 ? (_su_llog(sresolv_log, 3, "sres.c"
, (const char *)__func__, 2038, "Adding nameserver: %s\n", addr
->IpAddress.String)) : (void)0);
     sres_parse_nameserver(c, addr->IpAddress.String);
    }
    ret = 0;
  }
  su_free(home, info);
} while (dw == ERROR_BUFFER_OVERFLOW);
2045#endif

return ret;
2048}

2050/**
* Parses name servers listed in registry key 'key+lpValueName'. The
* key is expected to contain a whitespace separate list of
* name server IP addresses.
*
* @return number of server addresses added
*/
2057static int sres_parse_win32_reg_parse_dnsserver(sres_config_t *c, HKEY key, LPCTSTR lpValueName)
2058{
su_home_t *home = c->c_home;
su_strlst_t *reg_dns_list;
BYTE *name_servers = su_alloc(home, QUERY_DATALEN);
DWORD name_servers_length = QUERY_DATALEN;
int ret, servers_added = 0;

/* get name servers and ... */
while((ret = RegQueryValueEx(key,
	       lpValueName,
	       NULL((void*)0), NULL((void*)0),
	       name_servers,
	       &name_servers_length)) == ERROR_MORE_DATA) {
  name_servers_length += QUERY_DATALEN;

  /* sanity check, upper limit for memallocs */
  if (name_servers_length > MAX_DATALEN) break;

  name_servers = su_realloc(home, name_servers, name_servers_length);
  if (name_servers == NULL((void*)0)) {
    ret = ERROR_BUFFER_OVERFLOW;
    break;
  }
}

/* if reading the key was succesful, continue */
if (ret == ERROR_SUCCESS) {
  if (name_servers[0]){
    int i;

    /* add to list */
    reg_dns_list = su_strlst_split(home, (char *)name_servers, " ");

    for(i = 0 ; i < su_strlst_len(reg_dns_list); i++) {
const char *item = su_strlst_item(reg_dns_list, i);
SU_DEBUG_3(("Adding nameserver: %s (key=%s)\n", item, (char*)lpValueName))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 3 ? (_su_llog(sresolv_log, 3, "sres.c"
, (const char *)__func__, 2093, "Adding nameserver: %s (key=%s)\n"
, item, (char*)lpValueName)) : (void)0);
sres_parse_nameserver(c, item);
++servers_added;
    }

    su_strlst_destroy(reg_dns_list);

  }
}

su_free(home, name_servers);

return servers_added;
2106}

2108/**
* Discover system nameservers from Windows registry.
*
* Refs:
*  - http://msdn.microsoft.com/library/default.asp?url=/library/en-us/sysinfo/base/regqueryvalueex.asp
*  - http://support.microsoft.com/default.aspx?scid=kb;en-us;120642
*  - http://support.microsoft.com/kb/314053/EN-US/
*  - IP Helper API (possibly better way than current registry-based impl.)
*    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/iphlp/iphlp/ip_helper_start_page.asp
*/
2118static int sres_parse_win32_reg(sres_config_t *c)
2119{
int ret = -1;

2122#define MAX_KEY_LEN           255
2123#define MAX_VALUE_NAME_LEN    16383

su_home_t *home = c->c_home;
HKEY key_handle;
2127#if 0
HKEY interface_key_handle;
FILETIME ftime;
int index, i;
2131#endif
int found = 0;
char *interface_guid = su_alloc(home, MAX_VALUE_NAME_LEN);

2135#if 0
2136#if __MINGW32__
DWORD guid_size = QUERY_DATALEN;
2138#else
int guid_size = MAX_VALUE_NAME_LEN;
2140#endif

/* step: find interface specific nameservers
 * - this is currently disabled 2006/Jun (the current check might insert
 *   multiple unnecessary nameservers to the search list)
 */
/* open the 'Interfaces' registry Key */
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
   "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces",
   0, KEY_READ, &key_handle)) {
  SU_DEBUG_2(("RegOpenKeyEx failed\n"))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 2 ? (_su_llog(sresolv_log, 2, "sres.c"
, (const char *)__func__, 2150, "RegOpenKeyEx failed\n", )) :
 (void)0);
} else {
  index = 0;
  /* for each interface listed ... */
  while (RegEnumKeyEx(key_handle, index,
	interface_guid, &guid_size,
	NULL((void*)0),NULL((void*)0),0,&ftime) == ERROR_SUCCESS){
    if (RegOpenKeyEx(key_handle, interface_guid,
       0, KEY_READ,
       &interface_key_handle) == ERROR_SUCCESS) {

/* note: 'NameServer' is preferred over 'DhcpNameServer' */
found += sres_parse_win32_reg_parse_dnsserver(c, interface_key_handle, "NameServer");
if (found == 0)
 found += sres_parse_win32_reg_parse_dnsserver(c, interface_key_handle, "DhcpNameServer");

RegCloseKey(interface_key_handle);
    } else{
SU_DEBUG_2(("interface RegOpenKeyEx failed\n"))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 2 ? (_su_llog(sresolv_log, 2, "sres.c"
, (const char *)__func__, 2168, "interface RegOpenKeyEx failed\n"
, )) : (void)0);
    }
    index++;
    guid_size = 64;
  }
  RegCloseKey(key_handle);
}
2175#endif /* #if 0: interface-specific nameservers */

/* step: if no interface-specific nameservers are found,
 *       check for system-wide nameservers */
if (found == 0) {
  if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
     "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters",
     0, KEY_READ, &key_handle)) {
    SU_DEBUG_2(("RegOpenKeyEx failed (2)\n"))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 2 ? (_su_llog(sresolv_log, 2, "sres.c"
, (const char *)__func__, 2183, "RegOpenKeyEx failed (2)\n", )
) : (void)0);
  } else {
    found += sres_parse_win32_reg_parse_dnsserver(c, key_handle, "NameServer");
    if (found == 0)
found += sres_parse_win32_reg_parse_dnsserver(c, key_handle, "DhcpNameServer");
    RegCloseKey(key_handle);
  }
}

SU_DEBUG_3(("Total of %d name servers found from win32 registry.\n", found))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 3 ? (_su_llog(sresolv_log, 3, "sres.c"
, (const char *)__func__, 2192, "Total of %d name servers found from win32 registry.\n"
, found)) : (void)0);

/* return success if servers found */
if (found) ret = 0;

su_free(home, interface_guid);

return ret;
2200}

2202#endif /* HAVE_WIN32 */

2204/** Parse /etc/resolv.conf file.
*
* @retval #sres_config_t structure when successful
* @retval NULL upon an error
*
* @todo The resolv.conf directives @b sortlist and most of the options
*       are currently ignored.
*/
2212static
2213sres_config_t *sres_parse_resolv_conf(sres_resolver_t *res,
		      char const **options)
2215{
sres_config_t *c = su_home_new(sizeof *c);

if (c) {
  FILE *f;
  int i;

  f = fopen(c->c_filename = res->res_cnffile, "r");

  sres_parse_config(c, f);

  if (f)
    fclose(f);

2229#if HAVE_WIN32
  /* note: no 127.0.0.1 on win32 systems */
  /* on win32, query the registry for nameservers */
  if (sres_parse_win32_ip(c) == 0 || sres_parse_win32_reg(c) == 0)
    /* success */;
  else
    /* now what? */;
2236#else
  /* Use local nameserver by default */
  if (c->c_nameservers[0] == NULL((void*)0))
    sres_parse_nameserver(c, "127.0.0.1");
2240#endif

  for (i = 0; c->c_nameservers[i] && i < SRES_MAX_NAMESERVERS(SRES_MAX_NAMESERVERS); i++) {
    struct sockaddr_in *sin = (void *)c->c_nameservers[i]->ns_addr;
    sin->sin_port = htons(c->c_port);
  }

  sres_parse_options(c, getenv("RES_OPTIONS"));

  if (options)
    for (i = 0; options[i]; i++)
sres_parse_options(c, options[i]);

  sres_parse_options(c, getenv("SRES_OPTIONS"));

  su_home_threadsafe(c->c_home);
}

return c;
2259}

2261uint16_t _sres_default_port = 53;

2263/** Parse config file.
*
* @return Number of search domains, if successful.
* @retval -1 upon an error (never happens).
*/
2268static
2269int sres_parse_config(sres_config_t *c, FILE *f)
2270{
su_home_t *home = c->c_home;
int line;
char const *localdomain;
char *search = NULL((void*)0), *domain = NULL((void*)0);
char buf[1025];
int i = 0;

localdomain = getenv("LOCALDOMAIN");

/* Default values */
c->c_opt.ndots = 1;
c->c_opt.check_names = 1;
c->c_opt.timeout = SRES_RETRY_INTERVAL(SRES_RETRY_INTERVAL);
c->c_opt.attempts = SRES_MAX_RETRY_COUNT(SRES_MAX_RETRY_COUNT);
c->c_port = _sres_default_port;

if (f != NULL((void*)0)) {
  for (line = 1; fgets(buf, sizeof(buf), f); line++) {
    size_t len;
    char *value, *b;

    /* Skip whitespace at the beginning ...*/
    b = buf + strspn(buf, " \t");

    /* ... and comments + whitespace at the end */
    for (len = strcspn(b, "#;"); len > 0 && strchr(" \t\r\n", b[len - 1]); len--)
;

    if (len == 0) 	/* Empty line or comment */
continue;

    b[len] = '\0';

    len = strcspn(b, " \t");
    value = b + len; value += strspn(value, " \t");

2307#define MATCH(token)(len == strlen(token) && su_casenmatch(token, b, len)
) (len == strlen(token) && su_casenmatch(token, b, len))

    if (MATCH("nameserver")(len == strlen("nameserver") && su_casenmatch("nameserver"
, b, len))) {
if (sres_parse_nameserver(c, value) < 0)
 return -1;
    }
    else if (MATCH("domain")(len == strlen("domain") && su_casenmatch("domain", b
, len))) {
if (localdomain)	/* LOCALDOMAIN overrides */
 continue;
if (search)
 su_free(home, search), search = NULL((void*)0);
if (domain)
 su_free(home, domain), domain = NULL((void*)0);
domain = su_strdup(home, value);
if (!domain)
 return -1;
    }
    else if (MATCH("search")(len == strlen("search") && su_casenmatch("search", b
, len))) {
if (localdomain)	/* LOCALDOMAIN overrides */
 continue;
if (search) su_free(home, search), search = NULL((void*)0);
if (domain) su_free(home, domain), domain = NULL((void*)0);
search = su_strdup(home, value);
if (!search)
 return -1;
    }
    else if (MATCH("port")(len == strlen("port") && su_casenmatch("port", b, len
))) {
unsigned long port = strtoul(value, NULL((void*)0), 10);
if (port < 65536)
 c->c_port = port;
    }
    else if (MATCH("options")(len == strlen("options") && su_casenmatch("options",
 b, len))) {
sres_parse_options(c, value);
    }
  }
}

if (f)
  c->c_modified = sres_config_timestamp(c);

if (localdomain)
  c->c_search[0] = localdomain;
else if (domain)
  c->c_search[0] = domain;
else if (search) {
  for (i = 0; search[0] && i < SRES_MAX_SEARCH(SRES_MAX_SEARCH); i++) {
    c->c_search[i] = search;
    search += strcspn(search, " \t");
    if (*search) {
*search++ = '\0';
search += strspn(search, " \t");
    }
  }
}

return i;
2363}

2365#if DOXYGEN_ONLY
2366/**@ingroup sresolv_env
*
* Environment variable containing options for Sofia resolver. The options
* recognized by Sofia resolver are as follows:
* - @b debug           turn on debugging (no effect)
* - @b ndots:<i>n</i>  when searching, try first to query name as absolute
*                      domain if it contains at least <i>n</i> dots
* - @b timeout:<i>secs</i> timeout in seconds
* - @b attempts:<i>n</i> fail after <i>n</i> retries
* - @b rotate          use round robin selection of nameservers
* - @b no-check-names  do not check names for invalid characters
* - @b inet6           (no effect)
* - @b ip6-dotint      IPv6 addresses are resolved using suffix ".ip6.int"
*                      instead of the standard ".ip6.arpa" suffix
* - @b ip6-bytestring  (no effect)
* The following option is a Sofia-specific extension:
* - @b no-edns0        do not try to use EDNS0 extension (@RFC2671)
*
* The same options can be listed in @b options directive in resolv.conf, or
* in #RES_OPTIONS environment variable. Note that options given in
* #SRES_OPTIONS override those specified in #RES_OPTIONS which in turn
* override options specified in the @b options directive of resolve.conf.
*
* The meaning of an option can be reversed with prefix "no-".
*
* @sa Manual page for resolv.conf, #RES_OPTIONS.
*/
2393extern SRES_OPTIONS;

2395/**@ingroup sresolv_env
*
* Environment variable containing resolver options. This environment
* variable is also used by standard BIND resolver.
*
* @sa Manual page for resolv.conf, #SRES_OPTIONS.
*/
2402extern RES_OPTIONS;

2404/**@ingroup sresolv_env
*
* Environment variable containing search domain. This environment
* variable is also used by standard BIND resolver.
*
* @sa Manual page for resolv.conf, #RES_OPTIONS, #SRES_OPTIONS.
*/
2411extern LOCALDOMAIN;
2412#endif

2414/* Parse options line or #SRES_OPTIONS or #RES_OPTIONS environment variable. */
2415static int
2416sres_parse_options(sres_config_t *c, char const *value)
2417{
if (!value)
  return -1;

while (value[0]) {
  char const *b;
  size_t len, extra = 0;
  unsigned long n = 0;

  b = value; len = strcspn(value, " \t:");
  value += len;

  if (value[0] == ':') {
    len++;
    n = strtoul(++value, NULL((void*)0), 10);
    value += extra = strcspn(value, " \t");
  }

  if (*value)
    value += strspn(value, " \t");

  if (n > 65536) {
    SU_DEBUG_3(("sres: %s: invalid %*.0s\n", c->c_filename,(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 3 ? (_su_llog(sresolv_log, 3, "sres.c"
, (const char *)__func__, 2440, "sres: %s: invalid %*.0s\n", c
->c_filename, (int)(len + extra), b)) : (void)0)
  (int)(len + extra), b))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 3 ? (_su_llog(sresolv_log, 3, "sres.c"
, (const char *)__func__, 2440, "sres: %s: invalid %*.0s\n", c
->c_filename, (int)(len + extra), b)) : (void)0);
    continue;
  }

  /* Documented by BIND9 resolv.conf */
  if (MATCH("no-debug")(len == strlen("no-debug") && su_casenmatch("no-debug"
, b, len))) c->c_opt.debug = 0;
  else if (MATCH("debug")(len == strlen("debug") && su_casenmatch("debug", b, len
))) c->c_opt.debug = 1;
  else if (MATCH("ndots:")(len == strlen("ndots:") && su_casenmatch("ndots:", b
, len))) c->c_opt.ndots = n;
  else if (MATCH("timeout:")(len == strlen("timeout:") && su_casenmatch("timeout:"
, b, len))) c->c_opt.timeout = n;
  else if (MATCH("attempts:")(len == strlen("attempts:") && su_casenmatch("attempts:"
, b, len))) c->c_opt.attempts = n;
  else if (MATCH("no-rotate")(len == strlen("no-rotate") && su_casenmatch("no-rotate"
, b, len))) c->c_opt.rotate = 0;
  else if (MATCH("rotate")(len == strlen("rotate") && su_casenmatch("rotate", b
, len))) c->c_opt.rotate = 1;
  else if (MATCH("no-check-names")(len == strlen("no-check-names") && su_casenmatch("no-check-names"
, b, len))) c->c_opt.check_names = 0;
  else if (MATCH("check-names")(len == strlen("check-names") && su_casenmatch("check-names"
, b, len))) c->c_opt.check_names = 1;
  else if (MATCH("no-inet6")(len == strlen("no-inet6") && su_casenmatch("no-inet6"
, b, len))) c->c_opt.ip6int = 0;
  else if (MATCH("inet6")(len == strlen("inet6") && su_casenmatch("inet6", b, len
))) c->c_opt.inet6 = 1;
  else if (MATCH("no-ip6-dotint")(len == strlen("no-ip6-dotint") && su_casenmatch("no-ip6-dotint"
, b, len))) c->c_opt.ip6int = 0;
  else if (MATCH("ip6-dotint")(len == strlen("ip6-dotint") && su_casenmatch("ip6-dotint"
, b, len))) c->c_opt.ip6int = 1;
  else if (MATCH("no-ip6-bytestring")(len == strlen("no-ip6-bytestring") && su_casenmatch(
"no-ip6-bytestring", b, len))) c->c_opt.ip6bytestring = 0;
  else if (MATCH("ip6-bytestring")(len == strlen("ip6-bytestring") && su_casenmatch("ip6-bytestring"
, b, len))) c->c_opt.ip6bytestring = 1;
  /* Sofia-specific extensions: */
  else if (MATCH("no-edns0")(len == strlen("no-edns0") && su_casenmatch("no-edns0"
, b, len))) c->c_opt.edns = edns_not_supported;
  else if (MATCH("edns0")(len == strlen("edns0") && su_casenmatch("edns0", b, len
))) c->c_opt.edns = edns0_configured;
  else {
    SU_DEBUG_3(("sres: %s: unknown option %*.0s\n",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 3 ? (_su_llog(sresolv_log, 3, "sres.c"
, (const char *)__func__, 2465, "sres: %s: unknown option %*.0s\n"
, c->c_filename, (int)(len + extra), b)) : (void)0)
  c->c_filename, (int)(len + extra), b))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 3 ? (_su_llog(sresolv_log, 3, "sres.c"
, (const char *)__func__, 2465, "sres: %s: unknown option %*.0s\n"
, c->c_filename, (int)(len + extra), b)) : (void)0);
  }
}

return 0;
2470}

2472static
2473int sres_parse_nameserver(sres_config_t *c, char const *server)
2474{
sres_nameserver_t *ns;
struct sockaddr *sa;
int err, i;

for (i = 0; i < SRES_MAX_NAMESERVERS(SRES_MAX_NAMESERVERS); i++)
  if (c->c_nameservers[i] == NULL((void*)0))
    break;

if (i >= SRES_MAX_NAMESERVERS(SRES_MAX_NAMESERVERS))
  return 0 /* Silently discard extra nameservers */;

ns = su_zalloc(c->c_home, (sizeof *ns) + strlen(server) + 1);
if (!ns)
  return -1;

sa = (void *)ns->ns_addr;

2492#if HAVE_SIN61
if (strchr(server, ':')) {
  struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;
  memset(sa, 0, ns->ns_addrlen = sizeof *sin6);
  err = su_inet_ptoninet_pton(sa->sa_family = AF_INET610, server, &sin6->sin6_addr);
}
else
2499#endif
  {
    struct sockaddr_in *sin = (struct sockaddr_in *)sa;
    memset(sa, 0, ns->ns_addrlen = sizeof *sin);
    err = su_inet_ptoninet_pton(sa->sa_family = AF_INET2, server, &sin->sin_addr);
  }

if (err <= 0) {
  SU_DEBUG_3(("sres: nameserver %s: invalid address\n", server))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 3 ? (_su_llog(sresolv_log, 3, "sres.c"
, (const char *)__func__, 2507, "sres: nameserver %s: invalid address\n"
, server)) : (void)0);
  su_free(c->c_home, ns);
  return 0;
}

2512#if HAVE_SA_LEN
sa->sa_len = ns->ns_addrlen;
2514#endif

c->c_nameservers[i] = ns;

return 1;
2519}

2521/** Get current timestamp of resolv.conf file */
2522static
2523time_t sres_config_timestamp(sres_config_t const *c)
2524{
2525#ifndef HAVE_WIN32
struct stat st;

if (stat(c->c_filename, &st) == 0)
  return st.st_mtimest_mtim.tv_sec;

/** @return If the resolv.conf file does not exists, return old timestamp. */
return c->c_modified;
2533#else
/** On WIN32, return always different timestamp */
return c->c_modified + SRES_UPDATE_INTERVAL_SECS5;
2536#endif
2537}


2540/* ---------------------------------------------------------------------- */

2542/** Check if the new configuration has different servers than the old */
2543static
2544int sres_config_changed_servers(sres_config_t const *new_c,
		sres_config_t const *old_c)
2546{
int i;
sres_nameserver_t const *new_ns, *old_ns;

if (old_c == NULL((void*)0))
  return 1;

for (i = 0; i < SRES_MAX_NAMESERVERS(SRES_MAX_NAMESERVERS); i++) {
  new_ns = new_c->c_nameservers[i];
  old_ns = old_c->c_nameservers[i];

  if (!new_ns != !old_ns)
    return 1;
  if (!new_ns)
    return 0;
  if (new_ns->ns_addrlen != old_ns->ns_addrlen)
    return 1;
  if (memcmp(new_ns->ns_addr, old_ns->ns_addr, new_ns->ns_addrlen))
    return 1;
}

return 0;
2568}

2570/** Allocate new servers structure */
2571static
2572sres_server_t **sres_servers_new(sres_resolver_t *res,
		 sres_config_t const *c)
2574{
sres_server_t **servers, *dns;
sres_nameserver_t *ns;
int N, i;
size_t size;

for (N = 0; c->c_nameservers[N] && N < SRES_MAX_NAMESERVERS(SRES_MAX_NAMESERVERS); N++)
  ;

size = (N + 1) * (sizeof *servers) + N * (sizeof **servers);

servers = su_zalloc(res->res_home, size); if (!servers) return servers;
dns = (void *)(servers + N + 1);
for (i = 0; i < N; i++) {
  dns->dns_socket = INVALID_SOCKET((sres_socket_t)-1);
  ns = c->c_nameservers[i];
  memcpy(dns->dns_addr, ns->ns_addr, dns->dns_addrlen = ns->ns_addrlen);
  su_inet_ntopinet_ntop(dns->dns_addr->ss_family, SS_ADDR(dns->dns_addr)((dns->dns_addr)->ss_family == 2 ? (void *)&((struct
 sockaddr_in *)dns->dns_addr)->sin_addr : ((dns->dns_addr
)->ss_family == 10 ? (void *)&((struct sockaddr_in6 *)
dns->dns_addr)->sin6_addr : (void *)&((struct sockaddr
 *)dns->dns_addr)->sa_data)),
     dns->dns_name, sizeof dns->dns_name);
  dns->dns_edns = c->c_opt.edns;
  servers[i] = dns++;
}

return servers;
2598}

2600static
2601void sres_servers_close(sres_resolver_t *res,
	sres_server_t **servers)
2603{
int i;

if (res == NULL((void*)0) || servers == NULL((void*)0))
  return;

for (i = 0; i < SRES_MAX_NAMESERVERS(SRES_MAX_NAMESERVERS); i++) {
  if (!servers[i])
    break;

  if (servers[i]->dns_socket != INVALID_SOCKET((sres_socket_t)-1)) {
    if (res->res_updcb)
res->res_updcb(res->res_async, INVALID_SOCKET((sres_socket_t)-1), servers[i]->dns_socket);
    sres_close(servers[i]->dns_socket)close((servers[i]->dns_socket));
  }
}
2619}

2621static
2622int sres_servers_count(sres_server_t *const *servers)
2623{
int i;

if (!servers)
  return 0;

for (i = 0; i < SRES_MAX_NAMESERVERS(SRES_MAX_NAMESERVERS); i++) {
  if (!servers[i])
    break;
}

return i;
2635}

2637static
2638sres_socket_t sres_server_socket(sres_resolver_t *res, sres_server_t *dns)
2639{
int family = dns->dns_addr->ss_family;
sres_socket_t s;

if (dns->dns_socket != INVALID_SOCKET((sres_socket_t)-1))
  return dns->dns_socket;

s = socket(family, SOCK_DGRAMSOCK_DGRAM, IPPROTO_UDPIPPROTO_UDP);
if (s == -1) {
  SU_DEBUG_1(("%s: %s: %s\n", "sres_server_socket", "socket",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 1 ? (_su_llog(sresolv_log, 1, "sres.c"
, (const char *)__func__, 2649, "%s: %s: %s\n", "sres_server_socket"
, "socket", su_strerror(su_errno()))) : (void)0)
su_strerror(su_errno())))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 1 ? (_su_llog(sresolv_log, 1, "sres.c"
, (const char *)__func__, 2649, "%s: %s: %s\n", "sres_server_socket"
, "socket", su_strerror(su_errno()))) : (void)0);
  return s;
}

2653#if HAVE_IP_RECVERR1
if (family == AF_INET2 || family == AF_INET610) {
  int const one = 1;
  if (setsockopt(s, SOL_IP0, IP_RECVERR11, &one, sizeof(one)) < 0) {
    if (family == AF_INET2)
SU_DEBUG_3(("setsockopt(IPVRECVERR): %s\n", su_strerror(su_errno())))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 3 ? (_su_llog(sresolv_log, 3, "sres.c"
, (const char *)__func__, 2658, "setsockopt(IPVRECVERR): %s\n"
, su_strerror(su_errno()))) : (void)0);
  }
}
2661#endif
2662#if HAVE_IPV6_RECVERR1
if (family == AF_INET610) {
  int const one = 1;
  if (setsockopt(s, SOL_IPV641, IPV6_RECVERR25, &one, sizeof(one)) < 0)
    SU_DEBUG_3(("setsockopt(IPV6_RECVERR): %s\n", su_strerror(su_errno())))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 3 ? (_su_llog(sresolv_log, 3, "sres.c"
, (const char *)__func__, 2666, "setsockopt(IPV6_RECVERR): %s\n"
, su_strerror(su_errno()))) : (void)0);
}
2668#endif

if (connect(s, (void *)dns->dns_addr, dns->dns_addrlen) < 0) {
  char ipaddr[64];
  char const *lb = "", *rb = "";

  if (family == AF_INET2) {
    void *addr = &((struct sockaddr_in *)dns->dns_addr)->sin_addr;
    su_inet_ntopinet_ntop(family, addr, ipaddr, sizeof ipaddr);
  }
2678#if HAVE_SIN61
  else if (family == AF_INET610) {
    void *addr = &((struct sockaddr_in6 *)dns->dns_addr)->sin6_addr;
    su_inet_ntopinet_ntop(family, addr, ipaddr, sizeof ipaddr);
    lb = "[", rb = "]";
  }
2684#endif
  else
    snprintf(ipaddr, sizeof ipaddr, "<af=%u>", family);

  SU_DEBUG_1(("%s: %s: %s: %s%s%s:%u\n", "sres_server_socket", "connect",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 1 ? (_su_llog(sresolv_log, 1, "sres.c"
, (const char *)__func__, 2690, "%s: %s: %s: %s%s%s:%u\n", "sres_server_socket"
, "connect", su_strerror(su_errno()), lb, ipaddr, rb, ntohs((
(struct sockaddr_in *)dns->dns_addr)->sin_port))) : (void
)0)
su_strerror(su_errno()), lb, ipaddr, rb,(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 1 ? (_su_llog(sresolv_log, 1, "sres.c"
, (const char *)__func__, 2690, "%s: %s: %s: %s%s%s:%u\n", "sres_server_socket"
, "connect", su_strerror(su_errno()), lb, ipaddr, rb, ntohs((
(struct sockaddr_in *)dns->dns_addr)->sin_port))) : (void
)0)
ntohs(((struct sockaddr_in *)dns->dns_addr)->sin_port)))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 1 ? (_su_llog(sresolv_log, 1, "sres.c"
, (const char *)__func__, 2690, "%s: %s: %s: %s%s%s:%u\n", "sres_server_socket"
, "connect", su_strerror(su_errno()), lb, ipaddr, rb, ntohs((
(struct sockaddr_in *)dns->dns_addr)->sin_port))) : (void
)0);
  sres_close(s)close((s));
  return INVALID_SOCKET((sres_socket_t)-1);
}

if (res->res_updcb) {
  if (res->res_updcb(res->res_async, s, INVALID_SOCKET((sres_socket_t)-1)) < 0) {
    SU_DEBUG_1(("%s: %s: %s\n", "sres_server_socket", "update callback",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 1 ? (_su_llog(sresolv_log, 1, "sres.c"
, (const char *)__func__, 2698, "%s: %s: %s\n", "sres_server_socket"
, "update callback", su_strerror(su_errno()))) : (void)0)
  su_strerror(su_errno())))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 1 ? (_su_llog(sresolv_log, 1, "sres.c"
, (const char *)__func__, 2698, "%s: %s: %s\n", "sres_server_socket"
, "update callback", su_strerror(su_errno()))) : (void)0);
    sres_close(s)close((s));
    return INVALID_SOCKET((sres_socket_t)-1);
  }
}

dns->dns_socket = s;

return s;
2707}

2709/* ---------------------------------------------------------------------- */

2711/** Send a query packet */
2712static
2713int
2714sres_send_dns_query(sres_resolver_t *res,
    sres_query_t *q)
2716{
sres_message_t m[1];
uint8_t i, i0, N = res->res_n_servers;
sres_socket_t s;
int error = 0;
ssize_t size, no_edns_size, edns_size;
uint16_t id = q->q_id;
uint16_t type = q->q_type;
char const *domain = q->q_name;
time_t now = res->res_now;
sres_server_t **servers = res->res_servers, *dns;
char b[8];

if (now == 0) time(&now);

SU_DEBUG_9(("sres_send_dns_query(%p, %p) called\n", (void *)res, (void *)q))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 2731, "sres_send_dns_query(%p, %p) called\n"
, (void *)res, (void *)q)) : (void)0);

if (domain == NULL((void*)0))
  return -1;
if (servers == NULL((void*)0))
  return -1;
if (N == 0)
  return -1;

memset(m, 0, offsetof(sres_message_t, m_data[sizeof m->m_packet.mp_header])__builtin_offsetof(sres_message_t, m_packet.mp_data[sizeof m->
m_packet.mp_header]));

/* Create a DNS message */
size = sizeof(m->m_packet.mp_header);
m->m_size = (uint16_t)sizeof(m->m_datam_packet.mp_data);
m->m_offset = (uint16_t)size;

m->m_idm_packet.mp_header.mh_id = id;
m->m_flagsm_packet.mp_header.mh_flags = htons(SRES_HDR_QUERY | SRES_HDR_RD);

/* Query record */
m->m_qdcountm_packet.mp_header.mh_qdcount = htons(1);
m_put_domain(m, domain, 0, NULL((void*)0));
m_put_uint16(m, type);
m_put_uint16(m, sres_class_in);

no_edns_size = m->m_offset;

/* EDNS0 record (optional) */
m_put_domain(m, ".", 0, NULL((void*)0));
m_put_uint16(m, sres_type_opt);
m_put_uint16(m, sizeof(m->m_packet)); /* Class: our UDP payload size */
m_put_uint32(m, 0);		/* TTL: extended RCODE & flags */
m_put_uint16(m, 0);

edns_size = m->m_offset;

if (m->m_error) {
  SU_DEBUG_3(("%s(): encoding: %s\n", "sres_send_dns_query", m->m_error))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 3 ? (_su_llog(sresolv_log, 3, "sres.c"
, (const char *)__func__, 2768, "%s(): encoding: %s\n", "sres_send_dns_query"
, m->m_error)) : (void)0);
  su_seterrno(EIO5);
  return -1;
}

i0 = q->q_i_server;
if (i0 > N) i0 = 0; /* Number of DNS servers reduced */
dns = servers[i = i0];

error = EIO5;

if (res->res_config->c_opt.rotate || dns->dns_error || dns->dns_icmp)
  dns = sres_next_server(res, &q->q_i_server, 1), i = q->q_i_server;

for (; dns; dns = sres_next_server(res, &i, 1)) {
  /* If server supports EDNS, include EDNS0 record */
  q->q_edns = dns->dns_edns;
  /* 0 (no EDNS) or 1 (EDNS supported) additional data records */
  m->m_arcountm_packet.mp_header.mh_arcount = htons(q->q_edns != 0);
  /* Size with or without EDNS record */
  size = q->q_edns ? edns_size : no_edns_size;

  s = sres_server_socket(res, dns);

  if (s == INVALID_SOCKET((sres_socket_t)-1)) {
    dns->dns_icmp = now;
    dns->dns_error = SRES_TIME_MAX((time_t)9223372036854775807L);
    continue;
  }

  /* Send the DNS message via the UDP socket */
  if (sres_send(s, m->m_data, size, 0)send((s),(m->m_packet.mp_data),(size),(0)) == size)
    break;
  error = su_errno();

  dns->dns_icmp = now;
  dns->dns_error = now;	/* Mark as a bad destination */
}

if (!dns) {
  /* All servers have reported errors */
  SU_DEBUG_5(("%s(): sendto: %s\n", "sres_send_dns_query",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 2810, "%s(): sendto: %s\n", "sres_send_dns_query"
, su_strerror(error))) : (void)0)
su_strerror(error)))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 2810, "%s(): sendto: %s\n", "sres_send_dns_query"
, su_strerror(error))) : (void)0);
  return su_seterrno(error);
}

q->q_i_server = i;

SU_DEBUG_5(("%s(%p, %p) id=%u %s %s (to [%s]:%u)\n",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 2820, "%s(%p, %p) id=%u %s %s (to [%s]:%u)\n"
, "sres_send_dns_query", (void *)res, (void *)q, id, sres_record_type
(type, b), domain, dns->dns_name, htons(((struct sockaddr_in
 *)dns->dns_addr)->sin_port))) : (void)0)
     "sres_send_dns_query",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 2820, "%s(%p, %p) id=%u %s %s (to [%s]:%u)\n"
, "sres_send_dns_query", (void *)res, (void *)q, id, sres_record_type
(type, b), domain, dns->dns_name, htons(((struct sockaddr_in
 *)dns->dns_addr)->sin_port))) : (void)0)
     (void *)res, (void *)q, id, sres_record_type(type, b), domain,(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 2820, "%s(%p, %p) id=%u %s %s (to [%s]:%u)\n"
, "sres_send_dns_query", (void *)res, (void *)q, id, sres_record_type
(type, b), domain, dns->dns_name, htons(((struct sockaddr_in
 *)dns->dns_addr)->sin_port))) : (void)0)
     dns->dns_name,(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 2820, "%s(%p, %p) id=%u %s %s (to [%s]:%u)\n"
, "sres_send_dns_query", (void *)res, (void *)q, id, sres_record_type
(type, b), domain, dns->dns_name, htons(((struct sockaddr_in
 *)dns->dns_addr)->sin_port))) : (void)0)
     htons(((struct sockaddr_in *)dns->dns_addr)->sin_port)))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 2820, "%s(%p, %p) id=%u %s %s (to [%s]:%u)\n"
, "sres_send_dns_query", (void *)res, (void *)q, id, sres_record_type
(type, b), domain, dns->dns_name, htons(((struct sockaddr_in
 *)dns->dns_addr)->sin_port))) : (void)0);

return 0;
2823}

2825/** Retry time after ICMP error */
2826#define DNS_ICMP_TIMEOUT60 60

2828/** Retry time after immediate error */
2829#define DNS_ERROR_TIMEOUT10 10

2831/** Select next server.
*
* @param res resolver object
* @param[in,out] in_out_i index to DNS server table
* @param always return always a server
*/
2837static
2838sres_server_t *sres_next_server(sres_resolver_t *res,
		uint8_t *in_out_i,
		int always)
2841{
int i, j, N;
sres_server_t *dns, **servers;
time_t now = res->res_now;

N = res->res_n_servers;
servers = res->res_servers;
i = *in_out_i;

assert(res->res_servers && res->res_servers[i])((void) sizeof ((res->res_servers && res->res_servers
[i]) ? 1 : 0), __extension__ ({ if (res->res_servers &&
 res->res_servers[i]) ; else __assert_fail ("res->res_servers && res->res_servers[i]"
, "sres.c", 2850, __extension__ __PRETTY_FUNCTION__); }));

for (j=0; j < N; j++) {
  dns = servers[j]; if (!dns) continue;
  if (dns->dns_icmp + DNS_ICMP_TIMEOUT60 < now)
    dns->dns_icmp = 0;
  if (dns->dns_error + DNS_ERROR_TIMEOUT10 < now &&
dns->dns_error != SRES_TIME_MAX((time_t)9223372036854775807L))
    dns->dns_error = 0;
}

/* Retry using another server? */
for (j = (i + 1) % N; (j != i); j = (j + 1) % N) {
  dns = servers[j]; if (!dns) continue;
  if (dns->dns_icmp == 0) {
    return *in_out_i = j, dns;
  }
}

for (j = (i + 1) % N; (j != i); j = (j + 1) % N) {
  dns = servers[j]; if (!dns) continue;
  if (dns->dns_error == 0) {
    return *in_out_i = j, dns;
  }
}

if (!always)
  return NULL((void*)0);

dns = servers[i];
if (dns && dns->dns_error < now && dns->dns_error != SRES_TIME_MAX((time_t)9223372036854775807L))
  return dns;

for (j = (i + 1) % N; j != i; j = (j + 1) % N) {
  dns = servers[j]; if (!dns) continue;
  if (dns->dns_error < now && dns->dns_error != SRES_TIME_MAX((time_t)9223372036854775807L))
    return *in_out_i = j, dns;
}

return NULL((void*)0);
2890}

2892/**
* Callback function for subqueries
*/
2895static
2896void sres_answer_subquery(sres_context_t *context,
	  sres_query_t *query,
	  sres_record_t **answers)
2899{
sres_resolver_t *res;
sres_query_t *top = (sres_query_t *)context;
int i;
assert(top)((void) sizeof ((top) ? 1 : 0), __extension__ ({ if (top) ; else
 __assert_fail ("top", "sres.c", 2903, __extension__ __PRETTY_FUNCTION__
); })); assert(top->q_n_subs > 0)((void) sizeof ((top->q_n_subs > 0) ? 1 : 0), __extension__
 ({ if (top->q_n_subs > 0) ; else __assert_fail ("top->q_n_subs > 0"
, "sres.c", 2903, __extension__ __PRETTY_FUNCTION__); })); assert(query)((void) sizeof ((query) ? 1 : 0), __extension__ ({ if (query)
 ; else __assert_fail ("query", "sres.c", 2903, __extension__
 __PRETTY_FUNCTION__); }));

res = query->q_res;

for (i = 0; i <= SRES_MAX_SEARCH(SRES_MAX_SEARCH); i++) {
  if (top->q_subqueries[i] == query)
    break;
}
assert(i <= SRES_MAX_SEARCH)((void) sizeof ((i <= (SRES_MAX_SEARCH)) ? 1 : 0), __extension__
 ({ if (i <= (SRES_MAX_SEARCH)) ; else __assert_fail ("i <= SRES_MAX_SEARCH"
, "sres.c", 2911, __extension__ __PRETTY_FUNCTION__); }));
if (i > SRES_MAX_SEARCH(SRES_MAX_SEARCH) || top->q_n_subs == 0) {
  sres_free_answers(res, answers);
  return;
}

if (answers) {
  int j, k;
  for (j = 0, k = 0; answers[j]; j++) {
    if (answers[j]->sr_statussr_record->r_status)
sres_free_answer(query->q_res, answers[j]);
    else
answers[k++] = answers[j];
  }
  answers[k] = NULL((void*)0);
  if (!answers[0])
    sres_free_answers(query->q_res, answers), answers = NULL((void*)0);
}

top->q_subqueries[i] = NULL((void*)0);
top->q_subanswers[i] = answers;
top->q_n_subs--;

if (answers && top->q_callback) {
  sres_answer_f *callback = top->q_callback;

  top->q_callback = NULL((void*)0);
  sres_remove_query(top->q_res, top, 1);
  callback(top->q_context, top, answers);
}
else if (top->q_n_subs == 0 && top->q_id == 0) {
  sres_query_report_error(top, NULL((void*)0));
};
2944}

2946/** Report sres error */
2947static void
2948sres_query_report_error(sres_query_t *q,
	sres_record_t **answers)
2950{
int i;

if (q->q_callback) {
  char sbuf[8], tbuf[8];
  int status = 0;

  for (i = 0; i <= SRES_MAX_SEARCH(SRES_MAX_SEARCH); i++) {
    if (q->q_subqueries[i])	/* a pending query... */
return;

    if (q->q_subanswers[i]) {
answers = q->q_subanswers[i];
q->q_subanswers[i] = NULL((void*)0);
break;
    }
  }

  if (answers == NULL((void*)0)) {
    sres_cache_t *cache = q->q_res->res_cache;

    status = q->q_retry_count ? SRES_TIMEOUT_ERR : SRES_NETWORK_ERR;

    answers = su_zalloc(CHOME(cache)((su_home_t *)(cache)), 2 * sizeof *answers);
    if (answers)
answers[0] = sres_create_error_rr(cache, q, status);
  }
  else {
    for (i = 0; answers[i]; i++) {
status = answers[i]->sr_record->r_status;
if (status)
 break;
    }
  }

  SU_DEBUG_5(("sres(q=%p): reporting error %s for %s %s\n",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 2988, "sres(q=%p): reporting error %s for %s %s\n"
, (void *)q, sres_record_status(status, sbuf), sres_record_type
(q->q_type, tbuf), q->q_name)) : (void)0)
(void *)q,(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 2988, "sres(q=%p): reporting error %s for %s %s\n"
, (void *)q, sres_record_status(status, sbuf), sres_record_type
(q->q_type, tbuf), q->q_name)) : (void)0)
sres_record_status(status, sbuf),(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 2988, "sres(q=%p): reporting error %s for %s %s\n"
, (void *)q, sres_record_status(status, sbuf), sres_record_type
(q->q_type, tbuf), q->q_name)) : (void)0)
sres_record_type(q->q_type, tbuf), q->q_name))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 2988, "sres(q=%p): reporting error %s for %s %s\n"
, (void *)q, sres_record_status(status, sbuf), sres_record_type
(q->q_type, tbuf), q->q_name)) : (void)0);

  sres_remove_query(q->q_res, q, 1);
  (q->q_callback)(q->q_context, q, answers);
}

sres_free_query(q->q_res, q);
2995}

2997/** Resolver timer function.
*
* The function sresolver_timer() should be called in regular intervals. We
* recommend calling it in 500 ms intervals.
*
* @param res pointer to resolver object
* @param dummy argument for compatibility
*/
3005void sres_resolver_timer(sres_resolver_t *res, int dummy)
3006{
size_t i;
sres_query_t *q;
time_t now, retry_time;

if (res == NULL((void*)0))
  return;

now = time(&res->res_now);

if (res->res_queries->qt_used) {
  SU_DEBUG_9(("sres_resolver_timer() called at %lu\n", (long) now))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3017, "sres_resolver_timer() called at %lu\n"
, (long) now)) : (void)0);

  /** Every time it is called it goes through all query structures, and
   * retransmits all the query messages, which have not been answered yet.
   */
  for (i = 0; i < res->res_queries->qt_size; i++) {
    q = res->res_queries->qt_table[i];

    if (!q)
continue;

    /* Exponential backoff */
    retry_time = q->q_timestamp + ((time_t)1 << q->q_retry_count);

    if (now < retry_time)
continue;

    sres_resend_dns_query(res, q, 1);

    if (q != res->res_queries->qt_table[i])
i--;
  }

  if (res->res_schedulecb && res->res_queries->qt_used)
    res->res_schedulecb(res->res_async, SRES_RETRANSMIT_INTERVAL(SRES_RETRANSMIT_INTERVAL));
}

sres_cache_clean(res->res_cache, res->res_now);
3045}

3047/** Resend DNS query, report error if cannot resend any more.
*
* @param res  resolver object
* @param q    query object
* @param timeout  true if resent because of timeout
*                (false if because icmp error report)
*/
3054static void
3055sres_resend_dns_query(sres_resolver_t *res, sres_query_t *q, int timeout)
3056{
uint8_t i, N;
sres_server_t *dns;

SU_DEBUG_9(("sres_resend_dns_query(%p, %p, %s) called\n",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3061, "sres_resend_dns_query(%p, %p, %s) called\n"
, (void *)res, (void *)q, timeout ? "timeout" : "error")) : (
void)0)
     (void *)res, (void *)q, timeout ? "timeout" : "error"))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3061, "sres_resend_dns_query(%p, %p, %s) called\n"
, (void *)res, (void *)q, timeout ? "timeout" : "error")) : (
void)0);

N = res->res_n_servers;

if (N > 0 && q->q_retry_count < SRES_MAX_RETRY_COUNT(SRES_MAX_RETRY_COUNT)) {
  i = q->q_i_server;
  dns = sres_next_server(res, &i, timeout);

  if (dns) {
    res->res_i_server = q->q_i_server = i;

    if (q->q_retry_count > res->res_n_servers + 1 &&
 dns->dns_edns == edns_not_tried)
q->q_edns = edns_not_supported;

    sres_send_dns_query(res, q);

    if (timeout)
q->q_retry_count++;

    return;
  }
}

/* report timeout/network error */
q->q_id = 0;

if (q->q_n_subs)
  return;			/* let subqueries also timeout */

sres_query_report_error(q, NULL((void*)0));
3092}

3094static void
3095sres_resolve_cname(sres_resolver_t *res,
                 sres_query_t *orig_query,
                 char const *cname)
3098{
sres_query_t *query;

query = sres_query_alloc(res,
	   sres_resolving_cname,
	   (sres_context_t *)orig_query,
	   orig_query->q_type,
	   cname);

if (query)
  sres_send_dns_query(res, query);
else
  sres_query_report_error(orig_query, NULL((void*)0));
3111}

3113static void
3114sres_resolving_cname(sres_context_t *original_query,
    sres_query_t *query,
    sres_record_t **answers)
3117{
sres_query_t *orig = (sres_query_t *)original_query;

/* Notify the listener */
if (orig->q_callback != NULL((void*)0))
  (orig->q_callback)(orig->q_context, orig, answers);

sres_free_query(orig->q_res, orig);
3125}

3127/** Get a server by socket */
3128static
3129sres_server_t *
3130sres_server_by_socket(sres_resolver_t const *res, sres_socket_t socket)
3131{
int i;

if (socket == -1)
  return NULL((void*)0);

for (i = 0; i < res->res_n_servers; i++) {
  if (socket == res->res_servers[i]->dns_socket)
    return res->res_servers[i];
}

return NULL((void*)0);
3143}

3145static
3146void
3147sres_canonize_sockaddr(struct sockaddr_storage *from, socklen_t *fromlen)
3148{
3149#if HAVE_SIN61
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)from;

size_t sin6_addrsize =
  offsetof(struct sockaddr_in6, sin6_addr)__builtin_offsetof(struct sockaddr_in6, sin6_addr) +
  (sizeof sin6->sin6_addr);

if (from->ss_family == AF_INET610) {
  struct in6_addr const *ip6 = &sin6->sin6_addr;

  if (IN6_IS_ADDR_V4MAPPED(ip6)(__extension__ ({ const struct in6_addr *__a = (const struct in6_addr
 *) (ip6); __a->__in6_u.__u6_addr32[0] == 0 && __a
->__in6_u.__u6_addr32[1] == 0 && __a->__in6_u.__u6_addr32
[2] == htonl (0xffff); })) || IN6_IS_ADDR_V4COMPAT(ip6)(__extension__ ({ const struct in6_addr *__a = (const struct in6_addr
 *) (ip6); __a->__in6_u.__u6_addr32[0] == 0 && __a
->__in6_u.__u6_addr32[1] == 0 && __a->__in6_u.__u6_addr32
[2] == 0 && ntohl (__a->__in6_u.__u6_addr32[3]) >
 1; }))) {
    /* Convert to a IPv4 address */
    struct sockaddr_in *sin = (struct sockaddr_in *)from;
    memcpy(&sin->sin_addr, ip6->s6_addr__in6_u.__u6_addr8 + 12, sizeof sin->sin_addr);
    sin->sin_family = AF_INET2;
    *fromlen = sizeof (*sin);
3165#if HAVE_SA_LEN
    sin->sin_len = sizeof (*sin);
3167#endif
  }
  else if (sin6_addrsize < *fromlen) {
    /* Zero extra sin6 members like sin6_flowinfo or sin6_scope_id */
    memset((char *)from + sin6_addrsize, 0, *fromlen - sin6_addrsize);
  }
}
3174#endif

if (from->ss_family == AF_INET2) {
  struct sockaddr_in *sin = (struct sockaddr_in *)from;
  memset(sin->sin_zero, 0, sizeof (sin->sin_zero));
}
3180}

3182static
3183int sres_no_update(sres_async_t *async,
   sres_socket_t new_socket,
   sres_socket_t old_socket)
3186{
return 0;
3188}

3190/** Create connected sockets for resolver.
*/
3192int sres_resolver_sockets(sres_resolver_t *res,
	  sres_socket_t *return_sockets,
	  int n)
3195{
sres_socket_t s = INVALID_SOCKET((sres_socket_t)-1);
int i, retval;

if (!sres_resolver_set_async(res, sres_no_update,
	       (sres_async_t *)-1, 1))
  return -1;

retval = res->res_n_servers; assert(retval <= SRES_MAX_NAMESERVERS)((void) sizeof ((retval <= (SRES_MAX_NAMESERVERS)) ? 1 : 0
), __extension__ ({ if (retval <= (SRES_MAX_NAMESERVERS)) ;
 else __assert_fail ("retval <= SRES_MAX_NAMESERVERS", "sres.c"
, 3203, __extension__ __PRETTY_FUNCTION__); }));

if (!return_sockets || n == 0)
  return retval;

for (i = 0; i < retval && i < n;) {
  sres_server_t *dns = res->res_servers[i];

  s = sres_server_socket(res, dns);

  if (s == INVALID_SOCKET((sres_socket_t)-1)) {	/* Mark as a bad destination */
    dns->dns_icmp = SRES_TIME_MAX((time_t)9223372036854775807L);
    dns->dns_error = SRES_TIME_MAX((time_t)9223372036854775807L);
  }

  return_sockets[i++] = s;
}

return retval;
3222}

3224#if 0
3225/** Get a server by socket address */
3226static
3227sres_server_t *
3228sres_server_by_sockaddr(sres_resolver_t const *res,
	void const *from, socklen_t fromlen)
3230{
int i;

for (i = 0; i < res->res_n_servers; i++) {
  sres_server_t *dns = res->res_servers[i];
  if (dns->dns_addrlen == fromlen &&
memcmp(dns->dns_addr, from, fromlen) == 0)
    return dns;
}

return NULL((void*)0);
3241}
3242#endif

3244/** Receive error message from socket. */
3245#if HAVE_IP_RECVERR1 || HAVE_IPV6_RECVERR1
3246int sres_resolver_error(sres_resolver_t *res, int socket)
3247{
int errcode = 0;
struct cmsghdr *c;
struct sock_extended_err *ee;
struct sockaddr_storage *from;
char control[512];
char errmsg[64 + 768];
struct iovec iov[1];
struct msghdr msg[1] = {{ 0 }};
struct sockaddr_storage name[1] = {{ 0 }};
int n;
char info[128] = "";

SU_DEBUG_9(("%s(%p, %u) called\n", "sres_resolver_error",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3261, "%s(%p, %u) called\n", "sres_resolver_error"
, (void *)res, socket)) : (void)0)
     (void *)res, socket))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3261, "%s(%p, %u) called\n", "sres_resolver_error"
, (void *)res, socket)) : (void)0);

msg->msg_name = name, msg->msg_namelen = sizeof(name);
msg->msg_iov = iov, msg->msg_iovlen = 1;
iov->iov_base = errmsg, iov->iov_len = sizeof(errmsg);
msg->msg_control = control, msg->msg_controllen = sizeof(control);

n = recvmsg(socket, msg, MSG_ERRQUEUEMSG_ERRQUEUE);

if (n < 0) {
  int error = su_errno();
  if (error != EAGAIN11 && error != EWOULDBLOCK11)
    SU_DEBUG_1(("%s: recvmsg: %s\n", __func__, su_strerror(error)))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 1 ? (_su_llog(sresolv_log, 1, "sres.c"
, (const char *)__func__, 3273, "%s: recvmsg: %s\n", __func__
, su_strerror(error))) : (void)0);
  return n;
}

if ((msg->msg_flags & MSG_ERRQUEUEMSG_ERRQUEUE) != MSG_ERRQUEUEMSG_ERRQUEUE) {
  SU_DEBUG_1(("%s: recvmsg: no errqueue\n", __func__))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 1 ? (_su_llog(sresolv_log, 1, "sres.c"
, (const char *)__func__, 3278, "%s: recvmsg: no errqueue\n",
 __func__)) : (void)0);
  return su_seterrno(EIO5);
}

if (msg->msg_flags & MSG_CTRUNCMSG_CTRUNC) {
  SU_DEBUG_1(("%s: extended error was truncated\n", __func__))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 1 ? (_su_llog(sresolv_log, 1, "sres.c"
, (const char *)__func__, 3283, "%s: extended error was truncated\n"
, __func__)) : (void)0);
  return su_seterrno(EIO5);
}

if (msg->msg_flags & MSG_TRUNCMSG_TRUNC) {
  /* ICMP message may contain original message... */
  SU_DEBUG_5(("%s: icmp(6) message was truncated (at %d)\n", __func__, n))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3289, "%s: icmp(6) message was truncated (at %d)\n"
, __func__, n)) : (void)0);
}

/* Go through the ancillary data */
for (c = CMSG_FIRSTHDR(msg)((size_t) (msg)->msg_controllen >= sizeof (struct cmsghdr
) ? (struct cmsghdr *) (msg)->msg_control : (struct cmsghdr
 *) 0); c; c = CMSG_NXTHDR(msg, c)__cmsg_nxthdr (msg, c)) {
  if (0
3295#if HAVE_IP_RECVERR1
|| (c->cmsg_level == SOL_IP0 && c->cmsg_type == IP_RECVERR11)
3297#endif
3298#if HAVE_IPV6_RECVERR1
|| (c->cmsg_level == SOL_IPV641 && c->cmsg_type == IPV6_RECVERR25)
3300#endif
) {
    char const *origin;

    ee = (struct sock_extended_err *)CMSG_DATA(c)((c)->__cmsg_data);
    from = (void *)SO_EE_OFFENDER(ee)((struct sockaddr*)((ee)+1));
    info[0] = '\0';

    switch (ee->ee_origin) {
    case SO_EE_ORIGIN_LOCAL1:
strcpy(info, origin = "local");
break;
    case SO_EE_ORIGIN_ICMP2:
snprintf(info, sizeof(info), "%s type=%u code=%u",
 origin = "icmp", ee->ee_type, ee->ee_code);
break;
    case SO_EE_ORIGIN_ICMP63:
snprintf(info, sizeof(info), "%s type=%u code=%u",
 origin = "icmp6", ee->ee_type, ee->ee_code);
break;
    case SO_EE_ORIGIN_NONE0:
strcpy(info, origin = "none");
break;
    default:
strcpy(info, origin = "unknown");
break;
    }

    if (ee->ee_info)
snprintf(info + strlen(info), sizeof(info) - strlen(info),
 " info=%08x", ee->ee_info);
    errcode = ee->ee_errno;

    if (from->ss_family != AF_UNSPEC0) {
socklen_t fromlen = ((char *)c + c->cmsg_len) - (char *)from;

sres_canonize_sockaddr(from, &fromlen);

snprintf(info + strlen(info), sizeof(info) - strlen(info),
 " reported by ");
su_inet_ntopinet_ntop(from->ss_family, SS_ADDR(from)((from)->ss_family == 2 ? (void *)&((struct sockaddr_in
 *)from)->sin_addr : ((from)->ss_family == 10 ? (void *
)&((struct sockaddr_in6 *)from)->sin6_addr : (void *)&
((struct sockaddr *)from)->sa_data)),
  info + strlen(info), sizeof(info) - strlen(info));
    }

    if (msg->msg_namelen <= 0)
break;

    {
int error;
socklen_t errorlen = sizeof error;
/* Get error, if any */
getsockopt(socket, SOL_SOCKET1, SO_ERROR4, (void *)&error, &errorlen);
    }

    if (sres_resolver_report_error(res, socket, errcode,
		     msg->msg_name, msg->msg_namelen,
		     info))
return errcode;
    break;
  }
}

if (errcode)
  sres_resolver_report_error(res, socket, errcode, NULL((void*)0), 0, info);

return errcode;
3366}

3368#else
3369int sres_resolver_error(sres_resolver_t *res, int socket)
3370{
int errcode = 0;
socklen_t errorlen = sizeof(errcode);

SU_DEBUG_9(("%s(%p, %u) called\n", "sres_resolver_error",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3375, "%s(%p, %u) called\n", "sres_resolver_error"
, (void *)res, socket)) : (void)0)
     (void *)res, socket))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3375, "%s(%p, %u) called\n", "sres_resolver_error"
, (void *)res, socket)) : (void)0);

getsockopt(socket, SOL_SOCKET1, SO_ERROR4, (void *)&errcode, &errorlen);

return sres_resolver_report_error(res, socket, errcode, NULL((void*)0), 0, "");
3380}
3381#endif


3384/** Report error */
3385static
3386int
3387sres_resolver_report_error(sres_resolver_t *res,
	   sres_socket_t socket,
	   int errcode,
	   struct sockaddr_storage *remote,
	   socklen_t remotelen,
	   char const *info)
3393{
char buf[80];

buf[0] = '\0';

if (remote) {
  sres_canonize_sockaddr(remote, &remotelen);

  if (remote->ss_family == AF_INET2) {
    struct sockaddr_in const *sin = (struct sockaddr_in *)remote;
    uint8_t const *in_addr = (uint8_t*)&sin->sin_addr;
    su_inet_ntopinet_ntop(AF_INET2, in_addr, buf, sizeof(buf));
  }
3406#if HAVE_SIN61
  else if (remote->ss_family == AF_INET610) {
    struct sockaddr_in6 const *sin6 = (struct sockaddr_in6 *)remote;
    uint8_t const *in_addr = (uint8_t*)&sin6->sin6_addr;
    su_inet_ntopinet_ntop(AF_INET610, in_addr, buf, sizeof(buf));
  }
3412#endif
}

SU_DEBUG_5(("sres: network error %u (%s)%s%s%s%s\n",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3419, "sres: network error %u (%s)%s%s%s%s\n"
, errcode, su_strerror(errcode), buf[0] ? " from " : "", buf,
 info ? " by " : "", info ? info : "")) : (void)0)
     errcode, su_strerror(errcode),(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3419, "sres: network error %u (%s)%s%s%s%s\n"
, errcode, su_strerror(errcode), buf[0] ? " from " : "", buf,
 info ? " by " : "", info ? info : "")) : (void)0)
     buf[0] ? " from " : "", buf,(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3419, "sres: network error %u (%s)%s%s%s%s\n"
, errcode, su_strerror(errcode), buf[0] ? " from " : "", buf,
 info ? " by " : "", info ? info : "")) : (void)0)
     info ? " by " : "",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3419, "sres: network error %u (%s)%s%s%s%s\n"
, errcode, su_strerror(errcode), buf[0] ? " from " : "", buf,
 info ? " by " : "", info ? info : "")) : (void)0)
     info ? info : ""))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3419, "sres: network error %u (%s)%s%s%s%s\n"
, errcode, su_strerror(errcode), buf[0] ? " from " : "", buf,
 info ? " by " : "", info ? info : "")) : (void)0);

if (res->res_queries->qt_used) {
  /* Report error to queries */
  sres_server_t *dns;
  sres_query_t *q;
  size_t i;

  dns = sres_server_by_socket(res, socket);

  if (dns) {
    time(&res->res_now);
    dns->dns_icmp = res->res_now;

    for (i = 0; i < res->res_queries->qt_size; i++) {
q = res->res_queries->qt_table[i];

if (!q || dns != res->res_servers[q->q_i_server])
 continue;

/* Resend query/report error to application */
sres_resend_dns_query(res, q, 0);

if (q != res->res_queries->qt_table[i])
 i--;
    }
  }
}

return 1;
3449}


3452/** Receive a response packet from socket. */
3453int
3454sres_resolver_receive(sres_resolver_t *res, int socket)
3455{
ssize_t num_bytes;
int error;
sres_message_t m[1];

sres_query_t *query = NULL((void*)0);
sres_record_t **reply;
sres_server_t *dns;

struct sockaddr_storage from[1] = {{0}};
socklen_t fromlen = sizeof from;

SU_DEBUG_9(("%s(%p, %u) called\n", "sres_resolver_receive",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3468, "%s(%p, %u) called\n", "sres_resolver_receive"
, (void *)res, socket)) : (void)0)
     (void *)res, socket))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3468, "%s(%p, %u) called\n", "sres_resolver_receive"
, (void *)res, socket)) : (void)0);

memset(m, 0, offsetof(sres_message_t, m_data)__builtin_offsetof(sres_message_t, m_packet.mp_data));

num_bytes = sres_recvfrom(socket, m->m_data, sizeof (m->m_data), 0,recvfrom((socket),(m->m_packet.mp_data),(sizeof (m->m_packet
.mp_data)),(0),((void *)from),(&fromlen))
	    (void *)from, &fromlen)recvfrom((socket),(m->m_packet.mp_data),(sizeof (m->m_packet
.mp_data)),(0),((void *)from),(&fromlen));

if (num_bytes <= 0) {
  SU_DEBUG_5(("%s: %s\n", "sres_resolver_receive", su_strerror(su_errno())))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3476, "%s: %s\n", "sres_resolver_receive"
, su_strerror(su_errno()))) : (void)0);
  return 0;
}

if (num_bytes > 65535)
  num_bytes = 65535;

dns = sres_server_by_socket(res, socket);
if (!dns)
  return 0;

m->m_size = (uint16_t)num_bytes;

/* Decode the received message and get the matching query object */
error = sres_decode_msg(res, m, &query, &reply);

sres_log_response(res, m, from, query, reply);

if (query == NULL((void*)0))
  ;
else if (error == SRES_EDNS0_ERR) {
  dns->dns_edns = edns_not_supported;
  assert(query->q_id)((void) sizeof ((query->q_id) ? 1 : 0), __extension__ ({ if
 (query->q_id) ; else __assert_fail ("query->q_id", "sres.c"
, 3498, __extension__ __PRETTY_FUNCTION__); }));
  sres_remove_query(res, query, 0);
  sres_gen_id(res, query);
  sres_qtable_append(res->res_queries, query);
  sres_send_dns_query(res, query);
  query->q_retry_count++;
}
else if (!error && reply) {
  /* Remove the query from the pending list */
  sres_remove_query(res, query, 1);

  /* Resolve the CNAME alias, if necessary */
  if (query->q_type != sres_type_cname && query->q_type != sres_qtype_any &&
      reply[0] && reply[0]->sr_typesr_record->r_type == sres_type_cname) {
    const char *alias = reply[0]->sr_cname[0].cn_cname;
    sres_record_t **cached = NULL((void*)0);

    /* Check for the aliased results in the cache */
    if (sres_cache_get(res->res_cache, query->q_type, alias, &cached)
        > 0) {
      reply = cached;
    }
    else {
      /* Submit a query with the aliased name, dropping this result */
      sres_resolve_cname(res, query, alias);
      return 1;
    }
  }

  /* Notify the listener */
  if (query->q_callback != NULL((void*)0))
    (query->q_callback)(query->q_context, query, reply);

  sres_free_query(res, query);
}
else {
  sres_query_report_error(query, reply);
}

return 1;
3538}

3540static
3541void sres_log_response(sres_resolver_t const *res,
       sres_message_t const *m,
       struct sockaddr_storage const *from,
       sres_query_t const *query,
       sres_record_t * const *reply)
3546{
if (SU_LOGsresolv_log->log_level >= 5) {
3548#ifndef ADDRSIZE48
3549#define ADDRSIZE48 48
3550#endif
  char host[ADDRSIZE48] = "*";
  uint16_t port = 0;

  if (from == NULL((void*)0))
    ;
  else if (from->ss_family == AF_INET2) {
    struct sockaddr_in sin;
    memcpy(&sin, from, sizeof sin);
    su_inet_ntopinet_ntop(AF_INET2, &sin.sin_addr, host, sizeof host);
    port = sin.sin_port;
  }
3562#if HAVE_SIN61
  else if (from->ss_family == AF_INET610) {
    struct sockaddr_in6 sin6;
    memcpy(&sin6, from, sizeof sin6);
    su_inet_ntopinet_ntop(AF_INET610, &sin6.sin6_addr, host, sizeof host);
    port = sin6.sin6_port;
  }
3569#endif

  SU_DEBUG_5(("sres_resolver_receive(%p, %p) id=%u (from [%s]:%u)\n",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3573, "sres_resolver_receive(%p, %p) id=%u (from [%s]:%u)\n"
, (void *)res, (void *)query, m->m_packet.mp_header.mh_id,
 host, ntohs(port))) : (void)0)
(void *)res, (void *)query, m->m_id,(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3573, "sres_resolver_receive(%p, %p) id=%u (from [%s]:%u)\n"
, (void *)res, (void *)query, m->m_packet.mp_header.mh_id,
 host, ntohs(port))) : (void)0)
host, ntohs(port)))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3573, "sres_resolver_receive(%p, %p) id=%u (from [%s]:%u)\n"
, (void *)res, (void *)query, m->m_packet.mp_header.mh_id,
 host, ntohs(port))) : (void)0);
}
3575}

3577/** Decode DNS message.
*
*
* @retval 0 if successful
* @retval >0 if message indicated error
* @retval -1 if decoding error
*/
3584static
3585int
3586sres_decode_msg(sres_resolver_t *res,
sres_message_t *m,
sres_query_t **qq,
sres_record_t ***return_answers)
3590{
sres_record_t *rr = NULL((void*)0), **answers = NULL((void*)0), *error = NULL((void*)0);
sres_query_t *query = NULL((void*)0), **hq;
su_home_t *chome;
hash_value_t hash;
int err;
unsigned i, total, errorcount = 0;

assert(res && m && return_answers)((void) sizeof ((res && m && return_answers) ?
: 0), __extension__ ({ if (res && m && return_answers
) ; else __assert_fail ("res && m && return_answers"
, "sres.c", 3598, __extension__ __PRETTY_FUNCTION__); }));

time(&res->res_now);
chome = CHOME(res->res_cache)((su_home_t *)(res->res_cache));

*qq = NULL((void*)0);
*return_answers = NULL((void*)0);

m->m_offset = sizeof(m->m_packet.mp_header);

if (m->m_size < m->m_offset) {
1
Assuming the condition is false→
2
←
Taking false branch→
  SU_DEBUG_5(("sres_decode_msg: truncated message\n" VA_NONE))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3609, "sres_decode_msg: truncated message\n"
 "%s", "")) : (void)0);
  return -1;
}

m->m_flagsm_packet.mp_header.mh_flags   = ntohs(m->m_flagsm_packet.mp_header.mh_flags);
m->m_qdcountm_packet.mp_header.mh_qdcount = ntohs(m->m_qdcountm_packet.mp_header.mh_qdcount);
m->m_ancountm_packet.mp_header.mh_ancount = ntohs(m->m_ancountm_packet.mp_header.mh_ancount);
m->m_nscountm_packet.mp_header.mh_nscount = ntohs(m->m_nscountm_packet.mp_header.mh_nscount);
m->m_arcountm_packet.mp_header.mh_arcount = ntohs(m->m_arcountm_packet.mp_header.mh_arcount);

hash = Q_PRIME3571 * m->m_idm_packet.mp_header.mh_id;

/* Search for query with this ID */
for (hq = sres_qtable_hash(res->res_queries, hash);
3
←
Loop condition is false. Execution continues on line 3628→
     *hq;
     hq = sres_qtable_next(res->res_queries, hq))
  if (hash == (*hq)->q_hash)
    break;

*qq = query = *hq;

if (!query) {
4
←
Assuming 'query' is non-null→
5
←
Taking false branch→
  SU_DEBUG_5(("sres_decode_msg: matching query for id=%u\n", m->m_id))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3631, "sres_decode_msg: matching query for id=%u\n"
, m->m_packet.mp_header.mh_id)) : (void)0);
  return -1;
}

assert(query && m->m_id == query->q_id)((void) sizeof ((query && m->m_packet.mp_header.mh_id
 == query->q_id) ? 1 : 0), __extension__ ({ if (query &&
 m->m_packet.mp_header.mh_id == query->q_id) ; else __assert_fail
 ("query && m->m_id == query->q_id", "sres.c", 3635
, __extension__ __PRETTY_FUNCTION__); }));

if ((m->m_flagsm_packet.mp_header.mh_flags & 15) == SRES_FORMAT_ERR && query->q_edns)
6
←
Assuming the condition is false→
  return SRES_EDNS0_ERR;

/* Scan question section.
 * XXX: never mind the useless result values, this is done
 * for the side effects in m */
for (i = 0; i < m->m_qdcountm_packet.mp_header.mh_qdcount; i++) {
7
←
Assuming the condition is false→
8
←
Loop condition is false. Execution continues on line 3655→
  char name[1024];
  uint16_t qtype, qclass;
  m_get_domain(name, sizeof(name), m, 0); /* Query domain */
  qtype = m_get_uint16(m);  /* Query type */
  qclass = m_get_uint16(m); /* Query class */
  if (qtype && qclass) {
    /* XXX: never mind these useless check, this is done to make compiler happy about unused value */
  }

}

if (m->m_error) {
9
←
Assuming the condition is false→
10
←
Taking false branch→
  SU_DEBUG_5(("sres_decode_msg: %s\n", m->m_error))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3656, "sres_decode_msg: %s\n", m->
m_error)) : (void)0);
  return -1;
}

err = m->m_flagsm_packet.mp_header.mh_flags & SRES_HDR_RCODE;

if (m->m_ancountm_packet.mp_header.mh_ancount == 0 && err == 0)
11
←
Assuming the condition is false→
  err = SRES_RECORD_ERR;

if (err == SRES_RECORD_ERR ||
14
←
Taking false branch→
    err == SRES_NAME_ERR ||
12
←
Assuming 'err' is not equal to SRES_NAME_ERR→
    err == SRES_UNIMPL_ERR)
13
←
Assuming 'err' is not equal to SRES_UNIMPL_ERR→
  errorcount = 1;

total = errorcount + m->m_ancountm_packet.mp_header.mh_ancount + m->m_nscountm_packet.mp_header.mh_nscount + m->m_arcountm_packet.mp_header.mh_arcount;

answers = su_zalloc(chome, (total + 2) * sizeof answers[0]);
if (!answers)
15
←
Assuming 'answers' is non-null→
16
←
Taking false branch→
  return -1;

/* Scan resource records */
for (i = 0; i < total; i++) {
17
←
Assuming 'i' is < 'total'→
18
←
Loop condition is true.  Entering loop body→
  if (i < errorcount)
19
←
Taking false branch→
    rr = error = sres_create_error_rr(res->res_cache, query, err);
  else
    rr = sres_create_record(res, m, i - errorcount);
20
←
Calling 'sres_create_record'→

  if (!rr) {
    SU_DEBUG_5(("sres_create_record: %s\n", m->m_error))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3684, "sres_create_record: %s\n", m
->m_error)) : (void)0);
    break;
  }

  if (error && rr->sr_typesr_record->r_type == sres_type_soa) {
    sres_soa_record_t *soa = (sres_soa_record_t *)rr;
    if (error->sr_ttlsr_record->r_ttl > soa->soa_minimum && soa->soa_minimum > 10)
 error->sr_ttlsr_record->r_ttl = soa->soa_minimum;
  }

  answers[i] = rr;
}

if (i < total) {
  SU_DEBUG_5(("sres_decode_msg: got %u but expected "(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3700, "sres_decode_msg: got %u but expected "
 "errors=%u an=%u ar=%u ns=%u\n", i, errorcount, m->m_packet
.mp_header.mh_ancount, m->m_packet.mp_header.mh_arcount, m
->m_packet.mp_header.mh_nscount)) : (void)0)
"errors=%u an=%u ar=%u ns=%u\n", i, errorcount,(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3700, "sres_decode_msg: got %u but expected "
 "errors=%u an=%u ar=%u ns=%u\n", i, errorcount, m->m_packet
.mp_header.mh_ancount, m->m_packet.mp_header.mh_arcount, m
->m_packet.mp_header.mh_nscount)) : (void)0)
m->m_ancount, m->m_arcount, m->m_nscount))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3700, "sres_decode_msg: got %u but expected "
 "errors=%u an=%u ar=%u ns=%u\n", i, errorcount, m->m_packet
.mp_header.mh_ancount, m->m_packet.mp_header.mh_arcount, m
->m_packet.mp_header.mh_nscount)) : (void)0);
  for (i = 0; i < total; i++)
    sres_cache_free_record(res->res_cache, answers[i]);
  su_free(chome, answers);
  return -1;
}

if (m->m_ancountm_packet.mp_header.mh_ancount > 0 && errorcount == 0 && query->q_type < sres_qtype_tsig
    && (query->q_callback == sres_resolving_cname ||
 answers[0]->sr_typesr_record->r_type != sres_type_cname)) {

  for (i = 0; i < m->m_ancountm_packet.mp_header.mh_ancount; i++) {
    if (query->q_type == answers[i]->sr_typesr_record->r_type)
break;
  }

  if (i == m->m_ancountm_packet.mp_header.mh_ancount) {
    char b0[8], b1[8];
    /* The queried request was not found */
    SU_DEBUG_5(("sres_decode_msg: sent query %s, got %s\n",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3721, "sres_decode_msg: sent query %s, got %s\n"
, sres_record_type(query->q_type, b0), sres_record_type(answers
[0]->sr_record->r_type, b1))) : (void)0)
  sres_record_type(query->q_type, b0),(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3721, "sres_decode_msg: sent query %s, got %s\n"
, sres_record_type(query->q_type, b0), sres_record_type(answers
[0]->sr_record->r_type, b1))) : (void)0)
  sres_record_type(answers[0]->sr_type, b1)))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3721, "sres_decode_msg: sent query %s, got %s\n"
, sres_record_type(query->q_type, b0), sres_record_type(answers
[0]->sr_record->r_type, b1))) : (void)0);
    rr = sres_create_error_rr(res->res_cache, query, err = SRES_RECORD_ERR);
    memmove(answers + 1, answers, (sizeof answers[0]) * total++);
    answers[0] = rr;
    errorcount = 1;
  }
}

for (i = 0; i < total; i++) {
  rr = answers[i];

  if (i < m->m_ancountm_packet.mp_header.mh_ancount + errorcount)
    /* Increase reference count of entry passed in answers */
    rr->sr_refcountsr_record->r_refcount++;
  else
    /* Do not pass extra records to user */
    answers[i] = NULL((void*)0);

  sres_cache_store(res->res_cache, rr, res->res_now);
}

*return_answers = answers;

return err;
3745}

3747static
3748sres_record_t *
3749sres_create_record(sres_resolver_t *res, sres_message_t *m, int nth)
3750{
sres_cache_t *cache = res->res_cache;
sres_record_t *sr, sr0[1];

uint16_t m_size;
char name[1025];
unsigned len;
char btype[8], bclass[8];

sr = memset(sr0, 0, sizeof sr0);

len = m_get_domain(sr->sr_namesr_record->r_name = name, sizeof(name) - 1, m, 0); /* Name */
sr->sr_typesr_record->r_type = m_get_uint16(m);  /* Type */
sr->sr_classsr_record->r_class = m_get_uint16(m); /* Class */
sr->sr_ttlsr_record->r_ttl = m_get_uint32(m);   /* TTL */
sr->sr_rdlensr_record->r_rdlen = m_get_uint16(m); /* rdlength */
sr->sr_parsedsr_record->r_parsed = 1;
if (m->m_error)
21
←
Taking false branch→
  goto error;
if (len >= (sizeof name)) {
22
←
Taking false branch→
  m->m_error = "too long domain name in record";
  goto error;
}
name[len] = 0;

SU_DEBUG_9(("%s RR received %s %s %s %d rdlen=%d\n",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3782, "%s RR received %s %s %s %d rdlen=%d\n"
, nth < m->m_packet.mp_header.mh_ancount ? "ANSWER" : nth
 < m->m_packet.mp_header.mh_ancount + m->m_packet.mp_header
.mh_nscount ? "AUTHORITY" : "ADDITIONAL", name, sres_record_type
(sr->sr_record->r_type, btype), sres_record_class(sr->
sr_record->r_class, bclass), sr->sr_record->r_ttl, sr
->sr_record->r_rdlen)) : (void)0)
     nth < m->m_ancount ? "ANSWER" :(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3782, "%s RR received %s %s %s %d rdlen=%d\n"
, nth < m->m_packet.mp_header.mh_ancount ? "ANSWER" : nth
 < m->m_packet.mp_header.mh_ancount + m->m_packet.mp_header
.mh_nscount ? "AUTHORITY" : "ADDITIONAL", name, sres_record_type
(sr->sr_record->r_type, btype), sres_record_class(sr->
sr_record->r_class, bclass), sr->sr_record->r_ttl, sr
->sr_record->r_rdlen)) : (void)0)
     nth < m->m_ancount + m->m_nscount ? "AUTHORITY" :(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3782, "%s RR received %s %s %s %d rdlen=%d\n"
, nth < m->m_packet.mp_header.mh_ancount ? "ANSWER" : nth
 < m->m_packet.mp_header.mh_ancount + m->m_packet.mp_header
.mh_nscount ? "AUTHORITY" : "ADDITIONAL", name, sres_record_type
(sr->sr_record->r_type, btype), sres_record_class(sr->
sr_record->r_class, bclass), sr->sr_record->r_ttl, sr
->sr_record->r_rdlen)) : (void)0)
     "ADDITIONAL",(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3782, "%s RR received %s %s %s %d rdlen=%d\n"
, nth < m->m_packet.mp_header.mh_ancount ? "ANSWER" : nth
 < m->m_packet.mp_header.mh_ancount + m->m_packet.mp_header
.mh_nscount ? "AUTHORITY" : "ADDITIONAL", name, sres_record_type
(sr->sr_record->r_type, btype), sres_record_class(sr->
sr_record->r_class, bclass), sr->sr_record->r_ttl, sr
->sr_record->r_rdlen)) : (void)0)
     name,(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3782, "%s RR received %s %s %s %d rdlen=%d\n"
, nth < m->m_packet.mp_header.mh_ancount ? "ANSWER" : nth
 < m->m_packet.mp_header.mh_ancount + m->m_packet.mp_header
.mh_nscount ? "AUTHORITY" : "ADDITIONAL", name, sres_record_type
(sr->sr_record->r_type, btype), sres_record_class(sr->
sr_record->r_class, bclass), sr->sr_record->r_ttl, sr
->sr_record->r_rdlen)) : (void)0)
     sres_record_type(sr->sr_type, btype),(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3782, "%s RR received %s %s %s %d rdlen=%d\n"
, nth < m->m_packet.mp_header.mh_ancount ? "ANSWER" : nth
 < m->m_packet.mp_header.mh_ancount + m->m_packet.mp_header
.mh_nscount ? "AUTHORITY" : "ADDITIONAL", name, sres_record_type
(sr->sr_record->r_type, btype), sres_record_class(sr->
sr_record->r_class, bclass), sr->sr_record->r_ttl, sr
->sr_record->r_rdlen)) : (void)0)
     sres_record_class(sr->sr_class, bclass),(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3782, "%s RR received %s %s %s %d rdlen=%d\n"
, nth < m->m_packet.mp_header.mh_ancount ? "ANSWER" : nth
 < m->m_packet.mp_header.mh_ancount + m->m_packet.mp_header
.mh_nscount ? "AUTHORITY" : "ADDITIONAL", name, sres_record_type
(sr->sr_record->r_type, btype), sres_record_class(sr->
sr_record->r_class, bclass), sr->sr_record->r_ttl, sr
->sr_record->r_rdlen)) : (void)0)
     sr->sr_ttl, sr->sr_rdlen))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 9 ? (_su_llog(sresolv_log, 9, "sres.c"
, (const char *)__func__, 3782, "%s RR received %s %s %s %d rdlen=%d\n"
, nth < m->m_packet.mp_header.mh_ancount ? "ANSWER" : nth
 < m->m_packet.mp_header.mh_ancount + m->m_packet.mp_header
.mh_nscount ? "AUTHORITY" : "ADDITIONAL", name, sres_record_type
(sr->sr_record->r_type, btype), sres_record_class(sr->
sr_record->r_class, bclass), sr->sr_record->r_ttl, sr
->sr_record->r_rdlen)) : (void)0);

if (m->m_offset + sr->sr_rdlensr_record->r_rdlen > m->m_size) {
23
←
Assuming the condition is false→
24
←
Taking false branch→
  m->m_error = "truncated message";
  goto error;
}

m_size = m->m_size;
/* limit m_size to indicated rdlen, check whether record is truncated */
m->m_size = m->m_offset + sr->sr_rdlensr_record->r_rdlen;

switch (sr->sr_typesr_record->r_type) {
25
←
Control jumps to 'case sres_type_aaaa:'  at line 3803→
case sres_type_soa:
  sr = sres_init_rr_soa(cache, sr->sr_soa, m);
  break;
case sres_type_a:
  sr = sres_init_rr_a(cache, sr->sr_a, m);
  break;
case sres_type_a6:
  sr = sres_init_rr_a6(cache, sr->sr_a6, m);
  break;
case sres_type_aaaa:
  sr = sres_init_rr_aaaa(cache, sr->sr_aaaa, m);
  break;
26
←
 Execution continues on line 3823→
case sres_type_cname:
  sr = sres_init_rr_cname(cache, sr->sr_cname, m);
  break;
case sres_type_ptr:
  sr = sres_init_rr_ptr(cache, sr->sr_ptr, m);
  break;
case sres_type_srv:
  sr = sres_init_rr_srv(cache, sr->sr_srv, m);
  break;
case sres_type_naptr:
  sr = sres_init_rr_naptr(cache, sr->sr_naptr, m);
  break;
default:
  sr = sres_init_rr_unknown(cache, sr->sr_record, m);
  break;
}

if (m->m_error)
27
←
Taking false branch→
  goto error;

if (sr == sr0)
28
←
Taking false branch→
  sr = sres_cache_alloc_record(cache, sr, 0);

if (sr == NULL((void*)0)) {
29
←
Taking false branch→
  m->m_error = "memory exhausted";
  goto error;
}

/* Fill in the common fields */
m->m_size = m_size;

return sr;
30
←
Address of stack memory associated with local variable 'sr0' returned to caller

error:
if (sr && sr != sr0)
  sres_cache_free_record(cache, sr);
SU_DEBUG_5(("%s: %s\n", "sres_create_record", m->m_error))(((sresolv_log != ((void*)0) && sresolv_log->log_init
) == 0 ? 9 : ((sresolv_log != ((void*)0) && sresolv_log
->log_init > 1) ? sresolv_log->log_level : su_log_default
->log_level)) >= 5 ? (_su_llog(sresolv_log, 5, "sres.c"
, (const char *)__func__, 3842, "%s: %s\n", "sres_create_record"
, m->m_error)) : (void)0);
return NULL((void*)0);
3844}

3846/** Decode SOA record */
3847static sres_record_t *sres_init_rr_soa(sres_cache_t *cache,
		       sres_soa_record_t *soa,
		       sres_message_t *m)
3850{
uint16_t moffset, roffset;
unsigned mnamelen, rnamelen;

soa->soa_record->r_size = sizeof *soa;

moffset = m->m_offset, mnamelen = m_get_domain(NULL((void*)0), 0, m, 0) + 1;
roffset = m->m_offset, rnamelen = m_get_domain(NULL((void*)0), 0, m, 0) + 1;

soa->soa_serial = m_get_uint32(m);
soa->soa_refresh = m_get_uint32(m);
soa->soa_retry = m_get_uint32(m);
soa->soa_expire = m_get_uint32(m);
soa->soa_minimum = m_get_uint32(m);

if (m->m_error)
  return NULL((void*)0);

soa = (void *)sres_cache_alloc_record(cache, (void *)soa,
			mnamelen + rnamelen);

if (soa) {
  char *mname, *rname;

  assert(moffset > 0 && roffset > 0 && mnamelen > 1 && rnamelen > 1)((void) sizeof ((moffset > 0 && roffset > 0 &&
 mnamelen > 1 && rnamelen > 1) ? 1 : 0), __extension__
 ({ if (moffset > 0 && roffset > 0 && mnamelen
 > 1 && rnamelen > 1) ; else __assert_fail ("moffset > 0 && roffset > 0 && mnamelen > 1 && rnamelen > 1"
, "sres.c", 3874, __extension__ __PRETTY_FUNCTION__); }));

  m_get_domain(mname = (char *)(soa + 1), mnamelen, m, moffset);
  soa->soa_mname = mname;

  m_get_domain(rname = mname + mnamelen, rnamelen, m, roffset);
  soa->soa_rname = rname;
}

return (sres_record_t *)soa;
3884}

3886/** Decode A record */
3887static sres_record_t *sres_init_rr_a(sres_cache_t *cache,
		     sres_a_record_t *a,
		     sres_message_t *m)
3890{
a->a_record->r_size = sizeof *a;

a->a_addr.s_addr = htonl(m_get_uint32(m));

return (sres_record_t *)a;
3896}

3898/** Decode A6 record. See @RFC2874 */
3899static sres_record_t *sres_init_rr_a6(sres_cache_t *cache,
		      sres_a6_record_t *a6,
		      sres_message_t *m)
3902{

unsigned suffixlen = 0, i;
unsigned prefixlen = 0;
uint16_t offset;

a6->a6_record->r_size = sizeof *a6;

a6->a6_prelen = m_get_uint8(m);

if (a6->a6_prelen > 128) {
  m->m_error = "Invalid prefix length in A6 record";
  return NULL((void*)0);
}

suffixlen = (128 + 7 - a6->a6_prelen) / 8;
for (i = 16 - suffixlen; i < 16; i++)
  a6->a6_suffix.u6_addr[i] = m_get_uint8(m);

if (a6->a6_prelen > 0) {
  if (suffixlen > 0)
    /* Zero pad bits */
    a6->a6_suffix.u6_addr[16 - suffixlen] &= 0xff >> (a6->a6_prelen & 7);

  offset = m->m_offset, prefixlen = m_get_domain(NULL((void*)0), 0, m, 0) + 1;

  if (m->m_error)
    return NULL((void*)0);

  a6 = (void *)sres_cache_alloc_record(cache, (void *)a6, prefixlen);
  if (a6)
    m_get_domain(a6->a6_prename = (char *)(a6 + 1), prefixlen, m, offset);
}

return (sres_record_t *)a6;
3937}

3939/** Decode AAAA record */
3940static sres_record_t *sres_init_rr_aaaa(sres_cache_t *cache,
			sres_aaaa_record_t *aaaa,
			sres_message_t *m)
3943{
aaaa->aaaa_record->r_size = sizeof *aaaa;

if (m->m_offset + sizeof(aaaa->aaaa_addr) <= m->m_size) {
  memcpy(&aaaa->aaaa_addr, m->m_datam_packet.mp_data + m->m_offset, sizeof(aaaa->aaaa_addr));
  m->m_offset += sizeof(aaaa->aaaa_addr);
}
else
  m->m_error = "truncated AAAA record";

return (sres_record_t *)aaaa;
3954}

3956/** Decode CNAME record */
3957static sres_record_t *sres_init_rr_cname(sres_cache_t *cache,
			 sres_cname_record_t *cn,
			 sres_message_t *m)
3960{
uint16_t offset;
unsigned dlen;

cn->cn_record->r_size = sizeof *cn;

offset = m->m_offset, dlen = m_get_domain(NULL((void*)0), 0, m, 0) + 1;

if (m->m_error)
  return NULL((void*)0);

cn = (void *)sres_cache_alloc_record(cache, (void *)cn, dlen);
if (cn)
  m_get_domain(cn->cn_cname = (char *)(cn + 1), dlen, m, offset);

return (sres_record_t *)cn;
3976}

3978/** Decode PTR record */
3979static sres_record_t *sres_init_rr_ptr(sres_cache_t *cache,
		       sres_ptr_record_t *ptr,
		       sres_message_t *m)
3982{
uint16_t offset;
unsigned dlen;

ptr->ptr_record->r_size = sizeof *ptr;

offset = m->m_offset, dlen = m_get_domain(NULL((void*)0), 0, m, 0) + 1;

if (m->m_error)
  return NULL((void*)0);

ptr = (void *)sres_cache_alloc_record(cache, (void *)ptr, dlen);
if (ptr)
  m_get_domain(ptr->ptr_domain = (char *)(ptr + 1), dlen, m, offset);

return (sres_record_t *)ptr;
3998}

4000/** Decode SRV record */
4001static sres_record_t *sres_init_rr_srv(sres_cache_t *cache,
		       sres_srv_record_t *srv,
		       sres_message_t *m)
4004{
uint16_t offset;
unsigned dlen;

srv->srv_record->r_size = sizeof *srv;

srv->srv_priority = m_get_uint16(m);
srv->srv_weight = m_get_uint16(m);
srv->srv_port = m_get_uint16(m);
offset = m->m_offset, dlen = m_get_domain(NULL((void*)0), 0, m, 0) + 1;
if (m->m_error)
  return NULL((void*)0);

srv = (void *)sres_cache_alloc_record(cache, (void *)srv, dlen);
if (srv)
  m_get_domain(srv->srv_target = (char *)(srv + 1), dlen, m, offset);

return (sres_record_t *)srv;
4022}

4024/** Decode NAPTR record */
4025static sres_record_t *sres_init_rr_naptr(sres_cache_t *cache,
			 sres_naptr_record_t *na,
			 sres_message_t *m)
4028{
uint16_t offset[4];
unsigned len[4];

na->na_record->r_size = sizeof *na;

na->na_order = m_get_uint16(m);
na->na_prefer = m_get_uint16(m);

offset[0] = m->m_offset, len[0] = m_get_string(NULL((void*)0), 0, m, 0) + 1;
offset[1] = m->m_offset, len[1] = m_get_string(NULL((void*)0), 0, m, 0) + 1;
offset[2] = m->m_offset, len[2] = m_get_string(NULL((void*)0), 0, m, 0) + 1;
offset[3] = m->m_offset, len[3] = m_get_domain(NULL((void*)0), 0, m, 0) + 1;

if (m->m_error)
  return NULL((void*)0);

na = (void *)sres_cache_alloc_record(cache, (void *)na,
		       len[0] + len[1] + len[2] + len[3]);
if (na) {
  char *s = (char *)(na + 1);
  m_get_string(na->na_flags = s, len[0], m, offset[0]), s += len[0];
  m_get_string(na->na_services = s, len[1], m, offset[1]), s += len[1];
  m_get_string(na->na_regexp = s, len[2], m, offset[2]), s += len[2];
  m_get_domain(na->na_replace = s, len[3], m, offset[3]), s += len[3];
}

return (sres_record_t *)na;
4056}

4058/** Decode unknown record */
4059static sres_record_t *sres_init_rr_unknown(sres_cache_t *cache,
			   sres_common_t *r,
			   sres_message_t *m)
4062{
if (m->m_offset + r->r_rdlen > m->m_size)
  m->m_error = "truncated record";

if (m->m_error)
  return NULL((void*)0);

r->r_size = sizeof *r;

r = (void *)sres_cache_alloc_record(cache, (void *)r, r->r_rdlen + 1);
if (r) {
  char *data = (char *)(r + 1);

  r->r_parsed = 0;

  memcpy(data, m->m_datam_packet.mp_data + m->m_offset, r->r_rdlen);
  m->m_offset += r->r_rdlen;
  data[r->r_rdlen] = 0;
}

return (sres_record_t *)r;
4083}

4085static
4086sres_record_t *sres_create_error_rr(sres_cache_t *cache,
		    sres_query_t const *q,
		    uint16_t errcode)
4089{
sres_record_t *sr, r[1];
char buf[SRES_MAXDNAME(SRES_MAXDNAME)];

sr = memset(r, 0, sizeof *sr);

sr->sr_namesr_record->r_name = (char *)sres_toplevel(buf, sizeof buf, q->q_name);
sr->sr_sizesr_record->r_size = sizeof *sr;
sr->sr_statussr_record->r_status = errcode;
sr->sr_typesr_record->r_type = q->q_type;
sr->sr_classsr_record->r_class = q->q_class;
sr->sr_ttlsr_record->r_ttl = 10 * 60;

return sres_cache_alloc_record(cache, sr, 0);
4103}

4105/* Message processing primitives */

4107static
4108void
4109m_put_uint16(sres_message_t *m,
    uint16_t h)
4111{
uint8_t *p;

if (m->m_error)
  return;

p = m->m_datam_packet.mp_data + m->m_offset;
m->m_offset += sizeof h;

if (m->m_offset > m->m_size) {
  m->m_error = "message size overflow";
  return;
}

p[0] = h >> 8; p[1] = h;
4126}

4128static
4129void
4130m_put_uint32(sres_message_t *m,
    uint32_t w)
4132{
uint8_t *p;

if (m->m_error)
  return;

p = m->m_datam_packet.mp_data + m->m_offset;
m->m_offset += sizeof w;

if (m->m_offset > m->m_size) {
  m->m_error = "message size overflow";
  return;
}

p[0] = w >> 24; p[1] = w >> 16; p[2] = w >> 8; p[3] = w;
4147}

4149/*
* Put domain into query
*/
4152static
4153uint16_t
4154m_put_domain(sres_message_t *m,
    char const *domain,
    uint16_t top,
    char const *topdomain)
4158{
char const *label;
size_t llen;

if (m->m_error)
  return top;

/* Copy domain into query label at a time */
for (label = domain; label && label[0]; label += llen) {
  if (label[0] == '.' && label[1] != '\0') {
    m->m_error = "empty label";
    return 0;
  }

  llen = strcspn(label, ".");

  if (llen >= 64) {
    m->m_error = "too long label";
    return 0;
  }
  if (m->m_offset + llen + 1 > m->m_size) {
    m->m_error = "message size overflow";
    return 0;
  }

  m->m_datam_packet.mp_data[m->m_offset++] = (uint8_t)llen;
  memcpy(m->m_datam_packet.mp_data + m->m_offset, label, llen);
  m->m_offset += (uint8_t)llen;

  if (label[llen] == '\0')
    break;
  if (llen == 0)
    return top;
  if (label[llen + 1])
    llen++;
}

if (top) {
  m_put_uint16(m, 0xc000 | top);
  return top;
}
else if (topdomain) {
  uint16_t retval = m->m_offset;
  m_put_domain(m, topdomain, 0, NULL((void*)0));
  return retval;
}
else if (m->m_offset < m->m_size)
  m->m_datam_packet.mp_data[m->m_offset++] = '\0';
else
  m->m_error = "message size overflow";

return 0;
4210}

4212static
4213uint32_t
4214m_get_uint32(sres_message_t *m)
4215{
uint8_t const *p = m->m_datam_packet.mp_data + m->m_offset;

if (m->m_error)
  return 0;

m->m_offset += 4;

if (m->m_offset > m->m_size) {
  m->m_error = "truncated message";
  return 0;
}

return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
4229}

4231static
4232uint16_t
4233m_get_uint16(sres_message_t *m)
4234{
uint8_t const *p = m->m_datam_packet.mp_data + m->m_offset;

if (m->m_error)
  return 0;

m->m_offset += 2;

if (m->m_offset > m->m_size) {
  m->m_error = "truncated message";
  return 0;
}

return (p[0] << 8) | p[1];
4248}

4250static
4251uint8_t
4252m_get_uint8(sres_message_t *m)
4253{
uint8_t const *p = m->m_datam_packet.mp_data + m->m_offset;

if (m->m_error)
  return 0;

m->m_offset += 1;

if (m->m_offset > m->m_size) {
  m->m_error = "truncated message";
  return 0;
}

return p[0];
4267}

4269/**
* Get a string.
*/
4272static unsigned
4273m_get_string(char *d,
    unsigned n,
    sres_message_t *m,
    uint16_t offset)
4277{
uint8_t size;
uint8_t *p = m->m_datam_packet.mp_data;
int save_offset;

if (m->m_error)
  return 0;

if (offset == 0)
  offset = m->m_offset, save_offset = 1;
else
  save_offset = 0;

size = p[offset++];

if (size + offset >= m->m_size) {
  m->m_error = "truncated message";
  return size;
}

offset += size;

if (save_offset)
  m->m_offset = offset;

if (n == 0 || d == NULL((void*)0))
  return size;		/* Just return the size (without NUL). */

memcpy(d, p + offset - size, size < n ? size : n);

if (size < n)
  d[size] = '\0';		/* NUL terminate */

return size;
4311}

4313/**
* Uncompress a domain.
*
* @param offset start uncompression from this point in message
*/
4318static unsigned
4319m_get_domain(char *d,
    unsigned n,
    sres_message_t *m,
    uint16_t offset)
4323{
uint8_t cnt;
unsigned i = 0;
uint8_t *p = m->m_datam_packet.mp_data;
uint16_t new_offset;
int save_offset;

if (m->m_error)
  return 0;

if (d == NULL((void*)0))
  n = 0;

if (offset == 0)
  offset = m->m_offset, save_offset = 1;
else
  save_offset = 0;

while ((cnt = p[offset++])) {
  if (cnt >= 0xc0) {
    if (offset >= m->m_size) {
      m->m_error = "truncated message";
      return 0;
    }

    new_offset = ((cnt & 0x3F) << 8) + p[offset++];

    if (save_offset)
      m->m_offset = offset;

    if (new_offset <= 0 || new_offset >= m->m_size) {
      m->m_error = "invalid domain compression";
      return 0;
    }

    offset = new_offset;
    save_offset = 0;
  }
  else {
    if (offset + cnt >= m->m_size) {
      m->m_error = "truncated message";
      return 0;
    }
    if (i + cnt + 1 < n) {
      memcpy(d + i, p + offset, cnt);
      d[i + cnt] = '.';
    }

    i += cnt + 1;
    offset += cnt;
  }
}

if (i == 0) {
  if (i < n)
    d[i] = '.';
  i++;
}

if (i < n)
  d[i] = '\0';

if (save_offset)
  m->m_offset = offset;

return i;
4389}