/usr/src/sbin/unwind/resolver.c

Bug Summary

File:	src/sbin/unwind/resolver.c
Warning:	line 1600, column 18 The left operand of '==' is a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name resolver.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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 -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sbin/unwind/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/sbin/unwind -I /usr/src/sbin/unwind -I /usr/src/sbin/unwind/libunbound/libunbound -I /usr/src/sbin/unwind/libunbound -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/sbin/unwind/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/sbin/unwind/resolver.c
1/*	$OpenBSD: resolver.c,v 1.154 2021/12/18 10:34:19 florian Exp $	*/


4/*
* Copyright (c) 2018 Florian Obser <florian@openbsd.org>
* Copyright (c) 2004, 2005 Claudio Jeker <claudio@openbsd.org>
* Copyright (c) 2004 Esben Norby <norby@openbsd.org>
* Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

23#include <sys/types.h>
24#include <sys/queue.h>
25#include <sys/socket.h>
26#include <sys/syslog.h>
27#include <sys/time.h>

29#include <net/route.h>

31#include <errno(*__errno()).h>
32#include <event.h>
33#include <imsg.h>
34#include <limits.h>
35#include <netdb.h>
36#include <asr.h>
37#include <pwd.h>
38#include <signal.h>
39#include <stdio.h>
40#include <stdlib.h>
41#include <string.h>
42#include <time.h>
43#include <tls.h>
44#include <unistd.h>

46#include "libunbound/config.h"
47#include "libunbound/libunbound/context.h"
48#include "libunbound/libunbound/libworker.h"
49#include "libunbound/libunbound/unbound.h"
50#include "libunbound/libunbound/unbound-event.h"
51#include "libunbound/services/cache/rrset.h"
52#include "libunbound/sldns/sbuffer.h"
53#include "libunbound/sldns/rrdef.h"
54#include "libunbound/sldns/pkthdr.h"
55#include "libunbound/sldns/wire2str.h"
56#include "libunbound/util/config_file.h"
57#include "libunbound/util/module.h"
58#include "libunbound/util/regional.h"
59#include "libunbound/util/storage/slabhash.h"
60#include "libunbound/validator/validator.h"
61#include "libunbound/validator/val_kcache.h"
62#include "libunbound/validator/val_neg.h"

64#include <openssl/crypto.h>

66#include "log.h"
67#include "frontend.h"
68#include "unwind.h"
69#include "resolver.h"

71#define	TLS_DEFAULT_CA_CERT_FILE"/etc/ssl/cert.pem"	"/etc/ssl/cert.pem"
72#define	UB_LOG_VERBOSE4			4
73#define	UB_LOG_BRIEF0			0

75/* maximum size of a libunbound forwarder definition: IP@PORT#AUTHNAME */
76#define	FWD_MAX(46 + 256 + 2 + 5)				(INET6_ADDRSTRLEN46 + NI_MAXHOST256 + 2 + 5)

78/*
* The prefered resolver type can be this many ms slower than the next
* best and still be picked
*/
82#define	PREF_RESOLVER_MEDIAN_SKEW200	200		/* 200 ms */
83#define	NEXT_RES_MAX2000			2000		/* 2000 ms */

85#define	DOUBT_NXDOMAIN_SEC(5 * 60)		(5 * 60)	/* 5 minutes */

87#define	RESOLVER_CHECK_SEC1		1
88#define	RESOLVER_CHECK_MAXSEC1024		1024 /* ~17 minutes */
89#define	DECAY_PERIOD60			60
90#define	DECAY_NOMINATOR9			9
91#define	DECAY_DENOMINATOR10		10

93#define	TRUST_ANCHOR_RETRY_INTERVAL8640	8640
94#define	TRUST_ANCHOR_QUERY_INTERVAL43200	43200

96/* in libworker_event_done_cb() enum sec_status gets mapped to 0, 1 and 2 */
97#define	INSECURE0	0
98#define	BOGUS1		1
99#define	SECURE2		2

101#define	WKA1_FOUND1	1
102#define	WKA2_FOUND2	2

104struct uw_resolver {
struct event		 check_ev;
struct event		 free_ev;
struct ub_ctx		*ctx;
void			*asr_ctx;
struct timeval		 check_tv;
int			 ref_cnt;
int			 stop;
enum uw_resolver_state	 state;
enum uw_resolver_type	 type;
int			 check_running;
int64_t			 median;
int64_t			 histogram[nitems(histogram_limits)(sizeof((histogram_limits)) / sizeof((histogram_limits)[0]))];
int64_t			 latest_histogram[nitems(histogram_limits)(sizeof((histogram_limits)) / sizeof((histogram_limits)[0]))];
118};

120struct running_query {
TAILQ_ENTRY(running_query)struct { struct running_query *tqe_next; struct running_query
 **tqe_prev; }	 entry;
struct query_imsg		*query_imsg;
struct event			 timer_ev;
struct timespec			 tp;
struct resolver_preference	 res_pref;
int				 next_resolver;
int				 running;
128};

130TAILQ_HEAD(, running_query)struct { struct running_query *tqh_first; struct running_query
 **tqh_last; }	 running_queries;

132typedef void (*resolve_cb_t)(struct uw_resolver *, void *, int, void *, int,
  int, char *);

135struct resolver_cb_data {
resolve_cb_t		 cb;
void			*data;
struct uw_resolver	*res;
139};

141__dead__attribute__((__noreturn__)) void		 resolver_shutdown(void);
142void			 resolver_sig_handler(int sig, short, void *);
143void			 resolver_dispatch_frontend(int, short, void *);
144void			 resolver_dispatch_main(int, short, void *);
145int			 sort_resolver_types(struct resolver_preference *);
146void			 setup_query(struct query_imsg *);
147struct running_query	*find_running_query(uint64_t);
148void			 try_resolver_timo(int, short, void *);
149int			 try_next_resolver(struct running_query *);

151int			 resolve(struct uw_resolver *, const char*, int, int,
	     void*, resolve_cb_t);
153void			 resolve_done(struct uw_resolver *, void *, int, void *,
	     int, int, char *);
155void			 ub_resolve_done(void *, int, void *, int, int, char *,
	     int);
157void			 asr_resolve_done(struct asr_result *, void *);
158void			 new_resolver(enum uw_resolver_type,
	     enum uw_resolver_state);
160struct uw_resolver	*create_resolver(enum uw_resolver_type);
161void			 setup_unified_caches(void);
162void			 set_unified_cache(struct uw_resolver *);
163void			 free_resolver(struct uw_resolver *);
164void			 set_forwarders(struct uw_resolver *,
	     struct uw_forwarder_head *, int);
166void			 resolver_check_timo(int, short, void *);
167void			 resolver_free_timo(int, short, void *);
168void			 check_resolver(struct uw_resolver *);
169void			 check_resolver_done(struct uw_resolver *, void *, int,
	     void *, int, int, char *);
171void			 schedule_recheck_all_resolvers(void);
172int			 check_forwarders_changed(struct uw_forwarder_head *,
	     struct uw_forwarder_head *);
174void			 replace_forwarders(struct uw_forwarder_head *,
	     struct uw_forwarder_head *);
176void			 resolver_ref(struct uw_resolver *);
177void			 resolver_unref(struct uw_resolver *);
178int			 resolver_cmp(const void *, const void *);
179void			 restart_ub_resolvers(int);
180void			 show_status(pid_t);
181void			 show_autoconf(pid_t);
182void			 show_mem(pid_t);
183void			 send_resolver_info(struct uw_resolver *, pid_t);
184void			 send_detailed_resolver_info(struct uw_resolver *,
	     pid_t);
186void			 trust_anchor_resolve(void);
187void			 trust_anchor_timo(int, short, void *);
188void			 trust_anchor_resolve_done(struct uw_resolver *, void *,
	     int, void *, int, int, char *);
190void			 replace_autoconf_forwarders(struct
	     imsg_rdns_proposal *);
192int			 force_tree_cmp(struct force_tree_entry *,
	     struct force_tree_entry *);
194int			 find_force(struct force_tree *, char *,
	     struct uw_resolver **);
196int64_t			 histogram_median(int64_t *);
197void			 decay_latest_histograms(int, short, void *);
198int			 running_query_cnt(void);
199int			*resolvers_to_restart(struct uw_conf *,
	     struct uw_conf *);
201const char		*query_imsg2str(struct query_imsg *);
202char			*gen_resolv_conf(void);
203void			 check_dns64(void);
204void			 check_dns64_done(struct asr_result *, void *);
205int			 dns64_prefixlen(const struct in6_addr *,
	     const uint8_t *);
207void			 add_dns64_prefix(const struct in6_addr *, int,
	     struct dns64_prefix *, int, int);

210struct uw_conf			*resolver_conf;
211static struct imsgev		*iev_frontend;
212static struct imsgev		*iev_main;
213struct uw_forwarder_head	 autoconf_forwarder_list;
214struct uw_resolver		*resolvers[UW_RES_NONE];
215struct timespec			 last_network_change;

217struct event			 trust_anchor_timer;
218struct event			 decay_timer;

220static struct trust_anchor_head	 trust_anchors, new_trust_anchors;

222struct event_base		*ev_base;

224RB_GENERATE(force_tree, force_tree_entry, entry, force_tree_cmp)void force_tree_RB_INSERT_COLOR(struct force_tree *head, struct
 force_tree_entry *elm) { struct force_tree_entry *parent, *gparent
, *tmp; while ((parent = (elm)->entry.rbe_parent) &&
 (parent)->entry.rbe_color == 1) { gparent = (parent)->
entry.rbe_parent; if (parent == (gparent)->entry.rbe_left)
 { tmp = (gparent)->entry.rbe_right; if (tmp && (tmp
)->entry.rbe_color == 1) { (tmp)->entry.rbe_color = 0; do
 { (parent)->entry.rbe_color = 0; (gparent)->entry.rbe_color
 = 1; } while (0); elm = gparent; continue; } if ((parent)->
entry.rbe_right == elm) { do { (tmp) = (parent)->entry.rbe_right
; if (((parent)->entry.rbe_right = (tmp)->entry.rbe_left
)) { ((tmp)->entry.rbe_left)->entry.rbe_parent = (parent
); } do {} while (0); if (((tmp)->entry.rbe_parent = (parent
)->entry.rbe_parent)) { if ((parent) == ((parent)->entry
.rbe_parent)->entry.rbe_left) ((parent)->entry.rbe_parent
)->entry.rbe_left = (tmp); else ((parent)->entry.rbe_parent
)->entry.rbe_right = (tmp); } else (head)->rbh_root = (
tmp); (tmp)->entry.rbe_left = (parent); (parent)->entry
.rbe_parent = (tmp); do {} while (0); if (((tmp)->entry.rbe_parent
)) do {} while (0); } while (0); tmp = parent; parent = elm; elm
 = tmp; } do { (parent)->entry.rbe_color = 0; (gparent)->
entry.rbe_color = 1; } while (0); do { (tmp) = (gparent)->
entry.rbe_left; if (((gparent)->entry.rbe_left = (tmp)->
entry.rbe_right)) { ((tmp)->entry.rbe_right)->entry.rbe_parent
 = (gparent); } do {} while (0); if (((tmp)->entry.rbe_parent
 = (gparent)->entry.rbe_parent)) { if ((gparent) == ((gparent
)->entry.rbe_parent)->entry.rbe_left) ((gparent)->entry
.rbe_parent)->entry.rbe_left = (tmp); else ((gparent)->
entry.rbe_parent)->entry.rbe_right = (tmp); } else (head)->
rbh_root = (tmp); (tmp)->entry.rbe_right = (gparent); (gparent
)->entry.rbe_parent = (tmp); do {} while (0); if (((tmp)->
entry.rbe_parent)) do {} while (0); } while (0); } else { tmp
 = (gparent)->entry.rbe_left; if (tmp && (tmp)->
entry.rbe_color == 1) { (tmp)->entry.rbe_color = 0; do { (
parent)->entry.rbe_color = 0; (gparent)->entry.rbe_color
 = 1; } while (0); elm = gparent; continue; } if ((parent)->
entry.rbe_left == elm) { do { (tmp) = (parent)->entry.rbe_left
; if (((parent)->entry.rbe_left = (tmp)->entry.rbe_right
)) { ((tmp)->entry.rbe_right)->entry.rbe_parent = (parent
); } do {} while (0); if (((tmp)->entry.rbe_parent = (parent
)->entry.rbe_parent)) { if ((parent) == ((parent)->entry
.rbe_parent)->entry.rbe_left) ((parent)->entry.rbe_parent
)->entry.rbe_left = (tmp); else ((parent)->entry.rbe_parent
)->entry.rbe_right = (tmp); } else (head)->rbh_root = (
tmp); (tmp)->entry.rbe_right = (parent); (parent)->entry
.rbe_parent = (tmp); do {} while (0); if (((tmp)->entry.rbe_parent
)) do {} while (0); } while (0); tmp = parent; parent = elm; elm
 = tmp; } do { (parent)->entry.rbe_color = 0; (gparent)->
entry.rbe_color = 1; } while (0); do { (tmp) = (gparent)->
entry.rbe_right; if (((gparent)->entry.rbe_right = (tmp)->
entry.rbe_left)) { ((tmp)->entry.rbe_left)->entry.rbe_parent
 = (gparent); } do {} while (0); if (((tmp)->entry.rbe_parent
 = (gparent)->entry.rbe_parent)) { if ((gparent) == ((gparent
)->entry.rbe_parent)->entry.rbe_left) ((gparent)->entry
.rbe_parent)->entry.rbe_left = (tmp); else ((gparent)->
entry.rbe_parent)->entry.rbe_right = (tmp); } else (head)->
rbh_root = (tmp); (tmp)->entry.rbe_left = (gparent); (gparent
)->entry.rbe_parent = (tmp); do {} while (0); if (((tmp)->
entry.rbe_parent)) do {} while (0); } while (0); } } (head->
rbh_root)->entry.rbe_color = 0; } void force_tree_RB_REMOVE_COLOR
(struct force_tree *head, struct force_tree_entry *parent, struct
 force_tree_entry *elm) { struct force_tree_entry *tmp; while
 ((elm == ((void*)0) || (elm)->entry.rbe_color == 0) &&
 elm != (head)->rbh_root) { if ((parent)->entry.rbe_left
 == elm) { tmp = (parent)->entry.rbe_right; if ((tmp)->
entry.rbe_color == 1) { do { (tmp)->entry.rbe_color = 0; (
parent)->entry.rbe_color = 1; } while (0); do { (tmp) = (parent
)->entry.rbe_right; if (((parent)->entry.rbe_right = (tmp
)->entry.rbe_left)) { ((tmp)->entry.rbe_left)->entry
.rbe_parent = (parent); } do {} while (0); if (((tmp)->entry
.rbe_parent = (parent)->entry.rbe_parent)) { if ((parent) ==
 ((parent)->entry.rbe_parent)->entry.rbe_left) ((parent
)->entry.rbe_parent)->entry.rbe_left = (tmp); else ((parent
)->entry.rbe_parent)->entry.rbe_right = (tmp); } else (
head)->rbh_root = (tmp); (tmp)->entry.rbe_left = (parent
); (parent)->entry.rbe_parent = (tmp); do {} while (0); if
 (((tmp)->entry.rbe_parent)) do {} while (0); } while (0);
 tmp = (parent)->entry.rbe_right; } if (((tmp)->entry.rbe_left
 == ((void*)0) || ((tmp)->entry.rbe_left)->entry.rbe_color
 == 0) && ((tmp)->entry.rbe_right == ((void*)0) ||
 ((tmp)->entry.rbe_right)->entry.rbe_color == 0)) { (tmp
)->entry.rbe_color = 1; elm = parent; parent = (elm)->entry
.rbe_parent; } else { if ((tmp)->entry.rbe_right == ((void
*)0) || ((tmp)->entry.rbe_right)->entry.rbe_color == 0)
 { struct force_tree_entry *oleft; if ((oleft = (tmp)->entry
.rbe_left)) (oleft)->entry.rbe_color = 0; (tmp)->entry.
rbe_color = 1; do { (oleft) = (tmp)->entry.rbe_left; if ((
(tmp)->entry.rbe_left = (oleft)->entry.rbe_right)) { ((
oleft)->entry.rbe_right)->entry.rbe_parent = (tmp); } do
 {} while (0); if (((oleft)->entry.rbe_parent = (tmp)->
entry.rbe_parent)) { if ((tmp) == ((tmp)->entry.rbe_parent
)->entry.rbe_left) ((tmp)->entry.rbe_parent)->entry.
rbe_left = (oleft); else ((tmp)->entry.rbe_parent)->entry
.rbe_right = (oleft); } else (head)->rbh_root = (oleft); (
oleft)->entry.rbe_right = (tmp); (tmp)->entry.rbe_parent
 = (oleft); do {} while (0); if (((oleft)->entry.rbe_parent
)) do {} while (0); } while (0); tmp = (parent)->entry.rbe_right
; } (tmp)->entry.rbe_color = (parent)->entry.rbe_color;
 (parent)->entry.rbe_color = 0; if ((tmp)->entry.rbe_right
) ((tmp)->entry.rbe_right)->entry.rbe_color = 0; do { (
tmp) = (parent)->entry.rbe_right; if (((parent)->entry.
rbe_right = (tmp)->entry.rbe_left)) { ((tmp)->entry.rbe_left
)->entry.rbe_parent = (parent); } do {} while (0); if (((tmp
)->entry.rbe_parent = (parent)->entry.rbe_parent)) { if
 ((parent) == ((parent)->entry.rbe_parent)->entry.rbe_left
) ((parent)->entry.rbe_parent)->entry.rbe_left = (tmp);
 else ((parent)->entry.rbe_parent)->entry.rbe_right = (
tmp); } else (head)->rbh_root = (tmp); (tmp)->entry.rbe_left
 = (parent); (parent)->entry.rbe_parent = (tmp); do {} while
 (0); if (((tmp)->entry.rbe_parent)) do {} while (0); } while
 (0); elm = (head)->rbh_root; break; } } else { tmp = (parent
)->entry.rbe_left; if ((tmp)->entry.rbe_color == 1) { do
 { (tmp)->entry.rbe_color = 0; (parent)->entry.rbe_color
 = 1; } while (0); do { (tmp) = (parent)->entry.rbe_left; if
 (((parent)->entry.rbe_left = (tmp)->entry.rbe_right)) {
 ((tmp)->entry.rbe_right)->entry.rbe_parent = (parent);
 } do {} while (0); if (((tmp)->entry.rbe_parent = (parent
)->entry.rbe_parent)) { if ((parent) == ((parent)->entry
.rbe_parent)->entry.rbe_left) ((parent)->entry.rbe_parent
)->entry.rbe_left = (tmp); else ((parent)->entry.rbe_parent
)->entry.rbe_right = (tmp); } else (head)->rbh_root = (
tmp); (tmp)->entry.rbe_right = (parent); (parent)->entry
.rbe_parent = (tmp); do {} while (0); if (((tmp)->entry.rbe_parent
)) do {} while (0); } while (0); tmp = (parent)->entry.rbe_left
; } if (((tmp)->entry.rbe_left == ((void*)0) || ((tmp)->
entry.rbe_left)->entry.rbe_color == 0) && ((tmp)->
entry.rbe_right == ((void*)0) || ((tmp)->entry.rbe_right)->
entry.rbe_color == 0)) { (tmp)->entry.rbe_color = 1; elm =
 parent; parent = (elm)->entry.rbe_parent; } else { if ((tmp
)->entry.rbe_left == ((void*)0) || ((tmp)->entry.rbe_left
)->entry.rbe_color == 0) { struct force_tree_entry *oright
; if ((oright = (tmp)->entry.rbe_right)) (oright)->entry
.rbe_color = 0; (tmp)->entry.rbe_color = 1; do { (oright) =
 (tmp)->entry.rbe_right; if (((tmp)->entry.rbe_right = (
oright)->entry.rbe_left)) { ((oright)->entry.rbe_left)->
entry.rbe_parent = (tmp); } do {} while (0); if (((oright)->
entry.rbe_parent = (tmp)->entry.rbe_parent)) { if ((tmp) ==
 ((tmp)->entry.rbe_parent)->entry.rbe_left) ((tmp)->
entry.rbe_parent)->entry.rbe_left = (oright); else ((tmp)->
entry.rbe_parent)->entry.rbe_right = (oright); } else (head
)->rbh_root = (oright); (oright)->entry.rbe_left = (tmp
); (tmp)->entry.rbe_parent = (oright); do {} while (0); if
 (((oright)->entry.rbe_parent)) do {} while (0); } while (
0); tmp = (parent)->entry.rbe_left; } (tmp)->entry.rbe_color
 = (parent)->entry.rbe_color; (parent)->entry.rbe_color
 = 0; if ((tmp)->entry.rbe_left) ((tmp)->entry.rbe_left
)->entry.rbe_color = 0; do { (tmp) = (parent)->entry.rbe_left
; if (((parent)->entry.rbe_left = (tmp)->entry.rbe_right
)) { ((tmp)->entry.rbe_right)->entry.rbe_parent = (parent
); } do {} while (0); if (((tmp)->entry.rbe_parent = (parent
)->entry.rbe_parent)) { if ((parent) == ((parent)->entry
.rbe_parent)->entry.rbe_left) ((parent)->entry.rbe_parent
)->entry.rbe_left = (tmp); else ((parent)->entry.rbe_parent
)->entry.rbe_right = (tmp); } else (head)->rbh_root = (
tmp); (tmp)->entry.rbe_right = (parent); (parent)->entry
.rbe_parent = (tmp); do {} while (0); if (((tmp)->entry.rbe_parent
)) do {} while (0); } while (0); elm = (head)->rbh_root; break
; } } } if (elm) (elm)->entry.rbe_color = 0; } struct force_tree_entry
 * force_tree_RB_REMOVE(struct force_tree *head, struct force_tree_entry
 *elm) { struct force_tree_entry *child, *parent, *old = elm;
 int color; if ((elm)->entry.rbe_left == ((void*)0)) child
 = (elm)->entry.rbe_right; else if ((elm)->entry.rbe_right
 == ((void*)0)) child = (elm)->entry.rbe_left; else { struct
 force_tree_entry *left; elm = (elm)->entry.rbe_right; while
 ((left = (elm)->entry.rbe_left)) elm = left; child = (elm
)->entry.rbe_right; parent = (elm)->entry.rbe_parent; color
 = (elm)->entry.rbe_color; if (child) (child)->entry.rbe_parent
 = parent; if (parent) { if ((parent)->entry.rbe_left == elm
) (parent)->entry.rbe_left = child; else (parent)->entry
.rbe_right = child; do {} while (0); } else (head)->rbh_root
 = child; if ((elm)->entry.rbe_parent == old) parent = elm
; (elm)->entry = (old)->entry; if ((old)->entry.rbe_parent
) { if (((old)->entry.rbe_parent)->entry.rbe_left == old
) ((old)->entry.rbe_parent)->entry.rbe_left = elm; else
 ((old)->entry.rbe_parent)->entry.rbe_right = elm; do {
} while (0); } else (head)->rbh_root = elm; ((old)->entry
.rbe_left)->entry.rbe_parent = elm; if ((old)->entry.rbe_right
) ((old)->entry.rbe_right)->entry.rbe_parent = elm; if (
parent) { left = parent; do { do {} while (0); } while ((left
 = (left)->entry.rbe_parent)); } goto color; } parent = (elm
)->entry.rbe_parent; color = (elm)->entry.rbe_color; if
 (child) (child)->entry.rbe_parent = parent; if (parent) {
 if ((parent)->entry.rbe_left == elm) (parent)->entry.rbe_left
 = child; else (parent)->entry.rbe_right = child; do {} while
 (0); } else (head)->rbh_root = child; color: if (color ==
 0) force_tree_RB_REMOVE_COLOR(head, parent, child); return (
old); } struct force_tree_entry * force_tree_RB_INSERT(struct
 force_tree *head, struct force_tree_entry *elm) { struct force_tree_entry
 *tmp; struct force_tree_entry *parent = ((void*)0); int comp
 = 0; tmp = (head)->rbh_root; while (tmp) { parent = tmp; comp
 = (force_tree_cmp)(elm, parent); if (comp < 0) tmp = (tmp
)->entry.rbe_left; else if (comp > 0) tmp = (tmp)->entry
.rbe_right; else return (tmp); } do { (elm)->entry.rbe_parent
 = parent; (elm)->entry.rbe_left = (elm)->entry.rbe_right
 = ((void*)0); (elm)->entry.rbe_color = 1; } while (0); if
 (parent != ((void*)0)) { if (comp < 0) (parent)->entry
.rbe_left = elm; else (parent)->entry.rbe_right = elm; do {
} while (0); } else (head)->rbh_root = elm; force_tree_RB_INSERT_COLOR
(head, elm); return (((void*)0)); } struct force_tree_entry *
 force_tree_RB_FIND(struct force_tree *head, struct force_tree_entry
 *elm) { struct force_tree_entry *tmp = (head)->rbh_root; int
 comp; while (tmp) { comp = force_tree_cmp(elm, tmp); if (comp
 < 0) tmp = (tmp)->entry.rbe_left; else if (comp > 0
) tmp = (tmp)->entry.rbe_right; else return (tmp); } return
 (((void*)0)); } struct force_tree_entry * force_tree_RB_NFIND
(struct force_tree *head, struct force_tree_entry *elm) { struct
 force_tree_entry *tmp = (head)->rbh_root; struct force_tree_entry
 *res = ((void*)0); int comp; while (tmp) { comp = force_tree_cmp
(elm, tmp); if (comp < 0) { res = tmp; tmp = (tmp)->entry
.rbe_left; } else if (comp > 0) tmp = (tmp)->entry.rbe_right
; else return (tmp); } return (res); } struct force_tree_entry
 * force_tree_RB_NEXT(struct force_tree_entry *elm) { if ((elm
)->entry.rbe_right) { elm = (elm)->entry.rbe_right; while
 ((elm)->entry.rbe_left) elm = (elm)->entry.rbe_left; }
 else { if ((elm)->entry.rbe_parent && (elm == ((elm
)->entry.rbe_parent)->entry.rbe_left)) elm = (elm)->
entry.rbe_parent; else { while ((elm)->entry.rbe_parent &&
 (elm == ((elm)->entry.rbe_parent)->entry.rbe_right)) elm
 = (elm)->entry.rbe_parent; elm = (elm)->entry.rbe_parent
; } } return (elm); } struct force_tree_entry * force_tree_RB_PREV
(struct force_tree_entry *elm) { if ((elm)->entry.rbe_left
) { elm = (elm)->entry.rbe_left; while ((elm)->entry.rbe_right
) elm = (elm)->entry.rbe_right; } else { if ((elm)->entry
.rbe_parent && (elm == ((elm)->entry.rbe_parent)->
entry.rbe_right)) elm = (elm)->entry.rbe_parent; else { while
 ((elm)->entry.rbe_parent && (elm == ((elm)->entry
.rbe_parent)->entry.rbe_left)) elm = (elm)->entry.rbe_parent
; elm = (elm)->entry.rbe_parent; } } return (elm); } struct
 force_tree_entry * force_tree_RB_MINMAX(struct force_tree *head
, int val) { struct force_tree_entry *tmp = (head)->rbh_root
; struct force_tree_entry *parent = ((void*)0); while (tmp) {
 parent = tmp; if (val < 0) tmp = (tmp)->entry.rbe_left
; else tmp = (tmp)->entry.rbe_right; } return (parent); }

226int				 val_id = -1;
227struct slabhash			*unified_msg_cache;
228struct rrset_cache		*unified_rrset_cache;
229struct key_cache		*unified_key_cache;
230struct val_neg_cache		*unified_neg_cache;

232int				 dns64_present;
233int				 available_afs = HAVE_IPV41 | HAVE_IPV62;

235static const char * const	 as112_zones[] = {
/* RFC1918 */
"10.in-addr.arpa. transparent",
"16.172.in-addr.arpa. transparent",
"31.172.in-addr.arpa. transparent",
"168.192.in-addr.arpa. transparent",

/* RFC3330 */
"0.in-addr.arpa. transparent",
"254.169.in-addr.arpa. transparent",
"2.0.192.in-addr.arpa. transparent",
"100.51.198.in-addr.arpa. transparent",
"113.0.203.in-addr.arpa. transparent",
"255.255.255.255.in-addr.arpa. transparent",

/* RFC6598 */
"64.100.in-addr.arpa. transparent",
"65.100.in-addr.arpa. transparent",
"66.100.in-addr.arpa. transparent",
"67.100.in-addr.arpa. transparent",
"68.100.in-addr.arpa. transparent",
"69.100.in-addr.arpa. transparent",
"70.100.in-addr.arpa. transparent",
"71.100.in-addr.arpa. transparent",
"72.100.in-addr.arpa. transparent",
"73.100.in-addr.arpa. transparent",
"74.100.in-addr.arpa. transparent",
"75.100.in-addr.arpa. transparent",
"76.100.in-addr.arpa. transparent",
"77.100.in-addr.arpa. transparent",
"78.100.in-addr.arpa. transparent",
"79.100.in-addr.arpa. transparent",
"80.100.in-addr.arpa. transparent",
"81.100.in-addr.arpa. transparent",
"82.100.in-addr.arpa. transparent",
"83.100.in-addr.arpa. transparent",
"84.100.in-addr.arpa. transparent",
"85.100.in-addr.arpa. transparent",
"86.100.in-addr.arpa. transparent",
"87.100.in-addr.arpa. transparent",
"88.100.in-addr.arpa. transparent",
"89.100.in-addr.arpa. transparent",
"90.100.in-addr.arpa. transparent",
"91.100.in-addr.arpa. transparent",
"92.100.in-addr.arpa. transparent",
"93.100.in-addr.arpa. transparent",
"94.100.in-addr.arpa. transparent",
"95.100.in-addr.arpa. transparent",
"96.100.in-addr.arpa. transparent",
"97.100.in-addr.arpa. transparent",
"98.100.in-addr.arpa. transparent",
"99.100.in-addr.arpa. transparent",
"100.100.in-addr.arpa. transparent",
"101.100.in-addr.arpa. transparent",
"102.100.in-addr.arpa. transparent",
"103.100.in-addr.arpa. transparent",
"104.100.in-addr.arpa. transparent",
"105.100.in-addr.arpa. transparent",
"106.100.in-addr.arpa. transparent",
"107.100.in-addr.arpa. transparent",
"108.100.in-addr.arpa. transparent",
"109.100.in-addr.arpa. transparent",
"110.100.in-addr.arpa. transparent",
"111.100.in-addr.arpa. transparent",
"112.100.in-addr.arpa. transparent",
"113.100.in-addr.arpa. transparent",
"114.100.in-addr.arpa. transparent",
"115.100.in-addr.arpa. transparent",
"116.100.in-addr.arpa. transparent",
"117.100.in-addr.arpa. transparent",
"118.100.in-addr.arpa. transparent",
"119.100.in-addr.arpa. transparent",
"120.100.in-addr.arpa. transparent",
"121.100.in-addr.arpa. transparent",
"122.100.in-addr.arpa. transparent",
"123.100.in-addr.arpa. transparent",
"124.100.in-addr.arpa. transparent",
"125.100.in-addr.arpa. transparent",
"126.100.in-addr.arpa. transparent",
"127.100.in-addr.arpa. transparent",

/* RFC4291 */
"0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0."
"ip6.arpa. transparent",

/* RFC4193 */
"D.F.ip6.arpa. transparent",

/* RFC4291 */
"8.E.F.ip6.arpa. transparent",
"9.E.F.ip6.arpa. transparent",
"A.E.F.ip6.arpa. transparent",
"B.E.F.ip6.arpa. transparent",

/* RFC3849 */
"8.B.D.0.1.0.0.2.ip6.arpa. transparent"
331};

333const char	 bogus_past[]	= "validation failure <. NS IN>: signature "
		  "expired";
335const char	 bogus_future[]	= "validation failure <. NS IN>: signature "
		  "before inception date";

338void
339resolver_sig_handler(int sig, short event, void *arg)
340{
/*
* Normal signal handler rules don't apply because libevent
* decouples for us.
*/

switch (sig) {
case SIGINT2:
case SIGTERM15:
resolver_shutdown();
default:
fatalx("unexpected signal");
}
353}

355void
356resolver(int debug, int verbose)
357{
struct event		 ev_sigint, ev_sigterm;
struct passwd		*pw;
struct timeval		 tv = {DECAY_PERIOD60, 0};
struct alloc_cache	 cache_alloc_test;

resolver_conf = config_new_empty();

log_init(debug, LOG_DAEMON)uw_log_init(debug, (3<<3));
log_setverbose(verbose);

if ((pw = getpwnam(UNWIND_USER"_unwind")) == NULL((void*)0))
fatal("getpwnam");

setproctitle("%s", "resolver");
log_procinit("resolver");

if (setgroups(1, &pw->pw_gid) ||
   setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) ||
   setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid))
fatal("can't drop privileges");

if (unveil(TLS_DEFAULT_CA_CERT_FILE"/etc/ssl/cert.pem", "r") == -1)
fatal("unveil %s", TLS_DEFAULT_CA_CERT_FILE"/etc/ssl/cert.pem");

if (pledge("stdio inet dns rpath recvfd", NULL((void*)0)) == -1)
fatal("pledge");

ev_base = event_init();

/* Setup signal handler(s). */
signal_set(&ev_sigint, SIGINT, resolver_sig_handler, NULL)event_set(&ev_sigint, 2, 0x08|0x10, resolver_sig_handler,
 ((void*)0));
signal_set(&ev_sigterm, SIGTERM, resolver_sig_handler, NULL)event_set(&ev_sigterm, 15, 0x08|0x10, resolver_sig_handler
, ((void*)0));
signal_add(&ev_sigint, NULL)event_add(&ev_sigint, ((void*)0));
signal_add(&ev_sigterm, NULL)event_add(&ev_sigterm, ((void*)0));
signal(SIGPIPE13, SIG_IGN(void (*)(int))1);
signal(SIGHUP1, SIG_IGN(void (*)(int))1);

/* Setup pipe and event handler to the main process. */
if ((iev_main = malloc(sizeof(struct imsgev))) == NULL((void*)0))
fatal(NULL((void*)0));

imsg_init(&iev_main->ibuf, 3);
iev_main->handler = resolver_dispatch_main;

/* Setup event handlers. */
iev_main->events = EV_READ0x02;
event_set(&iev_main->ev, iev_main->ibuf.fd, iev_main->events,
   iev_main->handler, iev_main);
event_add(&iev_main->ev, NULL((void*)0));

evtimer_set(&trust_anchor_timer, trust_anchor_timo, NULL)event_set(&trust_anchor_timer, -1, 0, trust_anchor_timo, (
(void*)0));
evtimer_set(&decay_timer, decay_latest_histograms, NULL)event_set(&decay_timer, -1, 0, decay_latest_histograms, (
(void*)0));
evtimer_add(&decay_timer, &tv)event_add(&decay_timer, &tv);

clock_gettime(CLOCK_MONOTONIC3, &last_network_change);

alloc_init(&cache_alloc_test, NULL((void*)0), 0);
if (cache_alloc_test.max_reg_blocks != 10)
fatalx("local libunbound/util/alloc.c diff lost");
alloc_clear(&cache_alloc_test);

setup_unified_caches();

TAILQ_INIT(&autoconf_forwarder_list)do { (&autoconf_forwarder_list)->tqh_first = ((void*)0
); (&autoconf_forwarder_list)->tqh_last = &(&autoconf_forwarder_list
)->tqh_first; } while (0);
TAILQ_INIT(&trust_anchors)do { (&trust_anchors)->tqh_first = ((void*)0); (&trust_anchors
)->tqh_last = &(&trust_anchors)->tqh_first; } while
 (0);
TAILQ_INIT(&new_trust_anchors)do { (&new_trust_anchors)->tqh_first = ((void*)0); (&
new_trust_anchors)->tqh_last = &(&new_trust_anchors
)->tqh_first; } while (0);
TAILQ_INIT(&running_queries)do { (&running_queries)->tqh_first = ((void*)0); (&
running_queries)->tqh_last = &(&running_queries)->
tqh_first; } while (0);

event_dispatch();

resolver_shutdown();
429}

431__dead__attribute__((__noreturn__)) void
432resolver_shutdown(void)
433{
/* Close pipes. */
msgbuf_clear(&iev_frontend->ibuf.w);
close(iev_frontend->ibuf.fd);
msgbuf_clear(&iev_main->ibuf.w);
close(iev_main->ibuf.fd);

config_clear(resolver_conf);

free(iev_frontend);
free(iev_main);

log_info("resolver exiting")uw_log_info("resolver exiting");
exit(0);
447}

449int
450resolver_imsg_compose_main(int type, pid_t pid, void *data, uint16_t datalen)
451{
return (imsg_compose_event(iev_main, type, 0, pid, -1, data, datalen));
453}

455int
456resolver_imsg_compose_frontend(int type, pid_t pid, void *data,
  uint16_t datalen)
458{
return (imsg_compose_event(iev_frontend, type, 0, pid, -1,
   data, datalen));
461}

463void
464resolver_dispatch_frontend(int fd, short event, void *bula)
465{
struct imsgev		*iev = bula;
struct imsgbuf		*ibuf;
struct imsg		 imsg;
struct query_imsg	*query_imsg;
ssize_t			 n;
int			 shut = 0, verbose, i, new_available_afs;
char			*ta;

ibuf = &iev->ibuf;

if (event & EV_READ0x02) {
if ((n = imsg_read(ibuf)) == -1 && errno(*__errno()) != EAGAIN35)
	fatal("imsg_read error");
if (n == 0)	/* Connection closed. */
	shut = 1;
}
if (event & EV_WRITE0x04) {
if ((n = msgbuf_write(&ibuf->w)) == -1 && errno(*__errno()) != EAGAIN35)
	fatal("msgbuf_write");
if (n == 0)	/* Connection closed. */
	shut = 1;
}

for (;;) {
if ((n = imsg_get(ibuf, &imsg)) == -1)
	fatal("%s: imsg_get error", __func__);
if (n == 0)	/* No more messages. */
	break;

switch (imsg.hdr.type) {
case IMSG_CTL_LOG_VERBOSE:
	if (IMSG_DATA_SIZE(imsg)((imsg).hdr.len - sizeof(struct imsg_hdr)) != sizeof(verbose))
		fatalx("%s: IMSG_CTL_LOG_VERBOSE wrong length: "
		    "%lu", __func__,
		    IMSG_DATA_SIZE(imsg)((imsg).hdr.len - sizeof(struct imsg_hdr)));
	memcpy(&verbose, imsg.data, sizeof(verbose));
	if (log_getdebug() && (log_getverbose() & OPT_VERBOSE30x00000004)
	    != (verbose & OPT_VERBOSE30x00000004))
		restart_ub_resolvers(0);
	log_setverbose(verbose);
	break;
case IMSG_QUERY:
	if (IMSG_DATA_SIZE(imsg)((imsg).hdr.len - sizeof(struct imsg_hdr)) != sizeof(*query_imsg))
		fatalx("%s: IMSG_QUERY wrong length: %lu",
		    __func__, IMSG_DATA_SIZE(imsg)((imsg).hdr.len - sizeof(struct imsg_hdr)));
	if ((query_imsg = malloc(sizeof(*query_imsg))) ==
	    NULL((void*)0)) {
		log_warn("cannot allocate query")uw_log_warn("cannot allocate query");
		break;
	}
	memcpy(query_imsg, imsg.data, sizeof(*query_imsg));
	setup_query(query_imsg);
	break;
case IMSG_CTL_STATUS:
	if (IMSG_DATA_SIZE(imsg)((imsg).hdr.len - sizeof(struct imsg_hdr)) != 0)
		fatalx("%s: IMSG_CTL_STATUS wrong length: %lu",
		    __func__, IMSG_DATA_SIZE(imsg)((imsg).hdr.len - sizeof(struct imsg_hdr)));
	show_status(imsg.hdr.pid);
	break;
case IMSG_CTL_AUTOCONF:
	if (IMSG_DATA_SIZE(imsg)((imsg).hdr.len - sizeof(struct imsg_hdr)) != 0)
		fatalx("%s: IMSG_CTL_AUTOCONF wrong length: "
		    "%lu", __func__, IMSG_DATA_SIZE(imsg)((imsg).hdr.len - sizeof(struct imsg_hdr)));
	show_autoconf(imsg.hdr.pid);
	break;
case IMSG_CTL_MEM:
	if (IMSG_DATA_SIZE(imsg)((imsg).hdr.len - sizeof(struct imsg_hdr)) != 0)
		fatalx("%s: IMSG_CTL_AUTOCONF wrong length: "
		    "%lu", __func__, IMSG_DATA_SIZE(imsg)((imsg).hdr.len - sizeof(struct imsg_hdr)));
	show_mem(imsg.hdr.pid);
	break;
case IMSG_NEW_TA:
	if (((char *)imsg.data)[IMSG_DATA_SIZE(imsg)((imsg).hdr.len - sizeof(struct imsg_hdr)) - 1] !=
	    '\0')
		fatalx("Invalid trust anchor");
	ta = imsg.data;
	add_new_ta(&new_trust_anchors, ta);
	break;
case IMSG_NEW_TAS_ABORT:
	free_tas(&new_trust_anchors);
	break;
case IMSG_NEW_TAS_DONE:
	if (merge_tas(&new_trust_anchors, &trust_anchors))
		restart_ub_resolvers(1);
	break;
case IMSG_NETWORK_CHANGED:
	clock_gettime(CLOCK_MONOTONIC3, &last_network_change);
	schedule_recheck_all_resolvers();
	for (i = 0; i < UW_RES_NONE; i++) {
		if (resolvers[i] == NULL((void*)0))
			continue;
		memset(resolvers[i]->latest_histogram, 0,
		    sizeof(resolvers[i]->latest_histogram));
		resolvers[i]->median = histogram_median(
		    resolvers[i]->latest_histogram);
	}

	break;
case IMSG_REPLACE_DNS:
	if (IMSG_DATA_SIZE(imsg)((imsg).hdr.len - sizeof(struct imsg_hdr)) !=
	    sizeof(struct imsg_rdns_proposal))
		fatalx("%s: IMSG_ADD_DNS wrong length: %lu",
		    __func__, IMSG_DATA_SIZE(imsg)((imsg).hdr.len - sizeof(struct imsg_hdr)));
	replace_autoconf_forwarders((struct
	    imsg_rdns_proposal *)imsg.data);
	break;
case IMSG_CHANGE_AFS:
	if (IMSG_DATA_SIZE(imsg)((imsg).hdr.len - sizeof(struct imsg_hdr)) !=
	    sizeof(new_available_afs))
		fatalx("%s: IMSG_CHANGE_AFS wrong length: %lu",
		    __func__, IMSG_DATA_SIZE(imsg)((imsg).hdr.len - sizeof(struct imsg_hdr)));
	memcpy(&new_available_afs, imsg.data,
	    sizeof(new_available_afs));
	if (new_available_afs != available_afs) {
		available_afs = new_available_afs;
		restart_ub_resolvers(1);
	}
	break;
default:
	log_debug("%s: unexpected imsg %d", __func__,
	    imsg.hdr.type);
	break;
}
imsg_free(&imsg);
}
if (!shut)
imsg_event_add(iev);
else {
/* This pipe is dead. Remove its event handler. */
event_del(&iev->ev);
event_loopexit(NULL((void*)0));
}
598}

600void
601resolver_dispatch_main(int fd, short event, void *bula)
602{
static struct uw_conf	*nconf;
struct imsg		 imsg;
struct imsgev		*iev = bula;
struct imsgbuf		*ibuf;
ssize_t			 n;
int			 shut = 0, i, *restart;

ibuf = &iev->ibuf;

if (event & EV_READ0x02) {
if ((n = imsg_read(ibuf)) == -1 && errno(*__errno()) != EAGAIN35)
	fatal("imsg_read error");
if (n == 0)	/* Connection closed. */
	shut = 1;
}
if (event & EV_WRITE0x04) {
if ((n = msgbuf_write(&ibuf->w)) == -1 && errno(*__errno()) != EAGAIN35)
	fatal("msgbuf_write");
if (n == 0)	/* Connection closed. */
	shut = 1;
}

for (;;) {
if ((n = imsg_get(ibuf, &imsg)) == -1)
	fatal("%s: imsg_get error", __func__);
if (n == 0)	/* No more messages. */
	break;

switch (imsg.hdr.type) {
case IMSG_SOCKET_IPC_FRONTEND:
	/*
	 * Setup pipe and event handler to the frontend
	 * process.
	 */
	if (iev_frontend)
		fatalx("%s: received unexpected imsg fd "
		    "to resolver", __func__);

	if ((fd = imsg.fd) == -1)
		fatalx("%s: expected to receive imsg fd to "
		   "resolver but didn't receive any", __func__);

	iev_frontend = malloc(sizeof(struct imsgev));
	if (iev_frontend == NULL((void*)0))
		fatal(NULL((void*)0));

	imsg_init(&iev_frontend->ibuf, fd);
	iev_frontend->handler = resolver_dispatch_frontend;
	iev_frontend->events = EV_READ0x02;

	event_set(&iev_frontend->ev, iev_frontend->ibuf.fd,
	iev_frontend->events, iev_frontend->handler,
	    iev_frontend);
	event_add(&iev_frontend->ev, NULL((void*)0));
	break;

case IMSG_STARTUP:
	if (pledge("stdio inet dns rpath", NULL((void*)0)) == -1)
		fatal("pledge");
	break;
case IMSG_RECONF_CONF:
case IMSG_RECONF_BLOCKLIST_FILE:
case IMSG_RECONF_FORWARDER:
case IMSG_RECONF_DOT_FORWARDER:
case IMSG_RECONF_FORCE:
	imsg_receive_config(&imsg, &nconf);
	break;
case IMSG_RECONF_END:
	if (nconf == NULL((void*)0))
		fatalx("%s: IMSG_RECONF_END without "
		    "IMSG_RECONF_CONF", __func__);
	restart = resolvers_to_restart(resolver_conf, nconf);
	merge_config(resolver_conf, nconf);
	nconf = NULL((void*)0);
	for (i = 0; i < UW_RES_NONE; i++)
		if (restart[i])
			new_resolver(i, UNKNOWN);
	break;
default:
	log_debug("%s: unexpected imsg %d", __func__,
	    imsg.hdr.type);
	break;
}
imsg_free(&imsg);
}
if (!shut)
imsg_event_add(iev);
else {
/* This pipe is dead. Remove its event handler. */
event_del(&iev->ev);
event_loopexit(NULL((void*)0));
}
695}

697int
698sort_resolver_types(struct resolver_preference *dst)
699{
memcpy(dst, &resolver_conf->res_pref, sizeof(*dst));

/*
* Sort by resolver quality, validating > resolving etc.
* mergesort is stable and keeps the configured preference order
*/
return mergesort(dst->types, dst->len, sizeof(dst->types[0]),
   resolver_cmp);
708}

710void
711setup_query(struct query_imsg *query_imsg)
712{
struct running_query	*rq;
struct uw_resolver	*res;

if (find_running_query(query_imsg->id) != NULL((void*)0)) {
free(query_imsg);
return;
}

if ((rq = calloc(1, sizeof(*rq))) == NULL((void*)0)) {
log_warnx(NULL((void*)0));
free(query_imsg);
return;
}

clock_gettime(CLOCK_MONOTONIC3, &rq->tp);
rq->query_imsg = query_imsg;
rq->next_resolver = 0;

find_force(&resolver_conf->force, query_imsg->qname, &res);

if (res != NULL((void*)0) && res->state != DEAD && res->state != UNKNOWN) {
rq->res_pref.len = 1;
rq->res_pref.types[0] = res->type;
} else if (sort_resolver_types(&rq->res_pref) == -1) {
log_warn("mergesort")uw_log_warn("mergesort");
free(rq->query_imsg);
free(rq);
return;
}

evtimer_set(&rq->timer_ev, try_resolver_timo, rq)event_set(&rq->timer_ev, -1, 0, try_resolver_timo, rq);

TAILQ_INSERT_TAIL(&running_queries, rq, entry)do { (rq)->entry.tqe_next = ((void*)0); (rq)->entry.tqe_prev
 = (&running_queries)->tqh_last; *(&running_queries
)->tqh_last = (rq); (&running_queries)->tqh_last = &
(rq)->entry.tqe_next; } while (0);
try_next_resolver(rq);
747}

749struct running_query *
750find_running_query(uint64_t id)
751{
struct running_query	*rq;

TAILQ_FOREACH(rq, &running_queries, entry)for((rq) = ((&running_queries)->tqh_first); (rq) != ((
void*)0); (rq) = ((rq)->entry.tqe_next)) {
if (rq->query_imsg->id == id)
	return rq;
}
return NULL((void*)0);
759}

761void
762try_resolver_timo(int fd, short events, void *arg)
763{
struct running_query	*rq = arg;

try_next_resolver(rq);
767}

769int
770try_next_resolver(struct running_query *rq)
771{
struct uw_resolver	*res = NULL((void*)0);
struct query_imsg	*query_imsg = NULL((void*)0);
struct timespec		 tp, elapsed;
struct timeval		 tv = {0, 0};
int64_t			 ms;
int			 i;

while(rq->next_resolver < rq->res_pref.len &&
   ((res = resolvers[rq->res_pref.types[rq->next_resolver]]) == NULL((void*)0) ||
   res->state == DEAD || res->state == UNKNOWN))
rq->next_resolver++;

if (res == NULL((void*)0)) {
evtimer_del(&rq->timer_ev)event_del(&rq->timer_ev); /* we are not going to find one */
log_debug("%s: could not find (any more) working resolvers",
    __func__);
goto err;
}

rq->next_resolver++;
clock_gettime(CLOCK_MONOTONIC3, &tp);
timespecsub(&tp, &rq->tp, &elapsed)do { (&elapsed)->tv_sec = (&tp)->tv_sec - (&
rq->tp)->tv_sec; (&elapsed)->tv_nsec = (&tp)
->tv_nsec - (&rq->tp)->tv_nsec; if ((&elapsed
)->tv_nsec < 0) { (&elapsed)->tv_sec--; (&elapsed
)->tv_nsec += 1000000000L; } } while (0);
ms = elapsed.tv_sec * 1000 + elapsed.tv_nsec / 1000000;

log_debug("%s[+%lldms]: %s[%s] %s", __func__, ms,
   uw_resolver_type_str[res->type], uw_resolver_state_str[res->state],
   query_imsg2str(rq->query_imsg));

if ((query_imsg = malloc(sizeof(*query_imsg))) == NULL((void*)0)) {
log_warnx("%s", __func__);
goto err;
}
memcpy(query_imsg, rq->query_imsg, sizeof(*query_imsg));
clock_gettime(CLOCK_MONOTONIC3, &query_imsg->tp);

ms = res->median;
if (ms > NEXT_RES_MAX2000)
ms = NEXT_RES_MAX2000;

/* skip over unavailable resolvers in preferences */
for (i = 0; i < resolver_conf->res_pref.len &&
 resolvers[resolver_conf->res_pref.types[i]] == NULL((void*)0); i++)
;
if (res->type == resolver_conf->res_pref.types[i])
tv.tv_usec = 1000 * (PREF_RESOLVER_MEDIAN_SKEW200 + ms);
else
tv.tv_usec = 1000 * ms;

while (tv.tv_usec >= 1000000) {
tv.tv_sec++;
tv.tv_usec -= 1000000;
}
evtimer_add(&rq->timer_ev, &tv)event_add(&rq->timer_ev, &tv);

rq->running++;
if (resolve(res, query_imsg->qname, query_imsg->t,
   query_imsg->c, query_imsg, resolve_done) != 0) {
rq->running--;
goto err;
}

return 0;

err:
free(query_imsg);
if (rq->running == 0) {
TAILQ_REMOVE(&running_queries, rq, entry)do { if (((rq)->entry.tqe_next) != ((void*)0)) (rq)->entry
.tqe_next->entry.tqe_prev = (rq)->entry.tqe_prev; else (
&running_queries)->tqh_last = (rq)->entry.tqe_prev;
 *(rq)->entry.tqe_prev = (rq)->entry.tqe_next; ; ; } while
 (0);
evtimer_del(&rq->timer_ev)event_del(&rq->timer_ev);
free(rq->query_imsg);
free(rq);
}
return 1;
844}

846int
847resolve(struct uw_resolver *res, const char* name, int rrtype, int rrclass,
  void *mydata, resolve_cb_t cb)
849{
struct resolver_cb_data	*cb_data = NULL((void*)0);
struct asr_query	*aq = NULL((void*)0);
int			 err;

resolver_ref(res);

if ((cb_data = malloc(sizeof(*cb_data))) == NULL((void*)0))
goto err;
cb_data->cb = cb;
cb_data->data = mydata;
cb_data->res = res;

switch(res->type) {
case UW_RES_ASR:
if ((aq = res_query_async(name, rrclass, rrtype, res->asr_ctx))
    == NULL((void*)0)) {
	log_warn("%s: res_query_async", __func__)uw_log_warn("%s: res_query_async", __func__);
	goto err;
}
if (event_asr_run(aq, asr_resolve_done, cb_data) == NULL((void*)0)) {
	log_warn("%s: res_query_async", __func__)uw_log_warn("%s: res_query_async", __func__);
	goto err;
}
break;
case UW_RES_RECURSOR:
case UW_RES_AUTOCONF:
case UW_RES_ODOT_AUTOCONF:
case UW_RES_FORWARDER:
case UW_RES_ODOT_FORWARDER:
case UW_RES_DOT:
if ((err = ub_resolve_event(res->ctx, name,  rrtype, rrclass,
    cb_data, ub_resolve_done, NULL((void*)0))) != 0) {
	log_warn("%s: ub_resolve_event: err: %d, %s", __func__,uw_log_warn("%s: ub_resolve_event: err: %d, %s", __func__, err
, ub_strerror(err))
	    err, ub_strerror(err))uw_log_warn("%s: ub_resolve_event: err: %d, %s", __func__, err
, ub_strerror(err));
	goto err;
}
break;
default:
fatalx("unknown resolver type %d", res->type);
break;
}

return 0;
err:
free(cb_data);
free(aq);
resolver_unref(res);
return 1;
898}

900void
901resolve_done(struct uw_resolver *res, void *arg, int rcode,
  void *answer_packet, int answer_len, int sec, char *why_bogus)
903{
struct uw_resolver	*tmp_res;
struct ub_result	*result = NULL((void*)0);
sldns_buffer		*buf = NULL((void*)0);
struct regional		*region = NULL((void*)0);
struct query_imsg	*query_imsg;
struct answer_header	*answer_header;
struct running_query	*rq;
struct timespec		 tp, elapsed;
int64_t			 ms;
size_t			 i;
int			 running_res, asr_pref_pos, force_acceptbogus;
char			*str;
char			 rcode_buf[16];
uint8_t			*p, *data;
uint8_t			 answer_imsg[MAX_IMSGSIZE16384 - IMSG_HEADER_SIZEsizeof(struct imsg_hdr)];

clock_gettime(CLOCK_MONOTONIC3, &tp);

query_imsg = (struct query_imsg *)arg;

answer_header = (struct answer_header *)answer_imsg;
data = answer_imsg + sizeof(*answer_header);
answer_header->id = query_imsg->id;
answer_header->srvfail = 0;
answer_header->answer_len = 0;

timespecsub(&tp, &query_imsg->tp, &elapsed)do { (&elapsed)->tv_sec = (&tp)->tv_sec - (&
query_imsg->tp)->tv_sec; (&elapsed)->tv_nsec = (
&tp)->tv_nsec - (&query_imsg->tp)->tv_nsec; if
 ((&elapsed)->tv_nsec < 0) { (&elapsed)->tv_sec
--; (&elapsed)->tv_nsec += 1000000000L; } } while (0);

ms = elapsed.tv_sec * 1000 + elapsed.tv_nsec / 1000000;

for (i = 0; i < nitems(histogram_limits)(sizeof((histogram_limits)) / sizeof((histogram_limits)[0])); i++) {
if (ms < histogram_limits[i])
	break;
}
if (i == nitems(histogram_limits)(sizeof((histogram_limits)) / sizeof((histogram_limits)[0])))
log_debug("histogram bucket error");
else {
res->histogram[i]++;
/* latest_histogram is in units of 1000 to avoid rounding
   down when decaying */
res->latest_histogram[i] += 1000;
res->median = histogram_median(res->latest_histogram);
}

if ((rq = find_running_query(query_imsg->id)) == NULL((void*)0))
goto out;

running_res = --rq->running;

if (answer_len < LDNS_HEADER_SIZE12) {
log_warnx("bad packet: too short");
goto servfail;
}

if (answer_len > UINT16_MAX0xffff) {
log_warnx("bad packet: too large: %d - %s", answer_len,
    query_imsg2str(query_imsg));
goto servfail;
}
answer_header->answer_len = answer_len;

if (rcode == LDNS_RCODE_SERVFAIL) {
if (res->stop != 1)
	check_resolver(res);
goto servfail;
}

if ((result = calloc(1, sizeof(*result))) == NULL((void*)0))
goto servfail;
if ((buf = sldns_buffer_new(answer_len)) == NULL((void*)0))
goto servfail;
if ((region = regional_create()) == NULL((void*)0))
goto servfail;

result->rcode = LDNS_RCODE_SERVFAIL;

sldns_buffer_clear(buf);
sldns_buffer_write(buf, answer_packet, answer_len);
sldns_buffer_flip(buf);
libworker_enter_result(result, buf, region, sec);
result->answer_packet = NULL((void*)0);
result->answer_len = 0;

sldns_wire2str_rcode_buf(result->rcode, rcode_buf, sizeof(rcode_buf));
log_debug("%s[%s]: %s rcode: %s[%d], elapsed: %lldms, running: %d",
   __func__, uw_resolver_type_str[res->type],
   query_imsg2str(query_imsg), rcode_buf, result->rcode, ms,
   running_query_cnt());

force_acceptbogus = find_force(&resolver_conf->force, query_imsg->qname,
   &tmp_res);
if (tmp_res != NULL((void*)0) && tmp_res->type != res->type)
force_acceptbogus = 0;

timespecsub(&tp, &last_network_change, &elapsed)do { (&elapsed)->tv_sec = (&tp)->tv_sec - (&
last_network_change)->tv_sec; (&elapsed)->tv_nsec =
 (&tp)->tv_nsec - (&last_network_change)->tv_nsec
; if ((&elapsed)->tv_nsec < 0) { (&elapsed)->
tv_sec--; (&elapsed)->tv_nsec += 1000000000L; } } while
 (0);
if (sec != SECURE2 && elapsed.tv_sec < DOUBT_NXDOMAIN_SEC(5 * 60) &&
   !force_acceptbogus && res->type != UW_RES_ASR &&
   (result->rcode == LDNS_RCODE_NXDOMAIN || sec == BOGUS1)) {
/*
 * Doubt NXDOMAIN or BOGUS if we just switched networks, we
 * might be behind a captive portal.
 */
log_debug("%s: doubt NXDOMAIN or BOGUS from %s, network change"
    " %llds ago", __func__, uw_resolver_type_str[res->type],
    elapsed.tv_sec);

/* search for ASR */
asr_pref_pos = -1;
for (i = 0; i < (size_t)rq->res_pref.len; i++)
	if (rq->res_pref.types[i] == UW_RES_ASR) {
		asr_pref_pos = i;
		break;
	}

if (asr_pref_pos != -1 && resolvers[UW_RES_ASR] != NULL((void*)0)) {
	/* go to ASR if not yet scheduled */
	if (asr_pref_pos >= rq->next_resolver) {
		rq->next_resolver = asr_pref_pos;
		try_next_resolver(rq);
	}
	goto out;
}
log_debug("%s: using NXDOMAIN or BOGUS, couldn't find working "
    "ASR", __func__);
}

if (log_getverbose() & OPT_VERBOSE20x00000002 && (str =
   sldns_wire2str_pkt(answer_packet, answer_len)) != NULL((void*)0)) {
log_debug("%s", str);
free(str);
}

if (result->rcode == LDNS_RCODE_SERVFAIL)
goto servfail;

if (sec == SECURE2 && res->state != VALIDATING && res->stop != -1)
check_resolver(res);

if (res->state == VALIDATING && sec == BOGUS1) {
answer_header->bogus = !force_acceptbogus;
if (answer_header->bogus && why_bogus != NULL((void*)0))
	log_warnx("%s", why_bogus);
} else
answer_header->bogus = 0;

p = answer_packet;
do {
int len;

if ((size_t)answer_len > sizeof(answer_imsg) -
    sizeof(*answer_header))
	len = sizeof(answer_imsg) - sizeof(*answer_header);
else
	len = answer_len;
memcpy(data, p, len);
if (resolver_imsg_compose_frontend(IMSG_ANSWER, 0,
    &answer_imsg, sizeof(*answer_header) + len) == -1)
	fatalx("IMSG_ANSWER failed for \"%s\"",
	    query_imsg2str(query_imsg));
answer_len -= len;
p += len;
} while (answer_len > 0);

TAILQ_REMOVE(&running_queries, rq, entry)do { if (((rq)->entry.tqe_next) != ((void*)0)) (rq)->entry
.tqe_next->entry.tqe_prev = (rq)->entry.tqe_prev; else (
&running_queries)->tqh_last = (rq)->entry.tqe_prev;
 *(rq)->entry.tqe_prev = (rq)->entry.tqe_next; ; ; } while
 (0);
evtimer_del(&rq->timer_ev)event_del(&rq->timer_ev);
free(rq->query_imsg);
free(rq);
goto out;

servfail:
/* try_next_resolver() might free rq */
if (try_next_resolver(rq) != 0 && running_res == 0) {
/* we are the last one, send SERVFAIL */
answer_header->srvfail = 1;
resolver_imsg_compose_frontend(IMSG_ANSWER, 0,
    answer_imsg, sizeof(*answer_header));
}
out:
free(query_imsg);
sldns_buffer_free(buf);
regional_destroy(region);
ub_resolve_free(result);
1086}

1088void
1089new_resolver(enum uw_resolver_type type, enum uw_resolver_state state)
1090{
free_resolver(resolvers[type]);
resolvers[type] = NULL((void*)0);

if (!resolver_conf->enabled_resolvers[type])
return;

switch (type) {
case UW_RES_ASR:
case UW_RES_AUTOCONF:
case UW_RES_ODOT_AUTOCONF:
if (TAILQ_EMPTY(&autoconf_forwarder_list)(((&autoconf_forwarder_list)->tqh_first) == ((void*)0)
))
	return;
break;
case UW_RES_RECURSOR:
break;
case UW_RES_FORWARDER:
case UW_RES_ODOT_FORWARDER:
if (TAILQ_EMPTY(&resolver_conf->uw_forwarder_list)(((&resolver_conf->uw_forwarder_list)->tqh_first) ==
 ((void*)0)))
	return;
break;
case UW_RES_DOT:
if (TAILQ_EMPTY(&resolver_conf->uw_dot_forwarder_list)(((&resolver_conf->uw_dot_forwarder_list)->tqh_first
) == ((void*)0)))
	return;
break;
case UW_RES_NONE:
fatalx("cannot create UW_RES_NONE resolver");
}

switch (type) {
case UW_RES_RECURSOR:
case UW_RES_AUTOCONF:
case UW_RES_ODOT_AUTOCONF:
case UW_RES_FORWARDER:
case UW_RES_ODOT_FORWARDER:
case UW_RES_DOT:
if (TAILQ_EMPTY(&trust_anchors)(((&trust_anchors)->tqh_first) == ((void*)0)))
	return;
break;
case UW_RES_ASR:
break;
case UW_RES_NONE:
fatalx("cannot create UW_RES_NONE resolver");
}

if ((resolvers[type] = create_resolver(type)) == NULL((void*)0))
return;

switch (state) {
case DEAD:
case UNKNOWN:
check_resolver(resolvers[type]);
break;
case VALIDATING:
set_unified_cache(resolvers[type]);
/* FALLTHROUGH */
case RESOLVING:
resolvers[type]->state = state;
if (type == UW_RES_ASR)
	check_dns64();
break;
}
1152}

1154void
1155set_unified_cache(struct uw_resolver *res)
1156{
if (res == NULL((void*)0) || res->ctx == NULL((void*)0))
return;

if (res->ctx->env->msg_cache != NULL((void*)0)) {
/* XXX we are currently not using this */
if (res->ctx->env->msg_cache != unified_msg_cache ||
    res->ctx->env->rrset_cache != unified_rrset_cache ||
    res->ctx->env->key_cache != unified_key_cache ||
    res->ctx->env->neg_cache != unified_neg_cache)
	fatalx("wrong unified cache set on resolver");
else
	/* we are upgrading from UNKNOWN back to VALIDATING */
	return;
}

res->ctx->env->msg_cache = unified_msg_cache;
res->ctx->env->rrset_cache = unified_rrset_cache;
res->ctx->env->key_cache = unified_key_cache;
res->ctx->env->neg_cache = unified_neg_cache;

context_finalize(res->ctx);

if (res->ctx->env->msg_cache != unified_msg_cache ||
   res->ctx->env->rrset_cache != unified_rrset_cache ||
   res->ctx->env->key_cache != unified_key_cache ||
   res->ctx->env->neg_cache != unified_neg_cache)
fatalx("failed to set unified caches, libunbound/validator/"
    "validator.c diff lost");
1185}

1187static const struct {
const char *name;
const char *value;
1190} options[] = {
{ "aggressive-nsec:", "yes" },
{ "fast-server-permil:", "950" },
{ "edns-buffer-size:", "1232" },
{ "target-fetch-policy:", "0 0 0 0 0" },
{ "outgoing-range:", "64" },
{ "val-max-restart:", "0" },
1197};

1199struct uw_resolver *
1200create_resolver(enum uw_resolver_type type)
1201{
struct uw_resolver	*res;
struct trust_anchor	*ta;
size_t			 i;
int			 err;
char			*resolv_conf;

if ((res = calloc(1, sizeof(*res))) == NULL((void*)0)) {
log_warn("%s", __func__)uw_log_warn("%s", __func__);
return (NULL((void*)0));
}

res->type = type;
res->state = UNKNOWN;
res->check_tv.tv_sec = RESOLVER_CHECK_SEC1;
res->check_tv.tv_usec = arc4random() % 1000000; /* modulo bias is ok */

switch (type) {
case UW_RES_ASR:
if (TAILQ_EMPTY(&autoconf_forwarder_list)(((&autoconf_forwarder_list)->tqh_first) == ((void*)0)
)) {
	free(res);
	return (NULL((void*)0));
}
if ((resolv_conf = gen_resolv_conf()) == NULL((void*)0)) {
	free(res);
	log_warnx("could not create asr context");
	return (NULL((void*)0));
}
if ((res->asr_ctx = asr_resolver_from_string(resolv_conf)) ==
    NULL((void*)0)) {
	free(res);
	free(resolv_conf);
	log_warnx("could not create asr context");
	return (NULL((void*)0));
}
free(resolv_conf);
break;
case UW_RES_RECURSOR:
case UW_RES_AUTOCONF:
case UW_RES_ODOT_AUTOCONF:
case UW_RES_FORWARDER:
case UW_RES_ODOT_FORWARDER:
case UW_RES_DOT:
if ((res->ctx = ub_ctx_create_event(ev_base)) == NULL((void*)0)) {
	free(res);
	log_warnx("could not create unbound context");
	return (NULL((void*)0));
}

ub_ctx_debuglevel(res->ctx, log_getverbose() & OPT_VERBOSE30x00000004 ?
    UB_LOG_VERBOSE4 : UB_LOG_BRIEF0);

TAILQ_FOREACH(ta, &trust_anchors, entry)for((ta) = ((&trust_anchors)->tqh_first); (ta) != ((void
*)0); (ta) = ((ta)->entry.tqe_next)) {
	if ((err = ub_ctx_add_ta(res->ctx, ta->ta)) != 0) {
		ub_ctx_delete(res->ctx);
		free(res);
		log_warnx("error adding trust anchor: %s",
		    ub_strerror(err));
		return (NULL((void*)0));
	}
}

for (i = 0; i < nitems(options)(sizeof((options)) / sizeof((options)[0])); i++) {
	if ((err = ub_ctx_set_option(res->ctx, options[i].name,
	    options[i].value)) != 0) {
		ub_ctx_delete(res->ctx);
		free(res);
		log_warnx("error setting %s: %s: %s",
		    options[i].name, options[i].value,
		    ub_strerror(err));
		return (NULL((void*)0));
	}
}

if (!(available_afs & HAVE_IPV41)) {
	if((err = ub_ctx_set_option(res->ctx, "do-ip4:",
	    "no")) != 0) {
		ub_ctx_delete(res->ctx);
		free(res);
		log_warnx("error setting do-ip4: no: %s",
		    ub_strerror(err));
		return (NULL((void*)0));
	}
}

if (!(available_afs & HAVE_IPV62)) {
	if((err = ub_ctx_set_option(res->ctx, "do-ip6:",
	    "no")) != 0) {
		ub_ctx_delete(res->ctx);
		free(res);
		log_warnx("error setting do-ip6: no: %s",
		    ub_strerror(err));
		return (NULL((void*)0));
	}
}

if (!log_getdebug()) {
	if((err = ub_ctx_set_option(res->ctx, "use-syslog:",
	    "no")) != 0) {
		ub_ctx_delete(res->ctx);
		free(res);
		log_warnx("error setting use-syslog: no: %s",
		    ub_strerror(err));
		return (NULL((void*)0));
	}
	ub_ctx_debugout(res->ctx, NULL((void*)0));
}

break;
default:
fatalx("unknown resolver type %d", type);
break;
}

evtimer_set(&res->check_ev, resolver_check_timo, res)event_set(&res->check_ev, -1, 0, resolver_check_timo, res
);

switch(res->type) {
case UW_RES_ASR:
break;
case UW_RES_RECURSOR:
break;
case UW_RES_AUTOCONF:
set_forwarders(res, &autoconf_forwarder_list, 0);
break;
case UW_RES_ODOT_AUTOCONF:
set_forwarders(res, &autoconf_forwarder_list, 853);
ub_ctx_set_option(res->ctx, "tls-cert-bundle:",
    TLS_DEFAULT_CA_CERT_FILE"/etc/ssl/cert.pem");
ub_ctx_set_tls(res->ctx, 1);
break;
case UW_RES_FORWARDER:
set_forwarders(res, &resolver_conf->uw_forwarder_list, 0);
break;
case UW_RES_ODOT_FORWARDER:
set_forwarders(res, &resolver_conf->uw_forwarder_list, 853);
ub_ctx_set_option(res->ctx, "tls-cert-bundle:",
    TLS_DEFAULT_CA_CERT_FILE"/etc/ssl/cert.pem");
ub_ctx_set_tls(res->ctx, 1);
break;
case UW_RES_DOT:
set_forwarders(res, &resolver_conf->uw_dot_forwarder_list, 0);
ub_ctx_set_option(res->ctx, "tls-cert-bundle:",
    TLS_DEFAULT_CA_CERT_FILE"/etc/ssl/cert.pem");
ub_ctx_set_tls(res->ctx, 1);
break;
default:
fatalx("unknown resolver type %d", type);
break;
}

/* for the forwarder cases allow AS112 zones */
switch(res->type) {
case UW_RES_AUTOCONF:
case UW_RES_ODOT_AUTOCONF:
case UW_RES_FORWARDER:
case UW_RES_ODOT_FORWARDER:
case UW_RES_DOT:
for (i = 0; i < nitems(as112_zones)(sizeof((as112_zones)) / sizeof((as112_zones)[0])); i++) {
	if((err = ub_ctx_set_option(res->ctx, "local-zone:",
	    as112_zones[i])) != 0) {
		ub_ctx_delete(res->ctx);
		free(res);
		log_warnx("error setting local-zone: %s: %s",
		    as112_zones[i], ub_strerror(err));
		return (NULL((void*)0));
	}
}
break;
default:
break;
}

return (res);
1374}

1376void
1377free_resolver(struct uw_resolver *res)
1378{
struct val_env	*val_env;

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

if (res->ref_cnt > 0)
res->stop = 1;
else {
evtimer_del(&res->check_ev)event_del(&res->check_ev);
if (res->ctx != NULL((void*)0)) {
	if (res->ctx->env->msg_cache == unified_msg_cache) {
		val_env = (struct val_env*)
		    res->ctx->env->modinfo[val_id];
		res->ctx->env->msg_cache = NULL((void*)0);
		res->ctx->env->rrset_cache = NULL((void*)0);
		val_env->kcache = NULL((void*)0);
		res->ctx->env->key_cache = NULL((void*)0);
		val_env->neg_cache = NULL((void*)0);
		res->ctx->env->neg_cache = NULL((void*)0);
	}
}
ub_ctx_delete(res->ctx);
asr_resolver_free(res->asr_ctx);
free(res);
}
1404}

1406void
1407setup_unified_caches(void)
1408{
struct ub_ctx	*ctx;
struct val_env	*val_env;
size_t		 i;
int		 err, j;

if ((ctx = ub_ctx_create_event(ev_base)) == NULL((void*)0))
fatalx("could not create unbound context");

for (i = 0; i < nitems(options)(sizeof((options)) / sizeof((options)[0])); i++) {
if ((err = ub_ctx_set_option(ctx, options[i].name,
    options[i].value)) != 0) {
	fatalx("error setting %s: %s: %s", options[i].name,
	    options[i].value, ub_strerror(err));
}
}

context_finalize(ctx);

if (ctx->env->msg_cache == NULL((void*)0) || ctx->env->rrset_cache == NULL((void*)0) ||
   ctx->env->key_cache == NULL((void*)0) || ctx->env->neg_cache == NULL((void*)0))
fatalx("could not setup unified caches");

unified_msg_cache = ctx->env->msg_cache;
unified_rrset_cache = ctx->env->rrset_cache;
unified_key_cache = ctx->env->key_cache;
unified_neg_cache = ctx->env->neg_cache;

if (val_id == -1) {
for (j = 0; j < ctx->mods.num; j++) {
	if (strcmp(ctx->mods.mod[j]->name, "validator") == 0) {
		val_id = j;
		break;
	}
}
if (val_id == -1)
	fatalx("cannot find validator module");
}

val_env = (struct val_env*)ctx->env->modinfo[val_id];
ctx->env->msg_cache = NULL((void*)0);
ctx->env->rrset_cache = NULL((void*)0);
ctx->env->key_cache = NULL((void*)0);
val_env->kcache = NULL((void*)0);
ctx->env->neg_cache = NULL((void*)0);
val_env->neg_cache = NULL((void*)0);
ub_ctx_delete(ctx);
1455}

1457void
1458set_forwarders(struct uw_resolver *res, struct uw_forwarder_head
  *uw_forwarder_list, int port_override)
1460{
struct uw_forwarder	*uw_forwarder;
int			 ret;
char			 fwd[FWD_MAX(46 + 256 + 2 + 5)];

TAILQ_FOREACH(uw_forwarder, uw_forwarder_list, entry)for((uw_forwarder) = ((uw_forwarder_list)->tqh_first); (uw_forwarder
) != ((void*)0); (uw_forwarder) = ((uw_forwarder)->entry.tqe_next
)) {
if (uw_forwarder->auth_name[0] != '\0')
	ret = snprintf(fwd, sizeof(fwd), "%s@%d#%s",
	    uw_forwarder->ip, port_override ? port_override :
	    uw_forwarder->port, uw_forwarder->auth_name);
else
	ret = snprintf(fwd, sizeof(fwd), "%s@%d",
	    uw_forwarder->ip, port_override ? port_override :
	    uw_forwarder->port);

if (ret < 0 || (size_t)ret >= sizeof(fwd)) {
	log_warnx("forwarder too long");
	continue;
}

ub_ctx_set_fwd(res->ctx, fwd);
}
1482}

1484void
1485resolver_check_timo(int fd, short events, void *arg)
1486{
check_resolver((struct uw_resolver *)arg);
1488}

1490void
1491resolver_free_timo(int fd, short events, void *arg)
1492{
free_resolver((struct uw_resolver *)arg);
1494}

1496void
1497check_resolver(struct uw_resolver *resolver_to_check)
1498{
struct uw_resolver		*res;

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

if (resolver_to_check->check_running)
return;

if ((res = create_resolver(resolver_to_check->type)) == NULL((void*)0))
return;

resolver_ref(resolver_to_check);

resolver_to_check->check_running++;
if (resolve(res, ".", LDNS_RR_TYPE_NS, LDNS_RR_CLASS_IN,
   resolver_to_check, check_resolver_done) != 0) {
resolver_to_check->check_running--;
resolver_to_check->state = UNKNOWN;
resolver_unref(resolver_to_check);
resolver_to_check->check_tv.tv_sec = RESOLVER_CHECK_SEC1;
evtimer_add(&resolver_to_check->check_ev,event_add(&resolver_to_check->check_ev, &resolver_to_check
->check_tv)
    &resolver_to_check->check_tv)event_add(&resolver_to_check->check_ev, &resolver_to_check
->check_tv);
}
1522}

1524void
1525check_resolver_done(struct uw_resolver *res, void *arg, int rcode,
  void *answer_packet, int answer_len, int sec, char *why_bogus)
1527{
struct uw_resolver	*checked_resolver = arg;
struct timeval		 tv = {0, 1};
enum uw_resolver_state	 prev_state;
1
'prev_state' declared without an initial value→
int			 bogus_time = 0;
char			*str;

checked_resolver->check_running--;

if (checked_resolver != resolvers[checked_resolver->type]) {
2
←
Assuming the condition is true→
3
←
Taking true branch→
log_debug("%s: %s: ignoring late check result", __func__,
    uw_resolver_type_str[checked_resolver->type]);
goto out;
4
←
Control jumps to line 1598→
}

prev_state = checked_resolver->state;

if (answer_len < LDNS_HEADER_SIZE12) {
checked_resolver->state = DEAD;
log_warnx("%s: bad packet: too short", __func__);
goto out;
}

if (rcode == LDNS_RCODE_SERVFAIL) {
log_debug("%s: %s rcode: SERVFAIL", __func__,
    uw_resolver_type_str[checked_resolver->type]);

checked_resolver->state = DEAD;
goto out;
}

if (sec == SECURE2) {
if (dns64_present && (res->type == UW_RES_AUTOCONF ||
    res->type == UW_RES_ODOT_AUTOCONF)) {
	/* do not upgrade to validating, DNS64 breaks DNSSEC */
	if (prev_state != RESOLVING)
		new_resolver(checked_resolver->type,
		    RESOLVING);
} else {
	if (prev_state != VALIDATING)
		new_resolver(checked_resolver->type,
		    VALIDATING);
	if (!(evtimer_pending(&trust_anchor_timer, NULL)event_pending(&trust_anchor_timer, 0x01, ((void*)0))))
		evtimer_add(&trust_anchor_timer, &tv)event_add(&trust_anchor_timer, &tv);
}
} else if (rcode == LDNS_RCODE_NOERROR &&
   LDNS_RCODE_WIRE((uint8_t*)answer_packet)(*((uint8_t*)answer_packet+3) & 0x0fU) == LDNS_RCODE_NOERROR) {
if (why_bogus) {
	bogus_time = strncmp(why_bogus, bogus_past,
	    sizeof(bogus_past) - 1) == 0 || strncmp(why_bogus,
	    bogus_future, sizeof(bogus_future) - 1) == 0;

	log_warnx("%s: %s", uw_resolver_type_str[
	    checked_resolver->type], why_bogus);
}
if (prev_state != RESOLVING)
	new_resolver(checked_resolver->type, RESOLVING);
} else
checked_resolver->state = DEAD; /* we know the root exists */

log_debug("%s: %s: %s", __func__,
   uw_resolver_type_str[checked_resolver->type],
   uw_resolver_state_str[checked_resolver->state]);

if (log_getverbose() & OPT_VERBOSE20x00000002 && (str =
   sldns_wire2str_pkt(answer_packet, answer_len)) != NULL((void*)0)) {
log_debug("%s", str);
free(str);
}

1597out:
if (!checked_resolver->stop && (checked_resolver->state == DEAD ||
5
←
Assuming field 'stop' is 0→
6
←
Assuming field 'state' is equal to DEAD→
   bogus_time)) {
if (prev_state == DEAD || bogus_time)
7
←
The left operand of '==' is a garbage value
	checked_resolver->check_tv.tv_sec *= 2;
else
	checked_resolver->check_tv.tv_sec = RESOLVER_CHECK_SEC1;

if (checked_resolver->check_tv.tv_sec > RESOLVER_CHECK_MAXSEC1024)
	checked_resolver->check_tv.tv_sec =
	    RESOLVER_CHECK_MAXSEC1024;

evtimer_add(&checked_resolver->check_ev,event_add(&checked_resolver->check_ev, &checked_resolver
->check_tv)
    &checked_resolver->check_tv)event_add(&checked_resolver->check_ev, &checked_resolver
->check_tv);
}

resolver_unref(checked_resolver);
res->stop = 1; /* do not free in callback */
1615}

1617void
1618asr_resolve_done(struct asr_result *ar, void *arg)
1619{
struct resolver_cb_data	*cb_data = arg;
cb_data->cb(cb_data->res, cb_data->data, ar->ar_rcode, ar->ar_data,
   ar->ar_datalen, 0, NULL((void*)0));
free(ar->ar_data);
resolver_unref(cb_data->res);
free(cb_data);
1626}

1628void
1629ub_resolve_done(void *arg, int rcode, void *answer_packet, int answer_len,
  int sec, char *why_bogus, int was_ratelimited)
1631{
struct resolver_cb_data	*cb_data = arg;
cb_data->cb(cb_data->res, cb_data->data, rcode, answer_packet,
   answer_len, sec, why_bogus);
resolver_unref(cb_data->res);
free(cb_data);
1637}

1639void
1640schedule_recheck_all_resolvers(void)
1641{
struct timeval	 tv;
int		 i;

tv.tv_sec = 0;

for (i = 0; i < UW_RES_NONE; i++) {
if (resolvers[i] == NULL((void*)0))
	continue;
tv.tv_usec = arc4random() % 1000000; /* modulo bias is ok */
resolvers[i]->state = UNKNOWN;
evtimer_add(&resolvers[i]->check_ev, &tv)event_add(&resolvers[i]->check_ev, &tv);
}
1654}

1656int
1657check_forwarders_changed(struct uw_forwarder_head *list_a,
  struct uw_forwarder_head *list_b)
1659{
struct uw_forwarder	*a, *b;

a = TAILQ_FIRST(list_a)((list_a)->tqh_first);
b = TAILQ_FIRST(list_b)((list_b)->tqh_first);

while(a != NULL((void*)0) && b != NULL((void*)0)) {
if (strcmp(a->ip, b->ip) != 0)
	return 1;
if (a->port != b->port)
	return 1;
if (strcmp(a->auth_name, b->auth_name) != 0)
	return 1;
a = TAILQ_NEXT(a, entry)((a)->entry.tqe_next);
b = TAILQ_NEXT(b, entry)((b)->entry.tqe_next);
}

if (a != NULL((void*)0) || b != NULL((void*)0))
return 1;
return 0;
1679}

1681void
1682resolver_ref(struct uw_resolver *res)
1683{
if (res->ref_cnt == INT_MAX2147483647)
fatalx("%s: INT_MAX references", __func__);
res->ref_cnt++;
1687}

1689void
1690resolver_unref(struct uw_resolver *res)
1691{
struct timeval	 tv = { 0, 1};

if (res->ref_cnt == 0)
fatalx("%s: unreferenced resolver", __func__);

res->ref_cnt--;

/*
* Decouple from libunbound event callback.
* If we free the ctx inside of resolve_done or check_resovler_done
* we are cutting of the branch we are sitting on and hit a
* user-after-free
*/
if (res->stop && res->ref_cnt == 0) {
evtimer_set(&res->free_ev, resolver_free_timo, res)event_set(&res->free_ev, -1, 0, resolver_free_timo, res
);
evtimer_add(&res->free_ev, &tv)event_add(&res->free_ev, &tv);
}
1709}

1711void
1712replace_forwarders(struct uw_forwarder_head *new_list, struct
  uw_forwarder_head *old_list)
1714{
struct uw_forwarder	*uw_forwarder;

while ((uw_forwarder =
   TAILQ_FIRST(old_list)((old_list)->tqh_first)) != NULL((void*)0)) {
TAILQ_REMOVE(old_list, uw_forwarder, entry)do { if (((uw_forwarder)->entry.tqe_next) != ((void*)0)) (
uw_forwarder)->entry.tqe_next->entry.tqe_prev = (uw_forwarder
)->entry.tqe_prev; else (old_list)->tqh_last = (uw_forwarder
)->entry.tqe_prev; *(uw_forwarder)->entry.tqe_prev = (uw_forwarder
)->entry.tqe_next; ; ; } while (0);
free(uw_forwarder);
}

TAILQ_CONCAT(old_list, new_list, entry)do { if (!(((new_list)->tqh_first) == ((void*)0))) { *(old_list
)->tqh_last = (new_list)->tqh_first; (new_list)->tqh_first
->entry.tqe_prev = (old_list)->tqh_last; (old_list)->
tqh_last = (new_list)->tqh_last; do { ((new_list))->tqh_first
 = ((void*)0); ((new_list))->tqh_last = &((new_list))->
tqh_first; } while (0); } } while (0);
1724}

1726int
1727resolver_cmp(const void *_a, const void *_b)
1728{
const enum uw_resolver_type	 a = *(const enum uw_resolver_type *)_a;
const enum uw_resolver_type	 b = *(const enum uw_resolver_type *)_b;
int64_t				 a_median, b_median;

if (resolvers[a] == NULL((void*)0) && resolvers[b] == NULL((void*)0))
return 0;

if (resolvers[b] == NULL((void*)0))
return -1;

if (resolvers[a] == NULL((void*)0))
return 1;

if (resolvers[a]->state < resolvers[b]->state)
return 1;
else if (resolvers[a]->state > resolvers[b]->state)
return -1;
else {
a_median = resolvers[a]->median;
b_median = resolvers[b]->median;
if (resolvers[a]->type == resolver_conf->res_pref.types[0])
	a_median -= PREF_RESOLVER_MEDIAN_SKEW200;
else if (resolvers[b]->type == resolver_conf->res_pref.types[0])
	b_median -= PREF_RESOLVER_MEDIAN_SKEW200;
if (a_median < b_median)
	return -1;
else if (a_median > b_median)
	return 1;
else
	return 0;
}
1760}

1762void
1763restart_ub_resolvers(int recheck)
1764{
int			 i;
enum uw_resolver_state	 state;

for (i = 0; i < UW_RES_NONE; i++) {
if (i == UW_RES_ASR)
	continue;
if (recheck || resolvers[i] == NULL((void*)0))
	state = UNKNOWN;
else
	state = resolvers[i]->state;
new_resolver(i, state);
}
1777}

1779void
1780show_status(pid_t pid)
1781{
struct resolver_preference	 res_pref;
int				 i;

if (sort_resolver_types(&res_pref) == -1)
log_warn("mergesort")uw_log_warn("mergesort");

for (i = 0; i < resolver_conf->res_pref.len; i++)
send_resolver_info(resolvers[res_pref.types[i]], pid);

resolver_imsg_compose_frontend(IMSG_CTL_END, pid, NULL((void*)0), 0);
1792}

1794void
1795show_autoconf(pid_t pid)
1796{
struct uw_forwarder		*uw_forwarder;
struct ctl_forwarder_info	 cfi;

TAILQ_FOREACH(uw_forwarder, &autoconf_forwarder_list, entry)for((uw_forwarder) = ((&autoconf_forwarder_list)->tqh_first
); (uw_forwarder) != ((void*)0); (uw_forwarder) = ((uw_forwarder
)->entry.tqe_next)) {
memset(&cfi, 0, sizeof(cfi));
cfi.if_index = uw_forwarder->if_index;
cfi.src = uw_forwarder->src;
/* no truncation, structs are in sync */
memcpy(cfi.ip, uw_forwarder->ip, sizeof(cfi.ip));
resolver_imsg_compose_frontend(
    IMSG_CTL_AUTOCONF_RESOLVER_INFO,
    pid, &cfi, sizeof(cfi));
}

resolver_imsg_compose_frontend(IMSG_CTL_END, pid, NULL((void*)0), 0);
1812}

1814void
1815show_mem(pid_t pid)
1816{
struct ctl_mem_info	 cmi;

memset(&cmi, 0, sizeof(cmi));
cmi.msg_cache_used = slabhash_get_mem(unified_msg_cache);
cmi.msg_cache_max = slabhash_get_size(unified_msg_cache);
cmi.rrset_cache_used = slabhash_get_mem(&unified_rrset_cache->table);
cmi.rrset_cache_max = slabhash_get_size(&unified_rrset_cache->table);
cmi.key_cache_used = slabhash_get_mem(unified_key_cache->slab);
cmi.key_cache_max = slabhash_get_size(unified_key_cache->slab);
cmi.neg_cache_used = unified_neg_cache->use;
cmi.neg_cache_max = unified_neg_cache->max;
resolver_imsg_compose_frontend(IMSG_CTL_MEM_INFO, pid, &cmi,
   sizeof(cmi));

1831}

1833void
1834send_resolver_info(struct uw_resolver *res, pid_t pid)
1835{
struct ctl_resolver_info	 cri;
size_t				 i;

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

cri.state = res->state;
cri.type = res->type;
cri.median = res->median;

memcpy(cri.histogram, res->histogram, sizeof(cri.histogram));
memcpy(cri.latest_histogram, res->latest_histogram,
   sizeof(cri.latest_histogram));
for (i = 0; i < nitems(histogram_limits)(sizeof((histogram_limits)) / sizeof((histogram_limits)[0])); i++)
cri.latest_histogram[i] =
    (cri.latest_histogram[i] + 500) / 1000;

resolver_imsg_compose_frontend(IMSG_CTL_RESOLVER_INFO, pid, &cri,
   sizeof(cri));
1855}

1857void
1858trust_anchor_resolve(void)
1859{
struct resolver_preference	 res_pref;
struct uw_resolver		*res;
struct timeval			 tv = {TRUST_ANCHOR_RETRY_INTERVAL8640, 0};

if (sort_resolver_types(&res_pref) == -1)
log_warn("mergesort")uw_log_warn("mergesort");

res = resolvers[res_pref.types[0]];

if (res == NULL((void*)0) || res->state < VALIDATING)
goto err;

if (resolve(res, ".",  LDNS_RR_TYPE_DNSKEY, LDNS_RR_CLASS_IN, NULL((void*)0),
   trust_anchor_resolve_done) != 0)
goto err;

return;
err:
evtimer_add(&trust_anchor_timer, &tv)event_add(&trust_anchor_timer, &tv);
1879}

1881void
1882trust_anchor_timo(int fd, short events, void *arg)
1883{
trust_anchor_resolve();
1885}

1887void
1888trust_anchor_resolve_done(struct uw_resolver *res, void *arg, int rcode,
  void *answer_packet, int answer_len, int sec, char *why_bogus)
1890{
struct ub_result	*result = NULL((void*)0);
sldns_buffer		*buf = NULL((void*)0);
struct regional		*region = NULL((void*)0);
struct timeval		 tv = {TRUST_ANCHOR_RETRY_INTERVAL8640, 0};
int			 i, tas, n;
uint16_t		 dnskey_flags;
char			 rdata_buf[1024], *ta;

if (answer_len < LDNS_HEADER_SIZE12) {
log_warnx("bad packet: too short");
goto out;
}

if ((result = calloc(1, sizeof(*result))) == NULL((void*)0))
goto out;

if (sec != SECURE2)
goto out;

if ((buf = sldns_buffer_new(answer_len)) == NULL((void*)0))
goto out;
if ((region = regional_create()) == NULL((void*)0))
goto out;
result->rcode = LDNS_RCODE_SERVFAIL;

sldns_buffer_clear(buf);
sldns_buffer_write(buf, answer_packet, answer_len);
sldns_buffer_flip(buf);
libworker_enter_result(result, buf, region, sec);
result->answer_packet = NULL((void*)0);
result->answer_len = 0;

if (result->rcode != LDNS_RCODE_NOERROR)
goto out;

i = 0;
tas = 0;
while(result->data[i] != NULL((void*)0)) {
if (result->len[i] < 2) {
	if (tas > 0)
		resolver_imsg_compose_frontend(
		    IMSG_NEW_TAS_ABORT, 0, NULL((void*)0), 0);
	goto out;
}
n = sldns_wire2str_rdata_buf(result->data[i], result->len[i],
    rdata_buf, sizeof(rdata_buf), LDNS_RR_TYPE_DNSKEY);

if (n < 0 || (size_t)n >= sizeof(rdata_buf)) {
	log_warnx("trust anchor buffer to small");
	resolver_imsg_compose_frontend(IMSG_NEW_TAS_ABORT, 0,
	    NULL((void*)0), 0);
	goto out;
}

memcpy(&dnskey_flags, result->data[i], 2);
dnskey_flags = ntohs(dnskey_flags)(__uint16_t)(__builtin_constant_p(dnskey_flags) ? (__uint16_t
)(((__uint16_t)(dnskey_flags) & 0xffU) << 8 | ((__uint16_t
)(dnskey_flags) & 0xff00U) >> 8) : __swap16md(dnskey_flags
));
if ((dnskey_flags & LDNS_KEY_SEP_KEY0x0001) && !(dnskey_flags &
    LDNS_KEY_REVOKE_KEY0x0080)) {
	asprintf(&ta, ".\t%d\tIN\tDNSKEY\t%s", ROOT_DNSKEY_TTL172800,
	    rdata_buf);
	resolver_imsg_compose_frontend(IMSG_NEW_TA, 0, ta,
	    strlen(ta) + 1);
	tas++;
	free(ta);
}
i++;
}
if (tas > 0) {
resolver_imsg_compose_frontend(IMSG_NEW_TAS_DONE, 0, NULL((void*)0), 0);
tv.tv_sec = TRUST_ANCHOR_QUERY_INTERVAL43200;
}
1962out:
sldns_buffer_free(buf);
regional_destroy(region);
ub_resolve_free(result);
evtimer_add(&trust_anchor_timer, &tv)event_add(&trust_anchor_timer, &tv);
1967}

1969void
1970replace_autoconf_forwarders(struct imsg_rdns_proposal *rdns_proposal)
1971{
struct uw_forwarder_head	 new_forwarder_list;
struct uw_forwarder		*uw_forwarder, *tmp;
size_t				 addrsz;
int				 i, rdns_count, af, changed = 0;
char				 hostbuf[INET6_ADDRSTRLEN46], *src;

TAILQ_INIT(&new_forwarder_list)do { (&new_forwarder_list)->tqh_first = ((void*)0); (&
new_forwarder_list)->tqh_last = &(&new_forwarder_list
)->tqh_first; } while (0);
af = rdns_proposal->rtdns.sr_family;
src = rdns_proposal->rtdns.sr_dns;

switch (af) {
case AF_INET2:
addrsz = sizeof(struct in_addr);
break;
case AF_INET624:
addrsz = sizeof(struct in6_addr);
break;
default:
log_warnx("%s: unsupported address family: %d", __func__, af);
return;
}

if ((rdns_proposal->rtdns.sr_len - 2) % addrsz != 0) {
log_warnx("ignoring invalid RTM_PROPOSAL");
return;
}
rdns_count = (rdns_proposal->rtdns.sr_len -
   offsetof(struct sockaddr_rtdns, sr_dns)__builtin_offsetof(struct sockaddr_rtdns, sr_dns)) / addrsz;

for (i = 0; i < rdns_count; i++) {
struct sockaddr_storage ss;
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&ss;
struct sockaddr_in *sin = (struct sockaddr_in *)&ss;
int err;

memset(&ss, 0, sizeof(ss));
ss.ss_family = af;
switch (af) {
case AF_INET2:
	memcpy(&sin->sin_addr, src, addrsz);
	if (sin->sin_addr.s_addr == htonl(INADDR_LOOPBACK)(__uint32_t)(__builtin_constant_p(((u_int32_t)(0x7f000001))) ?
 (__uint32_t)(((__uint32_t)(((u_int32_t)(0x7f000001))) & 0xff
) << 24 | ((__uint32_t)(((u_int32_t)(0x7f000001))) &
 0xff00) << 8 | ((__uint32_t)(((u_int32_t)(0x7f000001))
) & 0xff0000) >> 8 | ((__uint32_t)(((u_int32_t)(0x7f000001
))) & 0xff000000) >> 24) : __swap32md(((u_int32_t)(
0x7f000001)))))
		goto skip;
	ss.ss_len = sizeof(*sin);
	break;
case AF_INET624:
	memcpy(&sin6->sin6_addr, src, addrsz);
	if (IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr)((*(const u_int32_t *)(const void *)(&(&sin6->sin6_addr
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&sin6->sin6_addr)->__u6_addr
.__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
 *)(&(&sin6->sin6_addr)->__u6_addr.__u6_addr8[8
]) == 0) && (*(const u_int32_t *)(const void *)(&
(&sin6->sin6_addr)->__u6_addr.__u6_addr8[12]) == (__uint32_t
)(__builtin_constant_p(1) ? (__uint32_t)(((__uint32_t)(1) &
 0xff) << 24 | ((__uint32_t)(1) & 0xff00) << 8
 | ((__uint32_t)(1) & 0xff0000) >> 8 | ((__uint32_t
)(1) & 0xff000000) >> 24) : __swap32md(1)))))
		goto skip;
	if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)(((&sin6->sin6_addr)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&sin6->sin6_addr)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80)))
		sin6->sin6_scope_id = rdns_proposal->if_index;
	ss.ss_len = sizeof(*sin6);
	break;
}
if ((err = getnameinfo((struct sockaddr *)&ss, ss.ss_len,
    hostbuf, sizeof(hostbuf), NULL((void*)0), 0, NI_NUMERICHOST1)) != 0) {
	log_warnx("getnameinfo: %s", gai_strerror(err));
	goto skip;
}

if ((uw_forwarder = calloc(1, sizeof(struct uw_forwarder))) ==
    NULL((void*)0))
	fatal(NULL((void*)0));
if (strlcpy(uw_forwarder->ip, hostbuf, sizeof(uw_forwarder->ip))
    >= sizeof(uw_forwarder->ip))
	fatalx("strlcpy");
uw_forwarder->port = 53;
uw_forwarder->if_index = rdns_proposal->if_index;
uw_forwarder->src = rdns_proposal->src;
TAILQ_INSERT_TAIL(&new_forwarder_list, uw_forwarder, entry)do { (uw_forwarder)->entry.tqe_next = ((void*)0); (uw_forwarder
)->entry.tqe_prev = (&new_forwarder_list)->tqh_last
; *(&new_forwarder_list)->tqh_last = (uw_forwarder); (
&new_forwarder_list)->tqh_last = &(uw_forwarder)->
entry.tqe_next; } while (0);

2042skip:
src += addrsz;
}

TAILQ_FOREACH(tmp, &autoconf_forwarder_list, entry)for((tmp) = ((&autoconf_forwarder_list)->tqh_first); (
tmp) != ((void*)0); (tmp) = ((tmp)->entry.tqe_next)) {
/*
 * if_index of zero signals to clear all proposals
 * src of zero signals interface gone
 */
if ((rdns_proposal->src == 0 || rdns_proposal->src ==
    tmp->src) && (rdns_proposal->if_index == 0 ||
    rdns_proposal->if_index == tmp->if_index))
	continue;
if ((uw_forwarder = calloc(1, sizeof(struct uw_forwarder))) ==
    NULL((void*)0))
	fatal(NULL((void*)0));
if (strlcpy(uw_forwarder->ip, tmp->ip,
    sizeof(uw_forwarder->ip)) >= sizeof(uw_forwarder->ip))
	fatalx("strlcpy");
uw_forwarder->port = tmp->port;
uw_forwarder->src = tmp->src;
uw_forwarder->if_index = tmp->if_index;
TAILQ_INSERT_TAIL(&new_forwarder_list, uw_forwarder, entry)do { (uw_forwarder)->entry.tqe_next = ((void*)0); (uw_forwarder
)->entry.tqe_prev = (&new_forwarder_list)->tqh_last
; *(&new_forwarder_list)->tqh_last = (uw_forwarder); (
&new_forwarder_list)->tqh_last = &(uw_forwarder)->
entry.tqe_next; } while (0);
}

changed = check_forwarders_changed(&new_forwarder_list,
   &autoconf_forwarder_list);

if (changed) {
replace_forwarders(&new_forwarder_list,
    &autoconf_forwarder_list);
new_resolver(UW_RES_ASR, UNKNOWN);
new_resolver(UW_RES_AUTOCONF, UNKNOWN);
new_resolver(UW_RES_ODOT_AUTOCONF, UNKNOWN);
} else {
while ((tmp = TAILQ_FIRST(&new_forwarder_list)((&new_forwarder_list)->tqh_first)) != NULL((void*)0)) {
	TAILQ_REMOVE(&new_forwarder_list, tmp, entry)do { if (((tmp)->entry.tqe_next) != ((void*)0)) (tmp)->
entry.tqe_next->entry.tqe_prev = (tmp)->entry.tqe_prev;
 else (&new_forwarder_list)->tqh_last = (tmp)->entry
.tqe_prev; *(tmp)->entry.tqe_prev = (tmp)->entry.tqe_next
; ; ; } while (0);
	free(tmp);
}
}
2082}

2084int
2085force_tree_cmp(struct force_tree_entry *a, struct force_tree_entry *b)
2086{
return strcasecmp(a->domain, b->domain);
2088}

2090int
2091find_force(struct force_tree *tree, char *qname, struct uw_resolver **res)
2092{
struct force_tree_entry	*n, e;
char 			*p;

if (res)
*res = NULL((void*)0);
if (RB_EMPTY(tree)((tree)->rbh_root == ((void*)0)))
return 0;

p = qname;
do {
if (strlcpy(e.domain, p, sizeof(e.domain)) >= sizeof(e.domain))
	fatal("qname too large");
n = RB_FIND(force_tree, tree, &e)force_tree_RB_FIND(tree, &e);
if (n != NULL((void*)0)) {
	log_debug("%s: %s -> %s[%s]", __func__, qname, p,
	    uw_resolver_type_str[n->type]);
	if (res)
		*res = resolvers[n->type];
	return n->acceptbogus;
}
if (*p == '.')
	p++;
p = strchr(p, '.');
if (p != NULL((void*)0) && p[1] != '\0')
	p++;
} while (p != NULL((void*)0));
return 0;

2121}

2123int64_t
2124histogram_median(int64_t *histogram)
2125{
size_t	 i;
int64_t	 sample_count = 0, running_count = 0;

/* skip first bucket, it contains cache hits */
for (i = 1; i < nitems(histogram_limits)(sizeof((histogram_limits)) / sizeof((histogram_limits)[0])); i++)
sample_count += histogram[i];

if (sample_count == 0)
return 0;

for (i = 1; i < nitems(histogram_limits)(sizeof((histogram_limits)) / sizeof((histogram_limits)[0])); i++) {
running_count += histogram[i];
if (running_count >= sample_count / 2)
	break;
}

if (i >= nitems(histogram_limits)(sizeof((histogram_limits)) / sizeof((histogram_limits)[0])) - 1)
return INT64_MAX0x7fffffffffffffffLL;
return (histogram_limits[i - 1] + histogram_limits[i]) / 2;
2145}

2147void
2148decay_latest_histograms(int fd, short events, void *arg)
2149{
enum uw_resolver_type	 i;
size_t			 j;
struct uw_resolver	*res;
struct timeval		 tv = {DECAY_PERIOD60, 0};

for (i = 0; i < UW_RES_NONE; i++) {
res = resolvers[i];
if (res == NULL((void*)0))
	continue;
for (j = 0; j < nitems(res->latest_histogram)(sizeof((res->latest_histogram)) / sizeof((res->latest_histogram
)[0])); j++)
	/* multiply then divide, avoiding truncating to 0 */
	res->latest_histogram[j] = res->latest_histogram[j] *
	    DECAY_NOMINATOR9 / DECAY_DENOMINATOR10;
res->median = histogram_median(res->latest_histogram);
}
evtimer_add(&decay_timer, &tv)event_add(&decay_timer, &tv);
2166}

2168int
2169running_query_cnt(void)
2170{
struct running_query	*e;
int			 cnt = 0;

TAILQ_FOREACH(e, &running_queries, entry)for((e) = ((&running_queries)->tqh_first); (e) != ((void
*)0); (e) = ((e)->entry.tqe_next))
cnt++;
return cnt;
2177}

2179int *
2180resolvers_to_restart(struct uw_conf *oconf, struct uw_conf *nconf)
2181{
static int	 restart[UW_RES_NONE];
int		 i;

memset(&restart, 0, sizeof(restart));
if (check_forwarders_changed(&oconf->uw_forwarder_list,
   &nconf->uw_forwarder_list)) {
restart[UW_RES_FORWARDER] = 1;
restart[UW_RES_ODOT_FORWARDER] = 1;
}
if (check_forwarders_changed(&oconf->uw_dot_forwarder_list,
   &nconf->uw_dot_forwarder_list)) {
restart[UW_RES_DOT] = 1;
}

for (i = 0; i < UW_RES_NONE; i++) {
if (oconf->enabled_resolvers[i] != nconf->enabled_resolvers[i])
	restart[i] = 1;
}
return restart;
2201}

2203const char *
2204query_imsg2str(struct query_imsg *query_imsg)
2205{
static char	 buf[sizeof(query_imsg->qname) + 1 + 16 + 1 + 16];
char		 qclass_buf[16];
char		 qtype_buf[16];

sldns_wire2str_class_buf(query_imsg->c, qclass_buf, sizeof(qclass_buf));
sldns_wire2str_type_buf(query_imsg->t, qtype_buf, sizeof(qtype_buf));

snprintf(buf, sizeof(buf), "%s %s %s", query_imsg->qname, qclass_buf,
   qtype_buf);
return buf;
2216}

2218char *
2219gen_resolv_conf()
2220{
struct uw_forwarder	*uw_forwarder;
char			*resolv_conf = NULL((void*)0), *tmp = NULL((void*)0);

TAILQ_FOREACH(uw_forwarder, &autoconf_forwarder_list, entry)for((uw_forwarder) = ((&autoconf_forwarder_list)->tqh_first
); (uw_forwarder) != ((void*)0); (uw_forwarder) = ((uw_forwarder
)->entry.tqe_next)) {
tmp = resolv_conf;
if (asprintf(&resolv_conf, "%snameserver %s\n", tmp ==
    NULL((void*)0) ? "" : tmp, uw_forwarder->ip) == -1) {
	free(tmp);
	return (NULL((void*)0));
}
free(tmp);
}
return resolv_conf;
2234}

2236void
2237check_dns64(void)
2238{
struct asr_query	*aq = NULL((void*)0);
char			*resolv_conf;
void			*asr_ctx;

if (TAILQ_EMPTY(&autoconf_forwarder_list)(((&autoconf_forwarder_list)->tqh_first) == ((void*)0)
))
return;

if ((resolv_conf = gen_resolv_conf()) == NULL((void*)0)) {
log_warnx("could not create asr context");
return;
}

if ((asr_ctx = asr_resolver_from_string(resolv_conf)) != NULL((void*)0)) {
if ((aq = res_query_async("ipv4only.arpa", LDNS_RR_CLASS_IN,
    LDNS_RR_TYPE_AAAA, asr_ctx)) == NULL((void*)0)) {
	log_warn("%s: res_query_async", __func__)uw_log_warn("%s: res_query_async", __func__);
	asr_resolver_free(asr_ctx);
}
if (event_asr_run(aq, check_dns64_done, asr_ctx) == NULL((void*)0)) {
	log_warn("%s: event_asr_run", __func__)uw_log_warn("%s: event_asr_run", __func__);
	free(aq);
	asr_resolver_free(asr_ctx);
}
} else
log_warnx("%s: could not create asr context", __func__);

free(resolv_conf);
2266}

2268void
2269check_dns64_done(struct asr_result *ar, void *arg)
2270{
/* RFC 7050: ipv4only.arpa resolves to 192.0.0.170 and 192.9.0.171 */
const uint8_t			 wka1[] = {192, 0, 0, 170};
const uint8_t			 wka2[] = {192, 0, 0, 171};
struct query_info		 skip, qinfo;
struct reply_info		*rinfo = NULL((void*)0);
struct regional			*region = NULL((void*)0);
struct sldns_buffer		*buf = NULL((void*)0);
struct ub_packed_rrset_key	*an_rrset = NULL((void*)0);
struct packed_rrset_data	*an_rrset_data;
struct alloc_cache		 alloc;
struct edns_data		 edns;
struct dns64_prefix		*prefixes = NULL((void*)0);
size_t				 i;
int				 preflen, count = 0;
void				*asr_ctx = arg;

memset(&qinfo, 0, sizeof(qinfo));
alloc_init(&alloc, NULL((void*)0), 0);

if (ar->ar_datalen < LDNS_HEADER_SIZE12) {
log_warnx("%s: bad packet: too short: %d", __func__,
    ar->ar_datalen);
goto out;
}

if (ar->ar_datalen > UINT16_MAX0xffff) {
log_warnx("%s: bad packet: too large: %d", __func__,
    ar->ar_datalen);
goto out;
}

if (ar->ar_rcode == LDNS_RCODE_NXDOMAIN) {
/* XXX this means that the autoconf resolver is broken */
log_debug("%s: NXDOMAIN", __func__);
goto out;
}

if ((buf = sldns_buffer_new(ar->ar_datalen)) == NULL((void*)0))
goto out;

if ((region = regional_create()) == NULL((void*)0))
goto out;

sldns_buffer_write(buf, ar->ar_data, ar->ar_datalen);
sldns_buffer_flip(buf);

/* read past query section, no memory is allocated */
if (!query_info_parse(&skip, buf))
goto out;

if (reply_info_parse(buf, &alloc, &qinfo, &rinfo, region, &edns) != 0)
goto out;

if ((an_rrset = reply_find_answer_rrset(&qinfo, rinfo)) == NULL((void*)0))
goto out;

an_rrset_data = (struct packed_rrset_data*)an_rrset->entry.data;

prefixes = calloc(an_rrset_data->count, sizeof(struct dns64_prefix));
if (prefixes == NULL((void*)0))
goto out;

for (i = 0; i < an_rrset_data->count; i++) {
struct in6_addr	 in6;

/* check for AAAA record */
if (an_rrset_data->rr_len[i] != 18) /* 2 + 128/8 */
	continue;
if (an_rrset_data->rr_data[i][0] != 0 &&
    an_rrset_data->rr_data[i][1] != 16)
	continue;

memcpy(&in6, &an_rrset_data->rr_data[i][2],
    sizeof(in6));
if ((preflen = dns64_prefixlen(&in6, wka1)) != -1)
	add_dns64_prefix(&in6, preflen, prefixes,
	    an_rrset_data->count, WKA1_FOUND1);
if ((preflen = dns64_prefixlen(&in6, wka2)) != -1)
	add_dns64_prefix(&in6, preflen, prefixes,
	    an_rrset_data->count, WKA2_FOUND2);
}

for (i = 0; i < an_rrset_data->count && prefixes[i].flags != 0; i++)
if ((prefixes[i].flags & (WKA1_FOUND1 | WKA2_FOUND2)) ==
    (WKA1_FOUND1 | WKA2_FOUND2))
	count++;

dns64_present = count > 0;

if (dns64_present) {
/* downgrade SLAAC resolvers, DNS64 breaks DNSSEC */
if (resolvers[UW_RES_AUTOCONF] != NULL((void*)0) &&
    resolvers[UW_RES_AUTOCONF]->state == VALIDATING)
	new_resolver(UW_RES_AUTOCONF, RESOLVING);
if (resolvers[UW_RES_ODOT_AUTOCONF] != NULL((void*)0) &&
    resolvers[UW_RES_ODOT_AUTOCONF]->state == VALIDATING)
	new_resolver(UW_RES_ODOT_AUTOCONF, RESOLVING);
}

resolver_imsg_compose_frontend(IMSG_NEW_DNS64_PREFIXES_START, 0,
   &count, sizeof(count));
for (i = 0; i < an_rrset_data->count && prefixes[i].flags != 0; i++) {
if ((prefixes[i].flags & (WKA1_FOUND1 | WKA2_FOUND2)) ==
    (WKA1_FOUND1 | WKA2_FOUND2)) {
	resolver_imsg_compose_frontend(IMSG_NEW_DNS64_PREFIX,
	    0, &prefixes[i], sizeof(struct dns64_prefix));
}
}
resolver_imsg_compose_frontend(IMSG_NEW_DNS64_PREFIXES_DONE, 0, NULL((void*)0),
   0);
out:
free(prefixes);
query_info_clear(&qinfo);
reply_info_parsedelete(rinfo, &alloc);
alloc_clear(&alloc);
regional_destroy(region);
sldns_buffer_free(buf);
free(ar->ar_data);
asr_resolver_free(asr_ctx);
2390}

2392int
2393dns64_prefixlen(const struct in6_addr *in6, const uint8_t *wka)
2394{
/* RFC 6052, 2.2 */
static const int	 possible_prefixes[] = {32, 40, 48, 56, 64, 96};
size_t			 i, j;
int			 found, pos;

for (i = 0; i < nitems(possible_prefixes)(sizeof((possible_prefixes)) / sizeof((possible_prefixes)[0])
); i++) {
pos = possible_prefixes[i] / 8;
found = 1;
for (j = 0; j < 4 && found; j++, pos++) {
	if (pos == 8) {
		if (in6->s6_addr__u6_addr.__u6_addr8[pos] != 0)
			found = 0;
		pos++;
	}
	if (in6->s6_addr__u6_addr.__u6_addr8[pos] != wka[j])
		found = 0;
}
if (found)
	return possible_prefixes[i];
}
return -1;
2416}

2418void
2419add_dns64_prefix(const struct in6_addr *in6, int prefixlen,
  struct dns64_prefix *prefixes, int prefixes_size, int flag)
2421{
struct in6_addr	 tmp;
int		 i;

tmp = *in6;

for(i = prefixlen / 8; i < 16; i++)
tmp.s6_addr__u6_addr.__u6_addr8[i] = 0;

for (i = 0; i < prefixes_size; i++) {
if (prefixes[i].flags == 0) {
	prefixes[i].in6 = tmp;
	prefixes[i].prefixlen = prefixlen;
	prefixes[i].flags |= flag;
	break;
} else if (prefixes[i].prefixlen == prefixlen &&
    memcmp(&prefixes[i].in6, &tmp, sizeof(tmp)) == 0) {
	prefixes[i].flags |= flag;
	break;
}
}
2442}