xref: /freebsd/contrib/unbound/libunbound/libworker.c (revision f44e67d120ad78ef7894241b519ee79fd190a16e)
1b7579f77SDag-Erling Smørgrav /*
2b7579f77SDag-Erling Smørgrav  * libunbound/worker.c - worker thread or process that resolves
3b7579f77SDag-Erling Smørgrav  *
4b7579f77SDag-Erling Smørgrav  * Copyright (c) 2007, NLnet Labs. All rights reserved.
5b7579f77SDag-Erling Smørgrav  *
6b7579f77SDag-Erling Smørgrav  * This software is open source.
7b7579f77SDag-Erling Smørgrav  *
8b7579f77SDag-Erling Smørgrav  * Redistribution and use in source and binary forms, with or without
9b7579f77SDag-Erling Smørgrav  * modification, are permitted provided that the following conditions
10b7579f77SDag-Erling Smørgrav  * are met:
11b7579f77SDag-Erling Smørgrav  *
12b7579f77SDag-Erling Smørgrav  * Redistributions of source code must retain the above copyright notice,
13b7579f77SDag-Erling Smørgrav  * this list of conditions and the following disclaimer.
14b7579f77SDag-Erling Smørgrav  *
15b7579f77SDag-Erling Smørgrav  * Redistributions in binary form must reproduce the above copyright notice,
16b7579f77SDag-Erling Smørgrav  * this list of conditions and the following disclaimer in the documentation
17b7579f77SDag-Erling Smørgrav  * and/or other materials provided with the distribution.
18b7579f77SDag-Erling Smørgrav  *
19b7579f77SDag-Erling Smørgrav  * Neither the name of the NLNET LABS nor the names of its contributors may
20b7579f77SDag-Erling Smørgrav  * be used to endorse or promote products derived from this software without
21b7579f77SDag-Erling Smørgrav  * specific prior written permission.
22b7579f77SDag-Erling Smørgrav  *
23b7579f77SDag-Erling Smørgrav  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
2417d15b25SDag-Erling Smørgrav  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
2517d15b25SDag-Erling Smørgrav  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
2617d15b25SDag-Erling Smørgrav  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
2717d15b25SDag-Erling Smørgrav  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
2817d15b25SDag-Erling Smørgrav  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
2917d15b25SDag-Erling Smørgrav  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
3017d15b25SDag-Erling Smørgrav  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
3117d15b25SDag-Erling Smørgrav  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
3217d15b25SDag-Erling Smørgrav  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
3317d15b25SDag-Erling Smørgrav  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34b7579f77SDag-Erling Smørgrav  */
35b7579f77SDag-Erling Smørgrav 
36b7579f77SDag-Erling Smørgrav /**
37b7579f77SDag-Erling Smørgrav  * \file
38b7579f77SDag-Erling Smørgrav  *
39b7579f77SDag-Erling Smørgrav  * This file contains the worker process or thread that performs
40b7579f77SDag-Erling Smørgrav  * the DNS resolving and validation. The worker is called by a procedure
41b7579f77SDag-Erling Smørgrav  * and if in the background continues until exit, if in the foreground
42b7579f77SDag-Erling Smørgrav  * returns from the procedure when done.
43b7579f77SDag-Erling Smørgrav  */
44b7579f77SDag-Erling Smørgrav #include "config.h"
458ed2b524SDag-Erling Smørgrav #ifdef HAVE_SSL
46b7579f77SDag-Erling Smørgrav #include <openssl/ssl.h>
478ed2b524SDag-Erling Smørgrav #endif
48b7579f77SDag-Erling Smørgrav #include "libunbound/libworker.h"
49b7579f77SDag-Erling Smørgrav #include "libunbound/context.h"
50b7579f77SDag-Erling Smørgrav #include "libunbound/unbound.h"
5104b59eacSDag-Erling Smørgrav #include "libunbound/worker.h"
5217d15b25SDag-Erling Smørgrav #include "libunbound/unbound-event.h"
53b7579f77SDag-Erling Smørgrav #include "services/outside_network.h"
54b7579f77SDag-Erling Smørgrav #include "services/mesh.h"
55b7579f77SDag-Erling Smørgrav #include "services/localzone.h"
56b7579f77SDag-Erling Smørgrav #include "services/cache/rrset.h"
57b7579f77SDag-Erling Smørgrav #include "services/outbound_list.h"
5857bddd21SDag-Erling Smørgrav #include "services/authzone.h"
5904b59eacSDag-Erling Smørgrav #include "util/fptr_wlist.h"
60b7579f77SDag-Erling Smørgrav #include "util/module.h"
61b7579f77SDag-Erling Smørgrav #include "util/regional.h"
62b7579f77SDag-Erling Smørgrav #include "util/random.h"
63b7579f77SDag-Erling Smørgrav #include "util/config_file.h"
64b7579f77SDag-Erling Smørgrav #include "util/netevent.h"
65b7579f77SDag-Erling Smørgrav #include "util/storage/lookup3.h"
66b7579f77SDag-Erling Smørgrav #include "util/storage/slabhash.h"
67b7579f77SDag-Erling Smørgrav #include "util/net_help.h"
68b7579f77SDag-Erling Smørgrav #include "util/data/dname.h"
69b7579f77SDag-Erling Smørgrav #include "util/data/msgreply.h"
70b7579f77SDag-Erling Smørgrav #include "util/data/msgencode.h"
71b7579f77SDag-Erling Smørgrav #include "util/tube.h"
72b7579f77SDag-Erling Smørgrav #include "iterator/iter_fwd.h"
73b7579f77SDag-Erling Smørgrav #include "iterator/iter_hints.h"
7409a3aaf3SDag-Erling Smørgrav #include "sldns/sbuffer.h"
7509a3aaf3SDag-Erling Smørgrav #include "sldns/str2wire.h"
76*f44e67d1SCy Schubert #ifdef USE_DNSTAP
77*f44e67d1SCy Schubert #include "dnstap/dtstream.h"
78*f44e67d1SCy Schubert #endif
79b7579f77SDag-Erling Smørgrav 
8025039b37SCy Schubert #ifdef HAVE_TARGETCONDITIONALS_H
8125039b37SCy Schubert #include <TargetConditionals.h>
8225039b37SCy Schubert #endif
8325039b37SCy Schubert 
84c0caa2e2SCy Schubert #if (defined(TARGET_OS_TV) && TARGET_OS_TV) || (defined(TARGET_OS_WATCH) && TARGET_OS_WATCH)
8525039b37SCy Schubert #undef HAVE_FORK
8625039b37SCy Schubert #endif
8725039b37SCy Schubert 
88b7579f77SDag-Erling Smørgrav /** handle new query command for bg worker */
89b7579f77SDag-Erling Smørgrav static void handle_newq(struct libworker* w, uint8_t* buf, uint32_t len);
90b7579f77SDag-Erling Smørgrav 
9117d15b25SDag-Erling Smørgrav /** delete libworker env */
92b7579f77SDag-Erling Smørgrav static void
9317d15b25SDag-Erling Smørgrav libworker_delete_env(struct libworker* w)
94b7579f77SDag-Erling Smørgrav {
95b7579f77SDag-Erling Smørgrav 	if(w->env) {
96b7579f77SDag-Erling Smørgrav 		outside_network_quit_prepare(w->back);
97b7579f77SDag-Erling Smørgrav 		mesh_delete(w->env->mesh);
98b7579f77SDag-Erling Smørgrav 		context_release_alloc(w->ctx, w->env->alloc,
99b7579f77SDag-Erling Smørgrav 			!w->is_bg || w->is_bg_thread);
10017d15b25SDag-Erling Smørgrav 		sldns_buffer_free(w->env->scratch_buffer);
101b7579f77SDag-Erling Smørgrav 		regional_destroy(w->env->scratch);
102b7579f77SDag-Erling Smørgrav 		forwards_delete(w->env->fwds);
103b7579f77SDag-Erling Smørgrav 		hints_delete(w->env->hints);
104b7579f77SDag-Erling Smørgrav 		ub_randfree(w->env->rnd);
105b7579f77SDag-Erling Smørgrav 		free(w->env);
106b7579f77SDag-Erling Smørgrav 	}
1078ed2b524SDag-Erling Smørgrav #ifdef HAVE_SSL
108b7579f77SDag-Erling Smørgrav 	SSL_CTX_free(w->sslctx);
1098ed2b524SDag-Erling Smørgrav #endif
110b7579f77SDag-Erling Smørgrav 	outside_network_delete(w->back);
11117d15b25SDag-Erling Smørgrav }
11217d15b25SDag-Erling Smørgrav 
11317d15b25SDag-Erling Smørgrav /** delete libworker struct */
11417d15b25SDag-Erling Smørgrav static void
11517d15b25SDag-Erling Smørgrav libworker_delete(struct libworker* w)
11617d15b25SDag-Erling Smørgrav {
11717d15b25SDag-Erling Smørgrav 	if(!w) return;
11817d15b25SDag-Erling Smørgrav 	libworker_delete_env(w);
119b7579f77SDag-Erling Smørgrav 	comm_base_delete(w->base);
120b7579f77SDag-Erling Smørgrav 	free(w);
121b7579f77SDag-Erling Smørgrav }
122b7579f77SDag-Erling Smørgrav 
12317d15b25SDag-Erling Smørgrav void
12417d15b25SDag-Erling Smørgrav libworker_delete_event(struct libworker* w)
12517d15b25SDag-Erling Smørgrav {
12617d15b25SDag-Erling Smørgrav 	if(!w) return;
12717d15b25SDag-Erling Smørgrav 	libworker_delete_env(w);
12817d15b25SDag-Erling Smørgrav 	comm_base_delete_no_base(w->base);
12917d15b25SDag-Erling Smørgrav 	free(w);
13017d15b25SDag-Erling Smørgrav }
13117d15b25SDag-Erling Smørgrav 
132b7579f77SDag-Erling Smørgrav /** setup fresh libworker struct */
133b7579f77SDag-Erling Smørgrav static struct libworker*
134e2d15004SDag-Erling Smørgrav libworker_setup(struct ub_ctx* ctx, int is_bg, struct ub_event_base* eb)
135b7579f77SDag-Erling Smørgrav {
136b7579f77SDag-Erling Smørgrav 	struct libworker* w = (struct libworker*)calloc(1, sizeof(*w));
137b7579f77SDag-Erling Smørgrav 	struct config_file* cfg = ctx->env->cfg;
138b7579f77SDag-Erling Smørgrav 	int* ports;
139b7579f77SDag-Erling Smørgrav 	int numports;
140b7579f77SDag-Erling Smørgrav 	if(!w) return NULL;
141b7579f77SDag-Erling Smørgrav 	w->is_bg = is_bg;
142b7579f77SDag-Erling Smørgrav 	w->ctx = ctx;
143b7579f77SDag-Erling Smørgrav 	w->env = (struct module_env*)malloc(sizeof(*w->env));
144b7579f77SDag-Erling Smørgrav 	if(!w->env) {
145b7579f77SDag-Erling Smørgrav 		free(w);
146b7579f77SDag-Erling Smørgrav 		return NULL;
147b7579f77SDag-Erling Smørgrav 	}
148b7579f77SDag-Erling Smørgrav 	*w->env = *ctx->env;
149b7579f77SDag-Erling Smørgrav 	w->env->alloc = context_obtain_alloc(ctx, !w->is_bg || w->is_bg_thread);
150b7579f77SDag-Erling Smørgrav 	if(!w->env->alloc) {
151b7579f77SDag-Erling Smørgrav 		libworker_delete(w);
152b7579f77SDag-Erling Smørgrav 		return NULL;
153b7579f77SDag-Erling Smørgrav 	}
154b7579f77SDag-Erling Smørgrav 	w->thread_num = w->env->alloc->thread_num;
155b7579f77SDag-Erling Smørgrav 	alloc_set_id_cleanup(w->env->alloc, &libworker_alloc_cleanup, w);
156b7579f77SDag-Erling Smørgrav 	if(!w->is_bg || w->is_bg_thread) {
157b7579f77SDag-Erling Smørgrav 		lock_basic_lock(&ctx->cfglock);
158b7579f77SDag-Erling Smørgrav 	}
159b7579f77SDag-Erling Smørgrav 	w->env->scratch = regional_create_custom(cfg->msg_buffer_size);
16017d15b25SDag-Erling Smørgrav 	w->env->scratch_buffer = sldns_buffer_new(cfg->msg_buffer_size);
161b7579f77SDag-Erling Smørgrav 	w->env->fwds = forwards_create();
162b7579f77SDag-Erling Smørgrav 	if(w->env->fwds && !forwards_apply_cfg(w->env->fwds, cfg)) {
163b7579f77SDag-Erling Smørgrav 		forwards_delete(w->env->fwds);
164b7579f77SDag-Erling Smørgrav 		w->env->fwds = NULL;
165b7579f77SDag-Erling Smørgrav 	}
166b7579f77SDag-Erling Smørgrav 	w->env->hints = hints_create();
167b7579f77SDag-Erling Smørgrav 	if(w->env->hints && !hints_apply_cfg(w->env->hints, cfg)) {
168b7579f77SDag-Erling Smørgrav 		hints_delete(w->env->hints);
169b7579f77SDag-Erling Smørgrav 		w->env->hints = NULL;
170b7579f77SDag-Erling Smørgrav 	}
1713bd4df0aSDag-Erling Smørgrav 	if(cfg->ssl_upstream || (cfg->tls_cert_bundle && cfg->tls_cert_bundle[0]) || cfg->tls_win_cert) {
17257bddd21SDag-Erling Smørgrav 		w->sslctx = connect_sslctx_create(NULL, NULL,
1733bd4df0aSDag-Erling Smørgrav 			cfg->tls_cert_bundle, cfg->tls_win_cert);
174b7579f77SDag-Erling Smørgrav 		if(!w->sslctx) {
175b7579f77SDag-Erling Smørgrav 			/* to make the setup fail after unlock */
176b7579f77SDag-Erling Smørgrav 			hints_delete(w->env->hints);
177b7579f77SDag-Erling Smørgrav 			w->env->hints = NULL;
178b7579f77SDag-Erling Smørgrav 		}
179b7579f77SDag-Erling Smørgrav 	}
180b7579f77SDag-Erling Smørgrav 	if(!w->is_bg || w->is_bg_thread) {
181b7579f77SDag-Erling Smørgrav 		lock_basic_unlock(&ctx->cfglock);
182b7579f77SDag-Erling Smørgrav 	}
183b7579f77SDag-Erling Smørgrav 	if(!w->env->scratch || !w->env->scratch_buffer || !w->env->fwds ||
184b7579f77SDag-Erling Smørgrav 		!w->env->hints) {
185b7579f77SDag-Erling Smørgrav 		libworker_delete(w);
186b7579f77SDag-Erling Smørgrav 		return NULL;
187b7579f77SDag-Erling Smørgrav 	}
188b7579f77SDag-Erling Smørgrav 	w->env->worker = (struct worker*)w;
189b7579f77SDag-Erling Smørgrav 	w->env->probe_timer = NULL;
190b7579f77SDag-Erling Smørgrav 	if(!w->is_bg || w->is_bg_thread) {
191b7579f77SDag-Erling Smørgrav 		lock_basic_lock(&ctx->cfglock);
192b7579f77SDag-Erling Smørgrav 	}
1930eefd307SCy Schubert 	if(!(w->env->rnd = ub_initstate(ctx->seed_rnd))) {
194b7579f77SDag-Erling Smørgrav 		if(!w->is_bg || w->is_bg_thread) {
195b7579f77SDag-Erling Smørgrav 			lock_basic_unlock(&ctx->cfglock);
196b7579f77SDag-Erling Smørgrav 		}
197b7579f77SDag-Erling Smørgrav 		libworker_delete(w);
198b7579f77SDag-Erling Smørgrav 		return NULL;
199b7579f77SDag-Erling Smørgrav 	}
200b7579f77SDag-Erling Smørgrav 	if(!w->is_bg || w->is_bg_thread) {
201b7579f77SDag-Erling Smørgrav 		lock_basic_unlock(&ctx->cfglock);
202b7579f77SDag-Erling Smørgrav 	}
203b7579f77SDag-Erling Smørgrav 	if(1) {
204b7579f77SDag-Erling Smørgrav 		/* primitive lockout for threading: if it overwrites another
205b7579f77SDag-Erling Smørgrav 		 * thread it is like wiping the cache (which is likely empty
206b7579f77SDag-Erling Smørgrav 		 * at the start) */
207b7579f77SDag-Erling Smørgrav 		/* note we are holding the ctx lock in normal threaded
208b7579f77SDag-Erling Smørgrav 		 * cases so that is solved properly, it is only for many ctx
209b7579f77SDag-Erling Smørgrav 		 * in different threads that this may clash */
210b7579f77SDag-Erling Smørgrav 		static int done_raninit = 0;
211b7579f77SDag-Erling Smørgrav 		if(!done_raninit) {
212b7579f77SDag-Erling Smørgrav 			done_raninit = 1;
213b7579f77SDag-Erling Smørgrav 			hash_set_raninit((uint32_t)ub_random(w->env->rnd));
214b7579f77SDag-Erling Smørgrav 		}
215b7579f77SDag-Erling Smørgrav 	}
216b7579f77SDag-Erling Smørgrav 
21717d15b25SDag-Erling Smørgrav 	if(eb)
21817d15b25SDag-Erling Smørgrav 		w->base = comm_base_create_event(eb);
21917d15b25SDag-Erling Smørgrav 	else	w->base = comm_base_create(0);
220b7579f77SDag-Erling Smørgrav 	if(!w->base) {
221b7579f77SDag-Erling Smørgrav 		libworker_delete(w);
222b7579f77SDag-Erling Smørgrav 		return NULL;
223b7579f77SDag-Erling Smørgrav 	}
22457bddd21SDag-Erling Smørgrav 	w->env->worker_base = w->base;
225b7579f77SDag-Erling Smørgrav 	if(!w->is_bg || w->is_bg_thread) {
226b7579f77SDag-Erling Smørgrav 		lock_basic_lock(&ctx->cfglock);
227b7579f77SDag-Erling Smørgrav 	}
228b7579f77SDag-Erling Smørgrav 	numports = cfg_condense_ports(cfg, &ports);
229b7579f77SDag-Erling Smørgrav 	if(numports == 0) {
230e86b9096SDag-Erling Smørgrav 		if(!w->is_bg || w->is_bg_thread) {
23117d15b25SDag-Erling Smørgrav 			lock_basic_unlock(&ctx->cfglock);
23217d15b25SDag-Erling Smørgrav 		}
233e86b9096SDag-Erling Smørgrav 		libworker_delete(w);
234b7579f77SDag-Erling Smørgrav 		return NULL;
235b7579f77SDag-Erling Smørgrav 	}
236b7579f77SDag-Erling Smørgrav 	w->back = outside_network_create(w->base, cfg->msg_buffer_size,
237b7579f77SDag-Erling Smørgrav 		(size_t)cfg->outgoing_num_ports, cfg->out_ifs,
238b7579f77SDag-Erling Smørgrav 		cfg->num_out_ifs, cfg->do_ip4, cfg->do_ip6,
23925039b37SCy Schubert 		cfg->do_tcp?cfg->outgoing_num_tcp:0, cfg->ip_dscp,
240b7579f77SDag-Erling Smørgrav 		w->env->infra_cache, w->env->rnd, cfg->use_caps_bits_for_id,
241b7579f77SDag-Erling Smørgrav 		ports, numports, cfg->unwanted_threshold,
2428a384985SDag-Erling Smørgrav 		cfg->outgoing_tcp_mss, &libworker_alloc_cleanup, w,
2438a384985SDag-Erling Smørgrav 		cfg->do_udp || cfg->udp_upstream_without_downstream, w->sslctx,
244369c6923SCy Schubert 		cfg->delay_close, cfg->tls_use_sni, NULL, cfg->udp_connect);
24557bddd21SDag-Erling Smørgrav 	w->env->outnet = w->back;
246b7579f77SDag-Erling Smørgrav 	if(!w->is_bg || w->is_bg_thread) {
247b7579f77SDag-Erling Smørgrav 		lock_basic_unlock(&ctx->cfglock);
248b7579f77SDag-Erling Smørgrav 	}
249b7579f77SDag-Erling Smørgrav 	free(ports);
250b7579f77SDag-Erling Smørgrav 	if(!w->back) {
251b7579f77SDag-Erling Smørgrav 		libworker_delete(w);
252b7579f77SDag-Erling Smørgrav 		return NULL;
253b7579f77SDag-Erling Smørgrav 	}
254b7579f77SDag-Erling Smørgrav 	w->env->mesh = mesh_create(&ctx->mods, w->env);
255b7579f77SDag-Erling Smørgrav 	if(!w->env->mesh) {
256b7579f77SDag-Erling Smørgrav 		libworker_delete(w);
257b7579f77SDag-Erling Smørgrav 		return NULL;
258b7579f77SDag-Erling Smørgrav 	}
259b7579f77SDag-Erling Smørgrav 	w->env->send_query = &libworker_send_query;
260b7579f77SDag-Erling Smørgrav 	w->env->detach_subs = &mesh_detach_subs;
261b7579f77SDag-Erling Smørgrav 	w->env->attach_sub = &mesh_attach_sub;
2628a384985SDag-Erling Smørgrav 	w->env->add_sub = &mesh_add_sub;
263b7579f77SDag-Erling Smørgrav 	w->env->kill_sub = &mesh_state_delete;
264b7579f77SDag-Erling Smørgrav 	w->env->detect_cycle = &mesh_detect_cycle;
265b7579f77SDag-Erling Smørgrav 	comm_base_timept(w->base, &w->env->now, &w->env->now_tv);
266b7579f77SDag-Erling Smørgrav 	return w;
267b7579f77SDag-Erling Smørgrav }
268b7579f77SDag-Erling Smørgrav 
26917d15b25SDag-Erling Smørgrav struct libworker* libworker_create_event(struct ub_ctx* ctx,
270e2d15004SDag-Erling Smørgrav 	struct ub_event_base* eb)
27117d15b25SDag-Erling Smørgrav {
27217d15b25SDag-Erling Smørgrav 	return libworker_setup(ctx, 0, eb);
27317d15b25SDag-Erling Smørgrav }
27417d15b25SDag-Erling Smørgrav 
275b7579f77SDag-Erling Smørgrav /** handle cancel command for bg worker */
276b7579f77SDag-Erling Smørgrav static void
277b7579f77SDag-Erling Smørgrav handle_cancel(struct libworker* w, uint8_t* buf, uint32_t len)
278b7579f77SDag-Erling Smørgrav {
279b7579f77SDag-Erling Smørgrav 	struct ctx_query* q;
280b7579f77SDag-Erling Smørgrav 	if(w->is_bg_thread) {
281b7579f77SDag-Erling Smørgrav 		lock_basic_lock(&w->ctx->cfglock);
282b7579f77SDag-Erling Smørgrav 		q = context_deserialize_cancel(w->ctx, buf, len);
283b7579f77SDag-Erling Smørgrav 		lock_basic_unlock(&w->ctx->cfglock);
284b7579f77SDag-Erling Smørgrav 	} else {
285b7579f77SDag-Erling Smørgrav 		q = context_deserialize_cancel(w->ctx, buf, len);
286b7579f77SDag-Erling Smørgrav 	}
287b7579f77SDag-Erling Smørgrav 	if(!q) {
288b7579f77SDag-Erling Smørgrav 		/* probably simply lookup failed, i.e. the message had been
289b7579f77SDag-Erling Smørgrav 		 * processed and answered before the cancel arrived */
290b7579f77SDag-Erling Smørgrav 		return;
291b7579f77SDag-Erling Smørgrav 	}
292b7579f77SDag-Erling Smørgrav 	q->cancelled = 1;
293b7579f77SDag-Erling Smørgrav 	free(buf);
294b7579f77SDag-Erling Smørgrav }
295b7579f77SDag-Erling Smørgrav 
296b7579f77SDag-Erling Smørgrav /** do control command coming into bg server */
297b7579f77SDag-Erling Smørgrav static void
298b7579f77SDag-Erling Smørgrav libworker_do_cmd(struct libworker* w, uint8_t* msg, uint32_t len)
299b7579f77SDag-Erling Smørgrav {
300b7579f77SDag-Erling Smørgrav 	switch(context_serial_getcmd(msg, len)) {
301b7579f77SDag-Erling Smørgrav 		default:
302b7579f77SDag-Erling Smørgrav 		case UB_LIBCMD_ANSWER:
303b7579f77SDag-Erling Smørgrav 			log_err("unknown command for bg worker %d",
304b7579f77SDag-Erling Smørgrav 				(int)context_serial_getcmd(msg, len));
305b7579f77SDag-Erling Smørgrav 			/* and fall through to quit */
306971980c3SDag-Erling Smørgrav 			/* fallthrough */
307b7579f77SDag-Erling Smørgrav 		case UB_LIBCMD_QUIT:
308b7579f77SDag-Erling Smørgrav 			free(msg);
309b7579f77SDag-Erling Smørgrav 			comm_base_exit(w->base);
310b7579f77SDag-Erling Smørgrav 			break;
311b7579f77SDag-Erling Smørgrav 		case UB_LIBCMD_NEWQUERY:
312b7579f77SDag-Erling Smørgrav 			handle_newq(w, msg, len);
313b7579f77SDag-Erling Smørgrav 			break;
314b7579f77SDag-Erling Smørgrav 		case UB_LIBCMD_CANCEL:
315b7579f77SDag-Erling Smørgrav 			handle_cancel(w, msg, len);
316b7579f77SDag-Erling Smørgrav 			break;
317b7579f77SDag-Erling Smørgrav 	}
318b7579f77SDag-Erling Smørgrav }
319b7579f77SDag-Erling Smørgrav 
320b7579f77SDag-Erling Smørgrav /** handle control command coming into server */
321b7579f77SDag-Erling Smørgrav void
322b7579f77SDag-Erling Smørgrav libworker_handle_control_cmd(struct tube* ATTR_UNUSED(tube),
323b7579f77SDag-Erling Smørgrav 	uint8_t* msg, size_t len, int err, void* arg)
324b7579f77SDag-Erling Smørgrav {
325b7579f77SDag-Erling Smørgrav 	struct libworker* w = (struct libworker*)arg;
326b7579f77SDag-Erling Smørgrav 
327b7579f77SDag-Erling Smørgrav 	if(err != 0) {
328b7579f77SDag-Erling Smørgrav 		free(msg);
329b7579f77SDag-Erling Smørgrav 		/* it is of no use to go on, exit */
330b7579f77SDag-Erling Smørgrav 		comm_base_exit(w->base);
331b7579f77SDag-Erling Smørgrav 		return;
332b7579f77SDag-Erling Smørgrav 	}
333b7579f77SDag-Erling Smørgrav 	libworker_do_cmd(w, msg, len); /* also frees the buf */
334b7579f77SDag-Erling Smørgrav }
335b7579f77SDag-Erling Smørgrav 
336b7579f77SDag-Erling Smørgrav /** the background thread func */
337b7579f77SDag-Erling Smørgrav static void*
338b7579f77SDag-Erling Smørgrav libworker_dobg(void* arg)
339b7579f77SDag-Erling Smørgrav {
340b7579f77SDag-Erling Smørgrav 	/* setup */
341b7579f77SDag-Erling Smørgrav 	uint32_t m;
342b7579f77SDag-Erling Smørgrav 	struct libworker* w = (struct libworker*)arg;
343b7579f77SDag-Erling Smørgrav 	struct ub_ctx* ctx;
344b7579f77SDag-Erling Smørgrav 	if(!w) {
345b7579f77SDag-Erling Smørgrav 		log_err("libunbound bg worker init failed, nomem");
346b7579f77SDag-Erling Smørgrav 		return NULL;
347b7579f77SDag-Erling Smørgrav 	}
348b7579f77SDag-Erling Smørgrav 	ctx = w->ctx;
349b7579f77SDag-Erling Smørgrav 	log_thread_set(&w->thread_num);
350b7579f77SDag-Erling Smørgrav #ifdef THREADS_DISABLED
351b7579f77SDag-Erling Smørgrav 	/* we are forked */
352b7579f77SDag-Erling Smørgrav 	w->is_bg_thread = 0;
353b7579f77SDag-Erling Smørgrav 	/* close non-used parts of the pipes */
354b7579f77SDag-Erling Smørgrav 	tube_close_write(ctx->qq_pipe);
355b7579f77SDag-Erling Smørgrav 	tube_close_read(ctx->rr_pipe);
356b7579f77SDag-Erling Smørgrav #endif
357b7579f77SDag-Erling Smørgrav 	if(!tube_setup_bg_listen(ctx->qq_pipe, w->base,
358b7579f77SDag-Erling Smørgrav 		libworker_handle_control_cmd, w)) {
359b7579f77SDag-Erling Smørgrav 		log_err("libunbound bg worker init failed, no bglisten");
360b7579f77SDag-Erling Smørgrav 		return NULL;
361b7579f77SDag-Erling Smørgrav 	}
362b7579f77SDag-Erling Smørgrav 	if(!tube_setup_bg_write(ctx->rr_pipe, w->base)) {
363b7579f77SDag-Erling Smørgrav 		log_err("libunbound bg worker init failed, no bgwrite");
364b7579f77SDag-Erling Smørgrav 		return NULL;
365b7579f77SDag-Erling Smørgrav 	}
366b7579f77SDag-Erling Smørgrav 
367b7579f77SDag-Erling Smørgrav 	/* do the work */
368b7579f77SDag-Erling Smørgrav 	comm_base_dispatch(w->base);
369b7579f77SDag-Erling Smørgrav 
370b7579f77SDag-Erling Smørgrav 	/* cleanup */
371b7579f77SDag-Erling Smørgrav 	m = UB_LIBCMD_QUIT;
3720fb34990SDag-Erling Smørgrav 	w->want_quit = 1;
373b7579f77SDag-Erling Smørgrav 	tube_remove_bg_listen(w->ctx->qq_pipe);
374b7579f77SDag-Erling Smørgrav 	tube_remove_bg_write(w->ctx->rr_pipe);
375b7579f77SDag-Erling Smørgrav 	libworker_delete(w);
376b7579f77SDag-Erling Smørgrav 	(void)tube_write_msg(ctx->rr_pipe, (uint8_t*)&m,
377b7579f77SDag-Erling Smørgrav 		(uint32_t)sizeof(m), 0);
378b7579f77SDag-Erling Smørgrav #ifdef THREADS_DISABLED
379b7579f77SDag-Erling Smørgrav 	/* close pipes from forked process before exit */
380b7579f77SDag-Erling Smørgrav 	tube_close_read(ctx->qq_pipe);
381b7579f77SDag-Erling Smørgrav 	tube_close_write(ctx->rr_pipe);
382b7579f77SDag-Erling Smørgrav #endif
383b7579f77SDag-Erling Smørgrav 	return NULL;
384b7579f77SDag-Erling Smørgrav }
385b7579f77SDag-Erling Smørgrav 
386b7579f77SDag-Erling Smørgrav int libworker_bg(struct ub_ctx* ctx)
387b7579f77SDag-Erling Smørgrav {
388b7579f77SDag-Erling Smørgrav 	struct libworker* w;
389b7579f77SDag-Erling Smørgrav 	/* fork or threadcreate */
390b7579f77SDag-Erling Smørgrav 	lock_basic_lock(&ctx->cfglock);
391b7579f77SDag-Erling Smørgrav 	if(ctx->dothread) {
392b7579f77SDag-Erling Smørgrav 		lock_basic_unlock(&ctx->cfglock);
39317d15b25SDag-Erling Smørgrav 		w = libworker_setup(ctx, 1, NULL);
394b7579f77SDag-Erling Smørgrav 		if(!w) return UB_NOMEM;
395b7579f77SDag-Erling Smørgrav 		w->is_bg_thread = 1;
396b7579f77SDag-Erling Smørgrav #ifdef ENABLE_LOCK_CHECKS
397b7579f77SDag-Erling Smørgrav 		w->thread_num = 1; /* for nicer DEBUG checklocks */
398b7579f77SDag-Erling Smørgrav #endif
399b7579f77SDag-Erling Smørgrav 		ub_thread_create(&ctx->bg_tid, libworker_dobg, w);
400b7579f77SDag-Erling Smørgrav 	} else {
401b7579f77SDag-Erling Smørgrav 		lock_basic_unlock(&ctx->cfglock);
402b7579f77SDag-Erling Smørgrav #ifndef HAVE_FORK
403b7579f77SDag-Erling Smørgrav 		/* no fork on windows */
404b7579f77SDag-Erling Smørgrav 		return UB_FORKFAIL;
405b7579f77SDag-Erling Smørgrav #else /* HAVE_FORK */
406b7579f77SDag-Erling Smørgrav 		switch((ctx->bg_pid=fork())) {
407b7579f77SDag-Erling Smørgrav 			case 0:
40817d15b25SDag-Erling Smørgrav 				w = libworker_setup(ctx, 1, NULL);
409b7579f77SDag-Erling Smørgrav 				if(!w) fatal_exit("out of memory");
410b7579f77SDag-Erling Smørgrav 				/* close non-used parts of the pipes */
411b7579f77SDag-Erling Smørgrav 				tube_close_write(ctx->qq_pipe);
412b7579f77SDag-Erling Smørgrav 				tube_close_read(ctx->rr_pipe);
413b7579f77SDag-Erling Smørgrav 				(void)libworker_dobg(w);
414b7579f77SDag-Erling Smørgrav 				exit(0);
415b7579f77SDag-Erling Smørgrav 				break;
416b7579f77SDag-Erling Smørgrav 			case -1:
417b7579f77SDag-Erling Smørgrav 				return UB_FORKFAIL;
418b7579f77SDag-Erling Smørgrav 			default:
41917d15b25SDag-Erling Smørgrav 				/* close non-used parts, so that the worker
42017d15b25SDag-Erling Smørgrav 				 * bgprocess gets 'pipe closed' when the
42117d15b25SDag-Erling Smørgrav 				 * main process exits */
42217d15b25SDag-Erling Smørgrav 				tube_close_read(ctx->qq_pipe);
42317d15b25SDag-Erling Smørgrav 				tube_close_write(ctx->rr_pipe);
424b7579f77SDag-Erling Smørgrav 				break;
425b7579f77SDag-Erling Smørgrav 		}
426b7579f77SDag-Erling Smørgrav #endif /* HAVE_FORK */
427b7579f77SDag-Erling Smørgrav 	}
428b7579f77SDag-Erling Smørgrav 	return UB_NOERROR;
429b7579f77SDag-Erling Smørgrav }
430b7579f77SDag-Erling Smørgrav 
431b7579f77SDag-Erling Smørgrav /** insert canonname */
432b7579f77SDag-Erling Smørgrav static int
433b7579f77SDag-Erling Smørgrav fill_canon(struct ub_result* res, uint8_t* s)
434b7579f77SDag-Erling Smørgrav {
435b7579f77SDag-Erling Smørgrav 	char buf[255+2];
436b7579f77SDag-Erling Smørgrav 	dname_str(s, buf);
437b7579f77SDag-Erling Smørgrav 	res->canonname = strdup(buf);
438b7579f77SDag-Erling Smørgrav 	return res->canonname != 0;
439b7579f77SDag-Erling Smørgrav }
440b7579f77SDag-Erling Smørgrav 
441b7579f77SDag-Erling Smørgrav /** fill data into result */
442b7579f77SDag-Erling Smørgrav static int
443b7579f77SDag-Erling Smørgrav fill_res(struct ub_result* res, struct ub_packed_rrset_key* answer,
4448ed2b524SDag-Erling Smørgrav 	uint8_t* finalcname, struct query_info* rq, struct reply_info* rep)
445b7579f77SDag-Erling Smørgrav {
446b7579f77SDag-Erling Smørgrav 	size_t i;
447b7579f77SDag-Erling Smørgrav 	struct packed_rrset_data* data;
4488ed2b524SDag-Erling Smørgrav 	res->ttl = 0;
449b7579f77SDag-Erling Smørgrav 	if(!answer) {
450b7579f77SDag-Erling Smørgrav 		if(finalcname) {
451b7579f77SDag-Erling Smørgrav 			if(!fill_canon(res, finalcname))
452b7579f77SDag-Erling Smørgrav 				return 0; /* out of memory */
453b7579f77SDag-Erling Smørgrav 		}
4548ed2b524SDag-Erling Smørgrav 		if(rep->rrset_count != 0)
4558ed2b524SDag-Erling Smørgrav 			res->ttl = (int)rep->ttl;
456b7579f77SDag-Erling Smørgrav 		res->data = (char**)calloc(1, sizeof(char*));
457b7579f77SDag-Erling Smørgrav 		res->len = (int*)calloc(1, sizeof(int));
458b7579f77SDag-Erling Smørgrav 		return (res->data && res->len);
459b7579f77SDag-Erling Smørgrav 	}
460b7579f77SDag-Erling Smørgrav 	data = (struct packed_rrset_data*)answer->entry.data;
461b7579f77SDag-Erling Smørgrav 	if(query_dname_compare(rq->qname, answer->rk.dname) != 0) {
462b7579f77SDag-Erling Smørgrav 		if(!fill_canon(res, answer->rk.dname))
463b7579f77SDag-Erling Smørgrav 			return 0; /* out of memory */
464b7579f77SDag-Erling Smørgrav 	} else	res->canonname = NULL;
465b7579f77SDag-Erling Smørgrav 	res->data = (char**)calloc(data->count+1, sizeof(char*));
466b7579f77SDag-Erling Smørgrav 	res->len = (int*)calloc(data->count+1, sizeof(int));
467b7579f77SDag-Erling Smørgrav 	if(!res->data || !res->len)
468b7579f77SDag-Erling Smørgrav 		return 0; /* out of memory */
469b7579f77SDag-Erling Smørgrav 	for(i=0; i<data->count; i++) {
470b7579f77SDag-Erling Smørgrav 		/* remove rdlength from rdata */
471b7579f77SDag-Erling Smørgrav 		res->len[i] = (int)(data->rr_len[i] - 2);
472b7579f77SDag-Erling Smørgrav 		res->data[i] = memdup(data->rr_data[i]+2, (size_t)res->len[i]);
473b7579f77SDag-Erling Smørgrav 		if(!res->data[i])
474b7579f77SDag-Erling Smørgrav 			return 0; /* out of memory */
475b7579f77SDag-Erling Smørgrav 	}
4768ed2b524SDag-Erling Smørgrav 	/* ttl for positive answers, from CNAME and answer RRs */
4778ed2b524SDag-Erling Smørgrav 	if(data->count != 0) {
4788ed2b524SDag-Erling Smørgrav 		size_t j;
4798ed2b524SDag-Erling Smørgrav 		res->ttl = (int)data->ttl;
4808ed2b524SDag-Erling Smørgrav 		for(j=0; j<rep->an_numrrsets; j++) {
4818ed2b524SDag-Erling Smørgrav 			struct packed_rrset_data* d =
4828ed2b524SDag-Erling Smørgrav 				(struct packed_rrset_data*)rep->rrsets[j]->
4838ed2b524SDag-Erling Smørgrav 				entry.data;
4848ed2b524SDag-Erling Smørgrav 			if((int)d->ttl < res->ttl)
4858ed2b524SDag-Erling Smørgrav 				res->ttl = (int)d->ttl;
4868ed2b524SDag-Erling Smørgrav 		}
4878ed2b524SDag-Erling Smørgrav 	}
4888ed2b524SDag-Erling Smørgrav 	/* ttl for negative answers */
4898ed2b524SDag-Erling Smørgrav 	if(data->count == 0 && rep->rrset_count != 0)
4908ed2b524SDag-Erling Smørgrav 		res->ttl = (int)rep->ttl;
491b7579f77SDag-Erling Smørgrav 	res->data[data->count] = NULL;
492b7579f77SDag-Erling Smørgrav 	res->len[data->count] = 0;
493b7579f77SDag-Erling Smørgrav 	return 1;
494b7579f77SDag-Erling Smørgrav }
495b7579f77SDag-Erling Smørgrav 
496b7579f77SDag-Erling Smørgrav /** fill result from parsed message, on error fills servfail */
497b7579f77SDag-Erling Smørgrav void
49817d15b25SDag-Erling Smørgrav libworker_enter_result(struct ub_result* res, sldns_buffer* buf,
499b7579f77SDag-Erling Smørgrav 	struct regional* temp, enum sec_status msg_security)
500b7579f77SDag-Erling Smørgrav {
501b7579f77SDag-Erling Smørgrav 	struct query_info rq;
502b7579f77SDag-Erling Smørgrav 	struct reply_info* rep;
503b7579f77SDag-Erling Smørgrav 	res->rcode = LDNS_RCODE_SERVFAIL;
50457bddd21SDag-Erling Smørgrav 	rep = parse_reply_in_temp_region(buf, temp, &rq);
505b7579f77SDag-Erling Smørgrav 	if(!rep) {
506b7579f77SDag-Erling Smørgrav 		log_err("cannot parse buf");
507b7579f77SDag-Erling Smørgrav 		return; /* error parsing buf, or out of memory */
508b7579f77SDag-Erling Smørgrav 	}
509b7579f77SDag-Erling Smørgrav 	if(!fill_res(res, reply_find_answer_rrset(&rq, rep),
5108ed2b524SDag-Erling Smørgrav 		reply_find_final_cname_target(&rq, rep), &rq, rep))
511b7579f77SDag-Erling Smørgrav 		return; /* out of memory */
512b7579f77SDag-Erling Smørgrav 	/* rcode, havedata, nxdomain, secure, bogus */
513b7579f77SDag-Erling Smørgrav 	res->rcode = (int)FLAGS_GET_RCODE(rep->flags);
514b7579f77SDag-Erling Smørgrav 	if(res->data && res->data[0])
515b7579f77SDag-Erling Smørgrav 		res->havedata = 1;
516b7579f77SDag-Erling Smørgrav 	if(res->rcode == LDNS_RCODE_NXDOMAIN)
517b7579f77SDag-Erling Smørgrav 		res->nxdomain = 1;
518b7579f77SDag-Erling Smørgrav 	if(msg_security == sec_status_secure)
519b7579f77SDag-Erling Smørgrav 		res->secure = 1;
5200fb34990SDag-Erling Smørgrav 	if(msg_security == sec_status_bogus ||
5210fb34990SDag-Erling Smørgrav 		msg_security == sec_status_secure_sentinel_fail)
522b7579f77SDag-Erling Smørgrav 		res->bogus = 1;
523b7579f77SDag-Erling Smørgrav }
524b7579f77SDag-Erling Smørgrav 
525b7579f77SDag-Erling Smørgrav /** fillup fg results */
526b7579f77SDag-Erling Smørgrav static void
52717d15b25SDag-Erling Smørgrav libworker_fillup_fg(struct ctx_query* q, int rcode, sldns_buffer* buf,
5284c75e3aaSDag-Erling Smørgrav 	enum sec_status s, char* why_bogus, int was_ratelimited)
529b7579f77SDag-Erling Smørgrav {
5304c75e3aaSDag-Erling Smørgrav 	q->res->was_ratelimited = was_ratelimited;
531b7579f77SDag-Erling Smørgrav 	if(why_bogus)
532b7579f77SDag-Erling Smørgrav 		q->res->why_bogus = strdup(why_bogus);
533b7579f77SDag-Erling Smørgrav 	if(rcode != 0) {
534b7579f77SDag-Erling Smørgrav 		q->res->rcode = rcode;
535b7579f77SDag-Erling Smørgrav 		q->msg_security = s;
536b7579f77SDag-Erling Smørgrav 		return;
537b7579f77SDag-Erling Smørgrav 	}
538b7579f77SDag-Erling Smørgrav 
539b7579f77SDag-Erling Smørgrav 	q->res->rcode = LDNS_RCODE_SERVFAIL;
5400eefd307SCy Schubert 	q->msg_security = sec_status_unchecked;
54117d15b25SDag-Erling Smørgrav 	q->msg = memdup(sldns_buffer_begin(buf), sldns_buffer_limit(buf));
54217d15b25SDag-Erling Smørgrav 	q->msg_len = sldns_buffer_limit(buf);
543b7579f77SDag-Erling Smørgrav 	if(!q->msg) {
544b7579f77SDag-Erling Smørgrav 		return; /* the error is in the rcode */
545b7579f77SDag-Erling Smørgrav 	}
546b7579f77SDag-Erling Smørgrav 
547b7579f77SDag-Erling Smørgrav 	/* canonname and results */
548b7579f77SDag-Erling Smørgrav 	q->msg_security = s;
549b7579f77SDag-Erling Smørgrav 	libworker_enter_result(q->res, buf, q->w->env->scratch, s);
550b7579f77SDag-Erling Smørgrav }
551b7579f77SDag-Erling Smørgrav 
552b7579f77SDag-Erling Smørgrav void
55317d15b25SDag-Erling Smørgrav libworker_fg_done_cb(void* arg, int rcode, sldns_buffer* buf, enum sec_status s,
5544c75e3aaSDag-Erling Smørgrav 	char* why_bogus, int was_ratelimited)
555b7579f77SDag-Erling Smørgrav {
556b7579f77SDag-Erling Smørgrav 	struct ctx_query* q = (struct ctx_query*)arg;
557b7579f77SDag-Erling Smørgrav 	/* fg query is done; exit comm base */
558b7579f77SDag-Erling Smørgrav 	comm_base_exit(q->w->base);
559b7579f77SDag-Erling Smørgrav 
5604c75e3aaSDag-Erling Smørgrav 	libworker_fillup_fg(q, rcode, buf, s, why_bogus, was_ratelimited);
561b7579f77SDag-Erling Smørgrav }
562b7579f77SDag-Erling Smørgrav 
563b7579f77SDag-Erling Smørgrav /** setup qinfo and edns */
564b7579f77SDag-Erling Smørgrav static int
565b7579f77SDag-Erling Smørgrav setup_qinfo_edns(struct libworker* w, struct ctx_query* q,
566b7579f77SDag-Erling Smørgrav 	struct query_info* qinfo, struct edns_data* edns)
567b7579f77SDag-Erling Smørgrav {
568b7579f77SDag-Erling Smørgrav 	qinfo->qtype = (uint16_t)q->res->qtype;
569b7579f77SDag-Erling Smørgrav 	qinfo->qclass = (uint16_t)q->res->qclass;
570bc892140SDag-Erling Smørgrav 	qinfo->local_alias = NULL;
57117d15b25SDag-Erling Smørgrav 	qinfo->qname = sldns_str2wire_dname(q->res->qname, &qinfo->qname_len);
57217d15b25SDag-Erling Smørgrav 	if(!qinfo->qname) {
573b7579f77SDag-Erling Smørgrav 		return 0;
574b7579f77SDag-Erling Smørgrav 	}
575b7579f77SDag-Erling Smørgrav 	edns->edns_present = 1;
576b7579f77SDag-Erling Smørgrav 	edns->ext_rcode = 0;
577b7579f77SDag-Erling Smørgrav 	edns->edns_version = 0;
578b7579f77SDag-Erling Smørgrav 	edns->bits = EDNS_DO;
579e2d15004SDag-Erling Smørgrav 	edns->opt_list = NULL;
580*f44e67d1SCy Schubert 	edns->padding_block_size = 0;
58117d15b25SDag-Erling Smørgrav 	if(sldns_buffer_capacity(w->back->udp_buff) < 65535)
58217d15b25SDag-Erling Smørgrav 		edns->udp_size = (uint16_t)sldns_buffer_capacity(
583b7579f77SDag-Erling Smørgrav 			w->back->udp_buff);
584b7579f77SDag-Erling Smørgrav 	else	edns->udp_size = 65535;
585b7579f77SDag-Erling Smørgrav 	return 1;
586b7579f77SDag-Erling Smørgrav }
587b7579f77SDag-Erling Smørgrav 
588b7579f77SDag-Erling Smørgrav int libworker_fg(struct ub_ctx* ctx, struct ctx_query* q)
589b7579f77SDag-Erling Smørgrav {
59017d15b25SDag-Erling Smørgrav 	struct libworker* w = libworker_setup(ctx, 0, NULL);
591b7579f77SDag-Erling Smørgrav 	uint16_t qflags, qid;
592b7579f77SDag-Erling Smørgrav 	struct query_info qinfo;
593b7579f77SDag-Erling Smørgrav 	struct edns_data edns;
594b7579f77SDag-Erling Smørgrav 	if(!w)
595b7579f77SDag-Erling Smørgrav 		return UB_INITFAIL;
596b7579f77SDag-Erling Smørgrav 	if(!setup_qinfo_edns(w, q, &qinfo, &edns)) {
597b7579f77SDag-Erling Smørgrav 		libworker_delete(w);
598b7579f77SDag-Erling Smørgrav 		return UB_SYNTAX;
599b7579f77SDag-Erling Smørgrav 	}
600b7579f77SDag-Erling Smørgrav 	qid = 0;
601b7579f77SDag-Erling Smørgrav 	qflags = BIT_RD;
602b7579f77SDag-Erling Smørgrav 	q->w = w;
603b7579f77SDag-Erling Smørgrav 	/* see if there is a fixed answer */
60417d15b25SDag-Erling Smørgrav 	sldns_buffer_write_u16_at(w->back->udp_buff, 0, qid);
60517d15b25SDag-Erling Smørgrav 	sldns_buffer_write_u16_at(w->back->udp_buff, 2, qflags);
606bc892140SDag-Erling Smørgrav 	if(local_zones_answer(ctx->local_zones, w->env, &qinfo, &edns,
607b5663de9SDag-Erling Smørgrav 		w->back->udp_buff, w->env->scratch, NULL, NULL, 0, NULL, 0,
608bc892140SDag-Erling Smørgrav 		NULL, 0, NULL, 0, NULL)) {
609b7579f77SDag-Erling Smørgrav 		regional_free_all(w->env->scratch);
610b7579f77SDag-Erling Smørgrav 		libworker_fillup_fg(q, LDNS_RCODE_NOERROR,
6114c75e3aaSDag-Erling Smørgrav 			w->back->udp_buff, sec_status_insecure, NULL, 0);
612b7579f77SDag-Erling Smørgrav 		libworker_delete(w);
613b7579f77SDag-Erling Smørgrav 		free(qinfo.qname);
614b7579f77SDag-Erling Smørgrav 		return UB_NOERROR;
615b7579f77SDag-Erling Smørgrav 	}
61657bddd21SDag-Erling Smørgrav 	if(ctx->env->auth_zones && auth_zones_answer(ctx->env->auth_zones,
6174c75e3aaSDag-Erling Smørgrav 		w->env, &qinfo, &edns, NULL, w->back->udp_buff, w->env->scratch)) {
61857bddd21SDag-Erling Smørgrav 		regional_free_all(w->env->scratch);
61957bddd21SDag-Erling Smørgrav 		libworker_fillup_fg(q, LDNS_RCODE_NOERROR,
6204c75e3aaSDag-Erling Smørgrav 			w->back->udp_buff, sec_status_insecure, NULL, 0);
62157bddd21SDag-Erling Smørgrav 		libworker_delete(w);
62257bddd21SDag-Erling Smørgrav 		free(qinfo.qname);
62357bddd21SDag-Erling Smørgrav 		return UB_NOERROR;
62457bddd21SDag-Erling Smørgrav 	}
625b7579f77SDag-Erling Smørgrav 	/* process new query */
626b7579f77SDag-Erling Smørgrav 	if(!mesh_new_callback(w->env->mesh, &qinfo, qflags, &edns,
627b7579f77SDag-Erling Smørgrav 		w->back->udp_buff, qid, libworker_fg_done_cb, q)) {
628b7579f77SDag-Erling Smørgrav 		free(qinfo.qname);
629b7579f77SDag-Erling Smørgrav 		return UB_NOMEM;
630b7579f77SDag-Erling Smørgrav 	}
631b7579f77SDag-Erling Smørgrav 	free(qinfo.qname);
632b7579f77SDag-Erling Smørgrav 
633b7579f77SDag-Erling Smørgrav 	/* wait for reply */
634b7579f77SDag-Erling Smørgrav 	comm_base_dispatch(w->base);
635b7579f77SDag-Erling Smørgrav 
636b7579f77SDag-Erling Smørgrav 	libworker_delete(w);
637b7579f77SDag-Erling Smørgrav 	return UB_NOERROR;
638b7579f77SDag-Erling Smørgrav }
639b7579f77SDag-Erling Smørgrav 
64017d15b25SDag-Erling Smørgrav void
64117d15b25SDag-Erling Smørgrav libworker_event_done_cb(void* arg, int rcode, sldns_buffer* buf,
6424c75e3aaSDag-Erling Smørgrav 	enum sec_status s, char* why_bogus, int was_ratelimited)
64317d15b25SDag-Erling Smørgrav {
64417d15b25SDag-Erling Smørgrav 	struct ctx_query* q = (struct ctx_query*)arg;
6453bd4df0aSDag-Erling Smørgrav 	ub_event_callback_type cb = q->cb_event;
64617d15b25SDag-Erling Smørgrav 	void* cb_arg = q->cb_arg;
64717d15b25SDag-Erling Smørgrav 	int cancelled = q->cancelled;
64817d15b25SDag-Erling Smørgrav 
64917d15b25SDag-Erling Smørgrav 	/* delete it now */
65017d15b25SDag-Erling Smørgrav 	struct ub_ctx* ctx = q->w->ctx;
65117d15b25SDag-Erling Smørgrav 	lock_basic_lock(&ctx->cfglock);
65217d15b25SDag-Erling Smørgrav 	(void)rbtree_delete(&ctx->queries, q->node.key);
65317d15b25SDag-Erling Smørgrav 	ctx->num_async--;
65417d15b25SDag-Erling Smørgrav 	context_query_delete(q);
65517d15b25SDag-Erling Smørgrav 	lock_basic_unlock(&ctx->cfglock);
65617d15b25SDag-Erling Smørgrav 
65717d15b25SDag-Erling Smørgrav 	if(!cancelled) {
65817d15b25SDag-Erling Smørgrav 		/* call callback */
65917d15b25SDag-Erling Smørgrav 		int sec = 0;
66017d15b25SDag-Erling Smørgrav 		if(s == sec_status_bogus)
66117d15b25SDag-Erling Smørgrav 			sec = 1;
66217d15b25SDag-Erling Smørgrav 		else if(s == sec_status_secure)
66317d15b25SDag-Erling Smørgrav 			sec = 2;
664e86b9096SDag-Erling Smørgrav 		(*cb)(cb_arg, rcode, (buf?(void*)sldns_buffer_begin(buf):NULL),
665e86b9096SDag-Erling Smørgrav 			(buf?(int)sldns_buffer_limit(buf):0), sec, why_bogus, was_ratelimited);
66617d15b25SDag-Erling Smørgrav 	}
66717d15b25SDag-Erling Smørgrav }
66817d15b25SDag-Erling Smørgrav 
66917d15b25SDag-Erling Smørgrav int libworker_attach_mesh(struct ub_ctx* ctx, struct ctx_query* q,
67017d15b25SDag-Erling Smørgrav 	int* async_id)
67117d15b25SDag-Erling Smørgrav {
67217d15b25SDag-Erling Smørgrav 	struct libworker* w = ctx->event_worker;
67317d15b25SDag-Erling Smørgrav 	uint16_t qflags, qid;
67417d15b25SDag-Erling Smørgrav 	struct query_info qinfo;
67517d15b25SDag-Erling Smørgrav 	struct edns_data edns;
67617d15b25SDag-Erling Smørgrav 	if(!w)
67717d15b25SDag-Erling Smørgrav 		return UB_INITFAIL;
67817d15b25SDag-Erling Smørgrav 	if(!setup_qinfo_edns(w, q, &qinfo, &edns))
67917d15b25SDag-Erling Smørgrav 		return UB_SYNTAX;
68017d15b25SDag-Erling Smørgrav 	qid = 0;
68117d15b25SDag-Erling Smørgrav 	qflags = BIT_RD;
68217d15b25SDag-Erling Smørgrav 	q->w = w;
68317d15b25SDag-Erling Smørgrav 	/* see if there is a fixed answer */
68417d15b25SDag-Erling Smørgrav 	sldns_buffer_write_u16_at(w->back->udp_buff, 0, qid);
68517d15b25SDag-Erling Smørgrav 	sldns_buffer_write_u16_at(w->back->udp_buff, 2, qflags);
686bc892140SDag-Erling Smørgrav 	if(local_zones_answer(ctx->local_zones, w->env, &qinfo, &edns,
687b5663de9SDag-Erling Smørgrav 		w->back->udp_buff, w->env->scratch, NULL, NULL, 0, NULL, 0,
688bc892140SDag-Erling Smørgrav 		NULL, 0, NULL, 0, NULL)) {
68917d15b25SDag-Erling Smørgrav 		regional_free_all(w->env->scratch);
69017d15b25SDag-Erling Smørgrav 		free(qinfo.qname);
69117d15b25SDag-Erling Smørgrav 		libworker_event_done_cb(q, LDNS_RCODE_NOERROR,
6924c75e3aaSDag-Erling Smørgrav 			w->back->udp_buff, sec_status_insecure, NULL, 0);
69317d15b25SDag-Erling Smørgrav 		return UB_NOERROR;
69417d15b25SDag-Erling Smørgrav 	}
69557bddd21SDag-Erling Smørgrav 	if(ctx->env->auth_zones && auth_zones_answer(ctx->env->auth_zones,
6964c75e3aaSDag-Erling Smørgrav 		w->env, &qinfo, &edns, NULL, w->back->udp_buff, w->env->scratch)) {
69757bddd21SDag-Erling Smørgrav 		regional_free_all(w->env->scratch);
69857bddd21SDag-Erling Smørgrav 		free(qinfo.qname);
69957bddd21SDag-Erling Smørgrav 		libworker_event_done_cb(q, LDNS_RCODE_NOERROR,
7004c75e3aaSDag-Erling Smørgrav 			w->back->udp_buff, sec_status_insecure, NULL, 0);
70157bddd21SDag-Erling Smørgrav 		return UB_NOERROR;
70257bddd21SDag-Erling Smørgrav 	}
70317d15b25SDag-Erling Smørgrav 	/* process new query */
70417d15b25SDag-Erling Smørgrav 	if(async_id)
70517d15b25SDag-Erling Smørgrav 		*async_id = q->querynum;
70617d15b25SDag-Erling Smørgrav 	if(!mesh_new_callback(w->env->mesh, &qinfo, qflags, &edns,
70717d15b25SDag-Erling Smørgrav 		w->back->udp_buff, qid, libworker_event_done_cb, q)) {
70817d15b25SDag-Erling Smørgrav 		free(qinfo.qname);
70917d15b25SDag-Erling Smørgrav 		return UB_NOMEM;
71017d15b25SDag-Erling Smørgrav 	}
71117d15b25SDag-Erling Smørgrav 	free(qinfo.qname);
71217d15b25SDag-Erling Smørgrav 	return UB_NOERROR;
71317d15b25SDag-Erling Smørgrav }
71417d15b25SDag-Erling Smørgrav 
715b7579f77SDag-Erling Smørgrav /** add result to the bg worker result queue */
716b7579f77SDag-Erling Smørgrav static void
71717d15b25SDag-Erling Smørgrav add_bg_result(struct libworker* w, struct ctx_query* q, sldns_buffer* pkt,
7184c75e3aaSDag-Erling Smørgrav 	int err, char* reason, int was_ratelimited)
719b7579f77SDag-Erling Smørgrav {
720b7579f77SDag-Erling Smørgrav 	uint8_t* msg = NULL;
721b7579f77SDag-Erling Smørgrav 	uint32_t len = 0;
722b7579f77SDag-Erling Smørgrav 
7230fb34990SDag-Erling Smørgrav 	if(w->want_quit) {
7240fb34990SDag-Erling Smørgrav 		context_query_delete(q);
7250fb34990SDag-Erling Smørgrav 		return;
7260fb34990SDag-Erling Smørgrav 	}
727b7579f77SDag-Erling Smørgrav 	/* serialize and delete unneeded q */
728b7579f77SDag-Erling Smørgrav 	if(w->is_bg_thread) {
729b7579f77SDag-Erling Smørgrav 		lock_basic_lock(&w->ctx->cfglock);
730b7579f77SDag-Erling Smørgrav 		if(reason)
731b7579f77SDag-Erling Smørgrav 			q->res->why_bogus = strdup(reason);
7324c75e3aaSDag-Erling Smørgrav 		q->res->was_ratelimited = was_ratelimited;
733b7579f77SDag-Erling Smørgrav 		if(pkt) {
73417d15b25SDag-Erling Smørgrav 			q->msg_len = sldns_buffer_remaining(pkt);
73517d15b25SDag-Erling Smørgrav 			q->msg = memdup(sldns_buffer_begin(pkt), q->msg_len);
7364c75e3aaSDag-Erling Smørgrav 			if(!q->msg) {
7374c75e3aaSDag-Erling Smørgrav 				msg = context_serialize_answer(q, UB_NOMEM, NULL, &len);
7384c75e3aaSDag-Erling Smørgrav 			} else {
7394c75e3aaSDag-Erling Smørgrav 				msg = context_serialize_answer(q, err, NULL, &len);
7404c75e3aaSDag-Erling Smørgrav 			}
7414c75e3aaSDag-Erling Smørgrav 		} else {
7424c75e3aaSDag-Erling Smørgrav 			msg = context_serialize_answer(q, err, NULL, &len);
7434c75e3aaSDag-Erling Smørgrav 		}
744b7579f77SDag-Erling Smørgrav 		lock_basic_unlock(&w->ctx->cfglock);
745b7579f77SDag-Erling Smørgrav 	} else {
746b7579f77SDag-Erling Smørgrav 		if(reason)
747b7579f77SDag-Erling Smørgrav 			q->res->why_bogus = strdup(reason);
7484c75e3aaSDag-Erling Smørgrav 		q->res->was_ratelimited = was_ratelimited;
749b7579f77SDag-Erling Smørgrav 		msg = context_serialize_answer(q, err, pkt, &len);
750b7579f77SDag-Erling Smørgrav 		(void)rbtree_delete(&w->ctx->queries, q->node.key);
751b7579f77SDag-Erling Smørgrav 		w->ctx->num_async--;
752b7579f77SDag-Erling Smørgrav 		context_query_delete(q);
753b7579f77SDag-Erling Smørgrav 	}
754b7579f77SDag-Erling Smørgrav 
755b7579f77SDag-Erling Smørgrav 	if(!msg) {
756b7579f77SDag-Erling Smørgrav 		log_err("out of memory for async answer");
757b7579f77SDag-Erling Smørgrav 		return;
758b7579f77SDag-Erling Smørgrav 	}
759b7579f77SDag-Erling Smørgrav 	if(!tube_queue_item(w->ctx->rr_pipe, msg, len)) {
760b7579f77SDag-Erling Smørgrav 		log_err("out of memory for async answer");
761b7579f77SDag-Erling Smørgrav 		return;
762b7579f77SDag-Erling Smørgrav 	}
763b7579f77SDag-Erling Smørgrav }
764b7579f77SDag-Erling Smørgrav 
765b7579f77SDag-Erling Smørgrav void
76617d15b25SDag-Erling Smørgrav libworker_bg_done_cb(void* arg, int rcode, sldns_buffer* buf, enum sec_status s,
7674c75e3aaSDag-Erling Smørgrav 	char* why_bogus, int was_ratelimited)
768b7579f77SDag-Erling Smørgrav {
769b7579f77SDag-Erling Smørgrav 	struct ctx_query* q = (struct ctx_query*)arg;
770b7579f77SDag-Erling Smørgrav 
771971980c3SDag-Erling Smørgrav 	if(q->cancelled || q->w->back->want_to_quit) {
772b7579f77SDag-Erling Smørgrav 		if(q->w->is_bg_thread) {
773b7579f77SDag-Erling Smørgrav 			/* delete it now */
774b7579f77SDag-Erling Smørgrav 			struct ub_ctx* ctx = q->w->ctx;
775b7579f77SDag-Erling Smørgrav 			lock_basic_lock(&ctx->cfglock);
776b7579f77SDag-Erling Smørgrav 			(void)rbtree_delete(&ctx->queries, q->node.key);
777b7579f77SDag-Erling Smørgrav 			ctx->num_async--;
778b7579f77SDag-Erling Smørgrav 			context_query_delete(q);
779b7579f77SDag-Erling Smørgrav 			lock_basic_unlock(&ctx->cfglock);
780b7579f77SDag-Erling Smørgrav 		}
781b7579f77SDag-Erling Smørgrav 		/* cancelled, do not give answer */
782b7579f77SDag-Erling Smørgrav 		return;
783b7579f77SDag-Erling Smørgrav 	}
784b7579f77SDag-Erling Smørgrav 	q->msg_security = s;
7854c75e3aaSDag-Erling Smørgrav 	if(!buf) {
7868ed2b524SDag-Erling Smørgrav 		buf = q->w->env->scratch_buffer;
7874c75e3aaSDag-Erling Smørgrav 	}
788b7579f77SDag-Erling Smørgrav 	if(rcode != 0) {
789b7579f77SDag-Erling Smørgrav 		error_encode(buf, rcode, NULL, 0, BIT_RD, NULL);
790b7579f77SDag-Erling Smørgrav 	}
7914c75e3aaSDag-Erling Smørgrav 	add_bg_result(q->w, q, buf, UB_NOERROR, why_bogus, was_ratelimited);
792b7579f77SDag-Erling Smørgrav }
793b7579f77SDag-Erling Smørgrav 
794b7579f77SDag-Erling Smørgrav 
795b7579f77SDag-Erling Smørgrav /** handle new query command for bg worker */
796b7579f77SDag-Erling Smørgrav static void
797b7579f77SDag-Erling Smørgrav handle_newq(struct libworker* w, uint8_t* buf, uint32_t len)
798b7579f77SDag-Erling Smørgrav {
799b7579f77SDag-Erling Smørgrav 	uint16_t qflags, qid;
800b7579f77SDag-Erling Smørgrav 	struct query_info qinfo;
801b7579f77SDag-Erling Smørgrav 	struct edns_data edns;
802b7579f77SDag-Erling Smørgrav 	struct ctx_query* q;
803b7579f77SDag-Erling Smørgrav 	if(w->is_bg_thread) {
804b7579f77SDag-Erling Smørgrav 		lock_basic_lock(&w->ctx->cfglock);
805b7579f77SDag-Erling Smørgrav 		q = context_lookup_new_query(w->ctx, buf, len);
806b7579f77SDag-Erling Smørgrav 		lock_basic_unlock(&w->ctx->cfglock);
807b7579f77SDag-Erling Smørgrav 	} else {
808b7579f77SDag-Erling Smørgrav 		q = context_deserialize_new_query(w->ctx, buf, len);
809b7579f77SDag-Erling Smørgrav 	}
810b7579f77SDag-Erling Smørgrav 	free(buf);
811b7579f77SDag-Erling Smørgrav 	if(!q) {
812b7579f77SDag-Erling Smørgrav 		log_err("failed to deserialize newq");
813b7579f77SDag-Erling Smørgrav 		return;
814b7579f77SDag-Erling Smørgrav 	}
815b7579f77SDag-Erling Smørgrav 	if(!setup_qinfo_edns(w, q, &qinfo, &edns)) {
8164c75e3aaSDag-Erling Smørgrav 		add_bg_result(w, q, NULL, UB_SYNTAX, NULL, 0);
817b7579f77SDag-Erling Smørgrav 		return;
818b7579f77SDag-Erling Smørgrav 	}
819b7579f77SDag-Erling Smørgrav 	qid = 0;
820b7579f77SDag-Erling Smørgrav 	qflags = BIT_RD;
821b7579f77SDag-Erling Smørgrav 	/* see if there is a fixed answer */
82217d15b25SDag-Erling Smørgrav 	sldns_buffer_write_u16_at(w->back->udp_buff, 0, qid);
82317d15b25SDag-Erling Smørgrav 	sldns_buffer_write_u16_at(w->back->udp_buff, 2, qflags);
824bc892140SDag-Erling Smørgrav 	if(local_zones_answer(w->ctx->local_zones, w->env, &qinfo, &edns,
825b5663de9SDag-Erling Smørgrav 		w->back->udp_buff, w->env->scratch, NULL, NULL, 0, NULL, 0,
826bc892140SDag-Erling Smørgrav 		NULL, 0, NULL, 0, NULL)) {
827b7579f77SDag-Erling Smørgrav 		regional_free_all(w->env->scratch);
828b7579f77SDag-Erling Smørgrav 		q->msg_security = sec_status_insecure;
8294c75e3aaSDag-Erling Smørgrav 		add_bg_result(w, q, w->back->udp_buff, UB_NOERROR, NULL, 0);
830b7579f77SDag-Erling Smørgrav 		free(qinfo.qname);
831b7579f77SDag-Erling Smørgrav 		return;
832b7579f77SDag-Erling Smørgrav 	}
83357bddd21SDag-Erling Smørgrav 	if(w->ctx->env->auth_zones && auth_zones_answer(w->ctx->env->auth_zones,
8344c75e3aaSDag-Erling Smørgrav 		w->env, &qinfo, &edns, NULL, w->back->udp_buff, w->env->scratch)) {
83557bddd21SDag-Erling Smørgrav 		regional_free_all(w->env->scratch);
83657bddd21SDag-Erling Smørgrav 		q->msg_security = sec_status_insecure;
8374c75e3aaSDag-Erling Smørgrav 		add_bg_result(w, q, w->back->udp_buff, UB_NOERROR, NULL, 0);
83857bddd21SDag-Erling Smørgrav 		free(qinfo.qname);
83957bddd21SDag-Erling Smørgrav 		return;
84057bddd21SDag-Erling Smørgrav 	}
841b7579f77SDag-Erling Smørgrav 	q->w = w;
842b7579f77SDag-Erling Smørgrav 	/* process new query */
843b7579f77SDag-Erling Smørgrav 	if(!mesh_new_callback(w->env->mesh, &qinfo, qflags, &edns,
844b7579f77SDag-Erling Smørgrav 		w->back->udp_buff, qid, libworker_bg_done_cb, q)) {
8454c75e3aaSDag-Erling Smørgrav 		add_bg_result(w, q, NULL, UB_NOMEM, NULL, 0);
846b7579f77SDag-Erling Smørgrav 	}
847b7579f77SDag-Erling Smørgrav 	free(qinfo.qname);
848b7579f77SDag-Erling Smørgrav }
849b7579f77SDag-Erling Smørgrav 
850b7579f77SDag-Erling Smørgrav void libworker_alloc_cleanup(void* arg)
851b7579f77SDag-Erling Smørgrav {
852b7579f77SDag-Erling Smørgrav 	struct libworker* w = (struct libworker*)arg;
853b7579f77SDag-Erling Smørgrav 	slabhash_clear(&w->env->rrset_cache->table);
854b7579f77SDag-Erling Smørgrav         slabhash_clear(w->env->msg_cache);
855b7579f77SDag-Erling Smørgrav }
856b7579f77SDag-Erling Smørgrav 
857bc892140SDag-Erling Smørgrav struct outbound_entry* libworker_send_query(struct query_info* qinfo,
858bc892140SDag-Erling Smørgrav 	uint16_t flags, int dnssec, int want_dnssec, int nocaps,
859e2d15004SDag-Erling Smørgrav 	struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
8600fb34990SDag-Erling Smørgrav 	size_t zonelen, int ssl_upstream, char* tls_auth_name,
8610fb34990SDag-Erling Smørgrav 	struct module_qstate* q)
862b7579f77SDag-Erling Smørgrav {
863b7579f77SDag-Erling Smørgrav 	struct libworker* w = (struct libworker*)q->env->worker;
864b7579f77SDag-Erling Smørgrav 	struct outbound_entry* e = (struct outbound_entry*)regional_alloc(
865b7579f77SDag-Erling Smørgrav 		q->region, sizeof(*e));
866b7579f77SDag-Erling Smørgrav 	if(!e)
867b7579f77SDag-Erling Smørgrav 		return NULL;
868b7579f77SDag-Erling Smørgrav 	e->qstate = q;
869bc892140SDag-Erling Smørgrav 	e->qsent = outnet_serviced_query(w->back, qinfo, flags, dnssec,
870bc892140SDag-Erling Smørgrav 		want_dnssec, nocaps, q->env->cfg->tcp_upstream, ssl_upstream,
8710fb34990SDag-Erling Smørgrav 		tls_auth_name, addr, addrlen, zone, zonelen, q,
8720fb34990SDag-Erling Smørgrav 		libworker_handle_service_reply, e, w->back->udp_buff, q->env);
873b7579f77SDag-Erling Smørgrav 	if(!e->qsent) {
874b7579f77SDag-Erling Smørgrav 		return NULL;
875b7579f77SDag-Erling Smørgrav 	}
876b7579f77SDag-Erling Smørgrav 	return e;
877b7579f77SDag-Erling Smørgrav }
878b7579f77SDag-Erling Smørgrav 
879b7579f77SDag-Erling Smørgrav int
880b7579f77SDag-Erling Smørgrav libworker_handle_reply(struct comm_point* c, void* arg, int error,
881b7579f77SDag-Erling Smørgrav         struct comm_reply* reply_info)
882b7579f77SDag-Erling Smørgrav {
883b7579f77SDag-Erling Smørgrav 	struct module_qstate* q = (struct module_qstate*)arg;
884b7579f77SDag-Erling Smørgrav 	struct libworker* lw = (struct libworker*)q->env->worker;
885b7579f77SDag-Erling Smørgrav 	struct outbound_entry e;
886b7579f77SDag-Erling Smørgrav 	e.qstate = q;
887b7579f77SDag-Erling Smørgrav 	e.qsent = NULL;
888b7579f77SDag-Erling Smørgrav 
889b7579f77SDag-Erling Smørgrav 	if(error != 0) {
890b7579f77SDag-Erling Smørgrav 		mesh_report_reply(lw->env->mesh, &e, reply_info, error);
891b7579f77SDag-Erling Smørgrav 		return 0;
892b7579f77SDag-Erling Smørgrav 	}
893b7579f77SDag-Erling Smørgrav 	/* sanity check. */
89417d15b25SDag-Erling Smørgrav 	if(!LDNS_QR_WIRE(sldns_buffer_begin(c->buffer))
89517d15b25SDag-Erling Smørgrav 		|| LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) !=
896b7579f77SDag-Erling Smørgrav 			LDNS_PACKET_QUERY
89717d15b25SDag-Erling Smørgrav 		|| LDNS_QDCOUNT(sldns_buffer_begin(c->buffer)) > 1) {
898b7579f77SDag-Erling Smørgrav 		/* error becomes timeout for the module as if this reply
899b7579f77SDag-Erling Smørgrav 		 * never arrived. */
900b7579f77SDag-Erling Smørgrav 		mesh_report_reply(lw->env->mesh, &e, reply_info,
901b7579f77SDag-Erling Smørgrav 			NETEVENT_TIMEOUT);
902b7579f77SDag-Erling Smørgrav 		return 0;
903b7579f77SDag-Erling Smørgrav 	}
904b7579f77SDag-Erling Smørgrav 	mesh_report_reply(lw->env->mesh, &e, reply_info, NETEVENT_NOERROR);
905b7579f77SDag-Erling Smørgrav 	return 0;
906b7579f77SDag-Erling Smørgrav }
907b7579f77SDag-Erling Smørgrav 
908b7579f77SDag-Erling Smørgrav int
909b7579f77SDag-Erling Smørgrav libworker_handle_service_reply(struct comm_point* c, void* arg, int error,
910b7579f77SDag-Erling Smørgrav         struct comm_reply* reply_info)
911b7579f77SDag-Erling Smørgrav {
912b7579f77SDag-Erling Smørgrav 	struct outbound_entry* e = (struct outbound_entry*)arg;
913b7579f77SDag-Erling Smørgrav 	struct libworker* lw = (struct libworker*)e->qstate->env->worker;
914b7579f77SDag-Erling Smørgrav 
915b7579f77SDag-Erling Smørgrav 	if(error != 0) {
916b7579f77SDag-Erling Smørgrav 		mesh_report_reply(lw->env->mesh, e, reply_info, error);
917b7579f77SDag-Erling Smørgrav 		return 0;
918b7579f77SDag-Erling Smørgrav 	}
919b7579f77SDag-Erling Smørgrav 	/* sanity check. */
92017d15b25SDag-Erling Smørgrav 	if(!LDNS_QR_WIRE(sldns_buffer_begin(c->buffer))
92117d15b25SDag-Erling Smørgrav 		|| LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) !=
922b7579f77SDag-Erling Smørgrav 			LDNS_PACKET_QUERY
92317d15b25SDag-Erling Smørgrav 		|| LDNS_QDCOUNT(sldns_buffer_begin(c->buffer)) > 1) {
924b7579f77SDag-Erling Smørgrav 		/* error becomes timeout for the module as if this reply
925b7579f77SDag-Erling Smørgrav 		 * never arrived. */
926b7579f77SDag-Erling Smørgrav 		mesh_report_reply(lw->env->mesh, e, reply_info,
927b7579f77SDag-Erling Smørgrav 			NETEVENT_TIMEOUT);
928b7579f77SDag-Erling Smørgrav 		return 0;
929b7579f77SDag-Erling Smørgrav 	}
930b7579f77SDag-Erling Smørgrav 	mesh_report_reply(lw->env->mesh,  e, reply_info, NETEVENT_NOERROR);
931b7579f77SDag-Erling Smørgrav 	return 0;
932b7579f77SDag-Erling Smørgrav }
933b7579f77SDag-Erling Smørgrav 
934b7579f77SDag-Erling Smørgrav /* --- fake callbacks for fptr_wlist to work --- */
935b7579f77SDag-Erling Smørgrav void worker_handle_control_cmd(struct tube* ATTR_UNUSED(tube),
936b7579f77SDag-Erling Smørgrav 	uint8_t* ATTR_UNUSED(buffer), size_t ATTR_UNUSED(len),
937b7579f77SDag-Erling Smørgrav 	int ATTR_UNUSED(error), void* ATTR_UNUSED(arg))
938b7579f77SDag-Erling Smørgrav {
939b7579f77SDag-Erling Smørgrav 	log_assert(0);
940b7579f77SDag-Erling Smørgrav }
941b7579f77SDag-Erling Smørgrav 
942b7579f77SDag-Erling Smørgrav int worker_handle_request(struct comm_point* ATTR_UNUSED(c),
943b7579f77SDag-Erling Smørgrav 	void* ATTR_UNUSED(arg), int ATTR_UNUSED(error),
944b7579f77SDag-Erling Smørgrav         struct comm_reply* ATTR_UNUSED(repinfo))
945b7579f77SDag-Erling Smørgrav {
946b7579f77SDag-Erling Smørgrav 	log_assert(0);
947b7579f77SDag-Erling Smørgrav 	return 0;
948b7579f77SDag-Erling Smørgrav }
949b7579f77SDag-Erling Smørgrav 
950b7579f77SDag-Erling Smørgrav int worker_handle_reply(struct comm_point* ATTR_UNUSED(c),
951b7579f77SDag-Erling Smørgrav 	void* ATTR_UNUSED(arg), int ATTR_UNUSED(error),
952b7579f77SDag-Erling Smørgrav         struct comm_reply* ATTR_UNUSED(reply_info))
953b7579f77SDag-Erling Smørgrav {
954b7579f77SDag-Erling Smørgrav 	log_assert(0);
955b7579f77SDag-Erling Smørgrav 	return 0;
956b7579f77SDag-Erling Smørgrav }
957b7579f77SDag-Erling Smørgrav 
958b7579f77SDag-Erling Smørgrav int worker_handle_service_reply(struct comm_point* ATTR_UNUSED(c),
959b7579f77SDag-Erling Smørgrav 	void* ATTR_UNUSED(arg), int ATTR_UNUSED(error),
960b7579f77SDag-Erling Smørgrav         struct comm_reply* ATTR_UNUSED(reply_info))
961b7579f77SDag-Erling Smørgrav {
962b7579f77SDag-Erling Smørgrav 	log_assert(0);
963b7579f77SDag-Erling Smørgrav 	return 0;
964b7579f77SDag-Erling Smørgrav }
965b7579f77SDag-Erling Smørgrav 
966b7579f77SDag-Erling Smørgrav int remote_accept_callback(struct comm_point* ATTR_UNUSED(c),
967b7579f77SDag-Erling Smørgrav 	void* ATTR_UNUSED(arg), int ATTR_UNUSED(error),
968b7579f77SDag-Erling Smørgrav         struct comm_reply* ATTR_UNUSED(repinfo))
969b7579f77SDag-Erling Smørgrav {
970b7579f77SDag-Erling Smørgrav 	log_assert(0);
971b7579f77SDag-Erling Smørgrav 	return 0;
972b7579f77SDag-Erling Smørgrav }
973b7579f77SDag-Erling Smørgrav 
974b7579f77SDag-Erling Smørgrav int remote_control_callback(struct comm_point* ATTR_UNUSED(c),
975b7579f77SDag-Erling Smørgrav 	void* ATTR_UNUSED(arg), int ATTR_UNUSED(error),
976b7579f77SDag-Erling Smørgrav         struct comm_reply* ATTR_UNUSED(repinfo))
977b7579f77SDag-Erling Smørgrav {
978b7579f77SDag-Erling Smørgrav 	log_assert(0);
979b7579f77SDag-Erling Smørgrav 	return 0;
980b7579f77SDag-Erling Smørgrav }
981b7579f77SDag-Erling Smørgrav 
982b7579f77SDag-Erling Smørgrav void worker_sighandler(int ATTR_UNUSED(sig), void* ATTR_UNUSED(arg))
983b7579f77SDag-Erling Smørgrav {
984b7579f77SDag-Erling Smørgrav 	log_assert(0);
985b7579f77SDag-Erling Smørgrav }
986b7579f77SDag-Erling Smørgrav 
987bc892140SDag-Erling Smørgrav struct outbound_entry* worker_send_query(struct query_info* ATTR_UNUSED(qinfo),
988bc892140SDag-Erling Smørgrav 	uint16_t ATTR_UNUSED(flags), int ATTR_UNUSED(dnssec),
989bc892140SDag-Erling Smørgrav 	int ATTR_UNUSED(want_dnssec), int ATTR_UNUSED(nocaps),
990bc892140SDag-Erling Smørgrav 	struct sockaddr_storage* ATTR_UNUSED(addr), socklen_t ATTR_UNUSED(addrlen),
991bc892140SDag-Erling Smørgrav 	uint8_t* ATTR_UNUSED(zone), size_t ATTR_UNUSED(zonelen),
9920fb34990SDag-Erling Smørgrav 	int ATTR_UNUSED(ssl_upstream), char* ATTR_UNUSED(tls_auth_name),
9930fb34990SDag-Erling Smørgrav 	struct module_qstate* ATTR_UNUSED(q))
994b7579f77SDag-Erling Smørgrav {
995b7579f77SDag-Erling Smørgrav 	log_assert(0);
996b7579f77SDag-Erling Smørgrav 	return 0;
997b7579f77SDag-Erling Smørgrav }
998b7579f77SDag-Erling Smørgrav 
999b7579f77SDag-Erling Smørgrav void
1000b7579f77SDag-Erling Smørgrav worker_alloc_cleanup(void* ATTR_UNUSED(arg))
1001b7579f77SDag-Erling Smørgrav {
1002b7579f77SDag-Erling Smørgrav 	log_assert(0);
1003b7579f77SDag-Erling Smørgrav }
1004b7579f77SDag-Erling Smørgrav 
1005b7579f77SDag-Erling Smørgrav void worker_stat_timer_cb(void* ATTR_UNUSED(arg))
1006b7579f77SDag-Erling Smørgrav {
1007b7579f77SDag-Erling Smørgrav 	log_assert(0);
1008b7579f77SDag-Erling Smørgrav }
1009b7579f77SDag-Erling Smørgrav 
1010b7579f77SDag-Erling Smørgrav void worker_probe_timer_cb(void* ATTR_UNUSED(arg))
1011b7579f77SDag-Erling Smørgrav {
1012b7579f77SDag-Erling Smørgrav 	log_assert(0);
1013b7579f77SDag-Erling Smørgrav }
1014b7579f77SDag-Erling Smørgrav 
1015b7579f77SDag-Erling Smørgrav void worker_start_accept(void* ATTR_UNUSED(arg))
1016b7579f77SDag-Erling Smørgrav {
1017b7579f77SDag-Erling Smørgrav 	log_assert(0);
1018b7579f77SDag-Erling Smørgrav }
1019b7579f77SDag-Erling Smørgrav 
1020b7579f77SDag-Erling Smørgrav void worker_stop_accept(void* ATTR_UNUSED(arg))
1021b7579f77SDag-Erling Smørgrav {
1022b7579f77SDag-Erling Smørgrav 	log_assert(0);
1023b7579f77SDag-Erling Smørgrav }
1024b7579f77SDag-Erling Smørgrav 
1025b7579f77SDag-Erling Smørgrav int order_lock_cmp(const void* ATTR_UNUSED(e1), const void* ATTR_UNUSED(e2))
1026b7579f77SDag-Erling Smørgrav {
1027b7579f77SDag-Erling Smørgrav 	log_assert(0);
1028b7579f77SDag-Erling Smørgrav 	return 0;
1029b7579f77SDag-Erling Smørgrav }
1030b7579f77SDag-Erling Smørgrav 
1031b7579f77SDag-Erling Smørgrav int
1032b7579f77SDag-Erling Smørgrav codeline_cmp(const void* ATTR_UNUSED(a), const void* ATTR_UNUSED(b))
1033b7579f77SDag-Erling Smørgrav {
1034b7579f77SDag-Erling Smørgrav 	log_assert(0);
1035b7579f77SDag-Erling Smørgrav 	return 0;
1036b7579f77SDag-Erling Smørgrav }
1037b7579f77SDag-Erling Smørgrav 
1038b7579f77SDag-Erling Smørgrav int replay_var_compare(const void* ATTR_UNUSED(a), const void* ATTR_UNUSED(b))
1039b7579f77SDag-Erling Smørgrav {
1040b7579f77SDag-Erling Smørgrav         log_assert(0);
1041b7579f77SDag-Erling Smørgrav         return 0;
1042b7579f77SDag-Erling Smørgrav }
1043b7579f77SDag-Erling Smørgrav 
1044b7579f77SDag-Erling Smørgrav void remote_get_opt_ssl(char* ATTR_UNUSED(str), void* ATTR_UNUSED(arg))
1045b7579f77SDag-Erling Smørgrav {
1046b7579f77SDag-Erling Smørgrav         log_assert(0);
1047b7579f77SDag-Erling Smørgrav }
1048b7579f77SDag-Erling Smørgrav 
1049b7579f77SDag-Erling Smørgrav #ifdef UB_ON_WINDOWS
1050b7579f77SDag-Erling Smørgrav void
1051b7579f77SDag-Erling Smørgrav worker_win_stop_cb(int ATTR_UNUSED(fd), short ATTR_UNUSED(ev), void*
1052b7579f77SDag-Erling Smørgrav         ATTR_UNUSED(arg)) {
1053b7579f77SDag-Erling Smørgrav         log_assert(0);
1054b7579f77SDag-Erling Smørgrav }
1055b7579f77SDag-Erling Smørgrav 
1056b7579f77SDag-Erling Smørgrav void
1057b7579f77SDag-Erling Smørgrav wsvc_cron_cb(void* ATTR_UNUSED(arg))
1058b7579f77SDag-Erling Smørgrav {
1059b7579f77SDag-Erling Smørgrav         log_assert(0);
1060b7579f77SDag-Erling Smørgrav }
1061b7579f77SDag-Erling Smørgrav #endif /* UB_ON_WINDOWS */
106225039b37SCy Schubert 
106325039b37SCy Schubert #ifdef USE_DNSTAP
106425039b37SCy Schubert void dtio_tap_callback(int ATTR_UNUSED(fd), short ATTR_UNUSED(ev),
106525039b37SCy Schubert 	void* ATTR_UNUSED(arg))
106625039b37SCy Schubert {
106725039b37SCy Schubert 	log_assert(0);
106825039b37SCy Schubert }
106925039b37SCy Schubert #endif
107025039b37SCy Schubert 
107125039b37SCy Schubert #ifdef USE_DNSTAP
107225039b37SCy Schubert void dtio_mainfdcallback(int ATTR_UNUSED(fd), short ATTR_UNUSED(ev),
107325039b37SCy Schubert 	void* ATTR_UNUSED(arg))
107425039b37SCy Schubert {
107525039b37SCy Schubert 	log_assert(0);
107625039b37SCy Schubert }
107725039b37SCy Schubert #endif
1078