xref: /freebsd/contrib/unbound/libunbound/libworker.c (revision f15e18a642cb3f7ebc747f8e9cdf11274140107d)
1 /*
2  * libunbound/worker.c - worker thread or process that resolves
3  *
4  * Copyright (c) 2007, NLnet Labs. All rights reserved.
5  *
6  * This software is open source.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * Redistributions of source code must retain the above copyright notice,
13  * this list of conditions and the following disclaimer.
14  *
15  * Redistributions in binary form must reproduce the above copyright notice,
16  * this list of conditions and the following disclaimer in the documentation
17  * and/or other materials provided with the distribution.
18  *
19  * Neither the name of the NLNET LABS nor the names of its contributors may
20  * be used to endorse or promote products derived from this software without
21  * specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
29  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
30  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34  */
35 
36 /**
37  * \file
38  *
39  * This file contains the worker process or thread that performs
40  * the DNS resolving and validation. The worker is called by a procedure
41  * and if in the background continues until exit, if in the foreground
42  * returns from the procedure when done.
43  */
44 #include "config.h"
45 #ifdef HAVE_SSL
46 #include <openssl/ssl.h>
47 #endif
48 #include "libunbound/libworker.h"
49 #include "libunbound/context.h"
50 #include "libunbound/unbound.h"
51 #include "libunbound/worker.h"
52 #include "libunbound/unbound-event.h"
53 #include "services/outside_network.h"
54 #include "services/mesh.h"
55 #include "services/localzone.h"
56 #include "services/cache/rrset.h"
57 #include "services/outbound_list.h"
58 #include "services/authzone.h"
59 #include "util/fptr_wlist.h"
60 #include "util/module.h"
61 #include "util/regional.h"
62 #include "util/random.h"
63 #include "util/config_file.h"
64 #include "util/netevent.h"
65 #include "util/storage/lookup3.h"
66 #include "util/storage/slabhash.h"
67 #include "util/net_help.h"
68 #include "util/data/dname.h"
69 #include "util/data/msgreply.h"
70 #include "util/data/msgencode.h"
71 #include "util/tube.h"
72 #include "iterator/iter_fwd.h"
73 #include "iterator/iter_hints.h"
74 #include "sldns/sbuffer.h"
75 #include "sldns/str2wire.h"
76 #ifdef USE_DNSTAP
77 #include "dnstap/dtstream.h"
78 #endif
79 
80 #ifdef HAVE_TARGETCONDITIONALS_H
81 #include <TargetConditionals.h>
82 #endif
83 
84 #if (defined(TARGET_OS_TV) && TARGET_OS_TV) || (defined(TARGET_OS_WATCH) && TARGET_OS_WATCH)
85 #undef HAVE_FORK
86 #endif
87 
88 /** handle new query command for bg worker */
89 static void handle_newq(struct libworker* w, uint8_t* buf, uint32_t len);
90 
91 /** delete libworker env */
92 static void
93 libworker_delete_env(struct libworker* w)
94 {
95 	if(w->env) {
96 		outside_network_quit_prepare(w->back);
97 		mesh_delete(w->env->mesh);
98 		context_release_alloc(w->ctx, w->env->alloc,
99 			!w->is_bg || w->is_bg_thread);
100 		sldns_buffer_free(w->env->scratch_buffer);
101 		regional_destroy(w->env->scratch);
102 		forwards_delete(w->env->fwds);
103 		hints_delete(w->env->hints);
104 		ub_randfree(w->env->rnd);
105 		free(w->env);
106 	}
107 #ifdef HAVE_SSL
108 	SSL_CTX_free(w->sslctx);
109 #endif
110 	outside_network_delete(w->back);
111 }
112 
113 /** delete libworker struct */
114 static void
115 libworker_delete(struct libworker* w)
116 {
117 	if(!w) return;
118 	libworker_delete_env(w);
119 	comm_base_delete(w->base);
120 	free(w);
121 }
122 
123 void
124 libworker_delete_event(struct libworker* w)
125 {
126 	if(!w) return;
127 	libworker_delete_env(w);
128 	comm_base_delete_no_base(w->base);
129 	free(w);
130 }
131 
132 /** setup fresh libworker struct */
133 static struct libworker*
134 libworker_setup(struct ub_ctx* ctx, int is_bg, struct ub_event_base* eb)
135 {
136 	struct libworker* w = (struct libworker*)calloc(1, sizeof(*w));
137 	struct config_file* cfg = ctx->env->cfg;
138 	int* ports;
139 	int numports;
140 	if(!w) return NULL;
141 	w->is_bg = is_bg;
142 	w->ctx = ctx;
143 	w->env = (struct module_env*)malloc(sizeof(*w->env));
144 	if(!w->env) {
145 		free(w);
146 		return NULL;
147 	}
148 	*w->env = *ctx->env;
149 	w->env->alloc = context_obtain_alloc(ctx, !w->is_bg || w->is_bg_thread);
150 	if(!w->env->alloc) {
151 		libworker_delete(w);
152 		return NULL;
153 	}
154 	w->thread_num = w->env->alloc->thread_num;
155 	alloc_set_id_cleanup(w->env->alloc, &libworker_alloc_cleanup, w);
156 	if(!w->is_bg || w->is_bg_thread) {
157 		lock_basic_lock(&ctx->cfglock);
158 	}
159 	w->env->scratch = regional_create_custom(cfg->msg_buffer_size);
160 	w->env->scratch_buffer = sldns_buffer_new(cfg->msg_buffer_size);
161 	w->env->fwds = forwards_create();
162 	if(w->env->fwds && !forwards_apply_cfg(w->env->fwds, cfg)) {
163 		forwards_delete(w->env->fwds);
164 		w->env->fwds = NULL;
165 	}
166 	w->env->hints = hints_create();
167 	if(w->env->hints && !hints_apply_cfg(w->env->hints, cfg)) {
168 		hints_delete(w->env->hints);
169 		w->env->hints = NULL;
170 	}
171 	if(cfg->ssl_upstream || (cfg->tls_cert_bundle && cfg->tls_cert_bundle[0]) || cfg->tls_win_cert) {
172 		w->sslctx = connect_sslctx_create(NULL, NULL,
173 			cfg->tls_cert_bundle, cfg->tls_win_cert);
174 		if(!w->sslctx) {
175 			/* to make the setup fail after unlock */
176 			hints_delete(w->env->hints);
177 			w->env->hints = NULL;
178 		}
179 	}
180 	if(!w->is_bg || w->is_bg_thread) {
181 		lock_basic_unlock(&ctx->cfglock);
182 	}
183 	if(!w->env->scratch || !w->env->scratch_buffer || !w->env->fwds ||
184 		!w->env->hints) {
185 		libworker_delete(w);
186 		return NULL;
187 	}
188 	w->env->worker = (struct worker*)w;
189 	w->env->probe_timer = NULL;
190 	if(!w->is_bg || w->is_bg_thread) {
191 		lock_basic_lock(&ctx->cfglock);
192 	}
193 	if(!(w->env->rnd = ub_initstate(ctx->seed_rnd))) {
194 		if(!w->is_bg || w->is_bg_thread) {
195 			lock_basic_unlock(&ctx->cfglock);
196 		}
197 		libworker_delete(w);
198 		return NULL;
199 	}
200 	if(!w->is_bg || w->is_bg_thread) {
201 		lock_basic_unlock(&ctx->cfglock);
202 	}
203 	if(1) {
204 		/* primitive lockout for threading: if it overwrites another
205 		 * thread it is like wiping the cache (which is likely empty
206 		 * at the start) */
207 		/* note we are holding the ctx lock in normal threaded
208 		 * cases so that is solved properly, it is only for many ctx
209 		 * in different threads that this may clash */
210 		static int done_raninit = 0;
211 		if(!done_raninit) {
212 			done_raninit = 1;
213 			hash_set_raninit((uint32_t)ub_random(w->env->rnd));
214 		}
215 	}
216 
217 	if(eb)
218 		w->base = comm_base_create_event(eb);
219 	else	w->base = comm_base_create(0);
220 	if(!w->base) {
221 		libworker_delete(w);
222 		return NULL;
223 	}
224 	w->env->worker_base = w->base;
225 	if(!w->is_bg || w->is_bg_thread) {
226 		lock_basic_lock(&ctx->cfglock);
227 	}
228 	numports = cfg_condense_ports(cfg, &ports);
229 	if(numports == 0) {
230 		if(!w->is_bg || w->is_bg_thread) {
231 			lock_basic_unlock(&ctx->cfglock);
232 		}
233 		libworker_delete(w);
234 		return NULL;
235 	}
236 	w->back = outside_network_create(w->base, cfg->msg_buffer_size,
237 		(size_t)cfg->outgoing_num_ports, cfg->out_ifs,
238 		cfg->num_out_ifs, cfg->do_ip4, cfg->do_ip6,
239 		cfg->do_tcp?cfg->outgoing_num_tcp:0, cfg->ip_dscp,
240 		w->env->infra_cache, w->env->rnd, cfg->use_caps_bits_for_id,
241 		ports, numports, cfg->unwanted_threshold,
242 		cfg->outgoing_tcp_mss, &libworker_alloc_cleanup, w,
243 		cfg->do_udp || cfg->udp_upstream_without_downstream, w->sslctx,
244 		cfg->delay_close, cfg->tls_use_sni, NULL, cfg->udp_connect);
245 	w->env->outnet = w->back;
246 	if(!w->is_bg || w->is_bg_thread) {
247 		lock_basic_unlock(&ctx->cfglock);
248 	}
249 	free(ports);
250 	if(!w->back) {
251 		libworker_delete(w);
252 		return NULL;
253 	}
254 	w->env->mesh = mesh_create(&ctx->mods, w->env);
255 	if(!w->env->mesh) {
256 		libworker_delete(w);
257 		return NULL;
258 	}
259 	w->env->send_query = &libworker_send_query;
260 	w->env->detach_subs = &mesh_detach_subs;
261 	w->env->attach_sub = &mesh_attach_sub;
262 	w->env->add_sub = &mesh_add_sub;
263 	w->env->kill_sub = &mesh_state_delete;
264 	w->env->detect_cycle = &mesh_detect_cycle;
265 	comm_base_timept(w->base, &w->env->now, &w->env->now_tv);
266 	return w;
267 }
268 
269 struct libworker* libworker_create_event(struct ub_ctx* ctx,
270 	struct ub_event_base* eb)
271 {
272 	return libworker_setup(ctx, 0, eb);
273 }
274 
275 /** handle cancel command for bg worker */
276 static void
277 handle_cancel(struct libworker* w, uint8_t* buf, uint32_t len)
278 {
279 	struct ctx_query* q;
280 	if(w->is_bg_thread) {
281 		lock_basic_lock(&w->ctx->cfglock);
282 		q = context_deserialize_cancel(w->ctx, buf, len);
283 		lock_basic_unlock(&w->ctx->cfglock);
284 	} else {
285 		q = context_deserialize_cancel(w->ctx, buf, len);
286 	}
287 	if(!q) {
288 		/* probably simply lookup failed, i.e. the message had been
289 		 * processed and answered before the cancel arrived */
290 		return;
291 	}
292 	q->cancelled = 1;
293 	free(buf);
294 }
295 
296 /** do control command coming into bg server */
297 static void
298 libworker_do_cmd(struct libworker* w, uint8_t* msg, uint32_t len)
299 {
300 	switch(context_serial_getcmd(msg, len)) {
301 		default:
302 		case UB_LIBCMD_ANSWER:
303 			log_err("unknown command for bg worker %d",
304 				(int)context_serial_getcmd(msg, len));
305 			/* and fall through to quit */
306 			/* fallthrough */
307 		case UB_LIBCMD_QUIT:
308 			free(msg);
309 			comm_base_exit(w->base);
310 			break;
311 		case UB_LIBCMD_NEWQUERY:
312 			handle_newq(w, msg, len);
313 			break;
314 		case UB_LIBCMD_CANCEL:
315 			handle_cancel(w, msg, len);
316 			break;
317 	}
318 }
319 
320 /** handle control command coming into server */
321 void
322 libworker_handle_control_cmd(struct tube* ATTR_UNUSED(tube),
323 	uint8_t* msg, size_t len, int err, void* arg)
324 {
325 	struct libworker* w = (struct libworker*)arg;
326 
327 	if(err != 0) {
328 		free(msg);
329 		/* it is of no use to go on, exit */
330 		comm_base_exit(w->base);
331 		return;
332 	}
333 	libworker_do_cmd(w, msg, len); /* also frees the buf */
334 }
335 
336 /** the background thread func */
337 static void*
338 libworker_dobg(void* arg)
339 {
340 	/* setup */
341 	uint32_t m;
342 	struct libworker* w = (struct libworker*)arg;
343 	struct ub_ctx* ctx;
344 	if(!w) {
345 		log_err("libunbound bg worker init failed, nomem");
346 		return NULL;
347 	}
348 	ctx = w->ctx;
349 	log_thread_set(&w->thread_num);
350 #ifdef THREADS_DISABLED
351 	/* we are forked */
352 	w->is_bg_thread = 0;
353 	/* close non-used parts of the pipes */
354 	tube_close_write(ctx->qq_pipe);
355 	tube_close_read(ctx->rr_pipe);
356 #endif
357 	if(!tube_setup_bg_listen(ctx->qq_pipe, w->base,
358 		libworker_handle_control_cmd, w)) {
359 		log_err("libunbound bg worker init failed, no bglisten");
360 		return NULL;
361 	}
362 	if(!tube_setup_bg_write(ctx->rr_pipe, w->base)) {
363 		log_err("libunbound bg worker init failed, no bgwrite");
364 		return NULL;
365 	}
366 
367 	/* do the work */
368 	comm_base_dispatch(w->base);
369 
370 	/* cleanup */
371 	m = UB_LIBCMD_QUIT;
372 	w->want_quit = 1;
373 	tube_remove_bg_listen(w->ctx->qq_pipe);
374 	tube_remove_bg_write(w->ctx->rr_pipe);
375 	libworker_delete(w);
376 	(void)tube_write_msg(ctx->rr_pipe, (uint8_t*)&m,
377 		(uint32_t)sizeof(m), 0);
378 #ifdef THREADS_DISABLED
379 	/* close pipes from forked process before exit */
380 	tube_close_read(ctx->qq_pipe);
381 	tube_close_write(ctx->rr_pipe);
382 #endif
383 	return NULL;
384 }
385 
386 int libworker_bg(struct ub_ctx* ctx)
387 {
388 	struct libworker* w;
389 	/* fork or threadcreate */
390 	lock_basic_lock(&ctx->cfglock);
391 	if(ctx->dothread) {
392 		lock_basic_unlock(&ctx->cfglock);
393 		w = libworker_setup(ctx, 1, NULL);
394 		if(!w) return UB_NOMEM;
395 		w->is_bg_thread = 1;
396 #ifdef ENABLE_LOCK_CHECKS
397 		w->thread_num = 1; /* for nicer DEBUG checklocks */
398 #endif
399 		ub_thread_create(&ctx->bg_tid, libworker_dobg, w);
400 	} else {
401 		lock_basic_unlock(&ctx->cfglock);
402 #ifndef HAVE_FORK
403 		/* no fork on windows */
404 		return UB_FORKFAIL;
405 #else /* HAVE_FORK */
406 		switch((ctx->bg_pid=fork())) {
407 			case 0:
408 				w = libworker_setup(ctx, 1, NULL);
409 				if(!w) fatal_exit("out of memory");
410 				/* close non-used parts of the pipes */
411 				tube_close_write(ctx->qq_pipe);
412 				tube_close_read(ctx->rr_pipe);
413 				(void)libworker_dobg(w);
414 				exit(0);
415 				break;
416 			case -1:
417 				return UB_FORKFAIL;
418 			default:
419 				/* close non-used parts, so that the worker
420 				 * bgprocess gets 'pipe closed' when the
421 				 * main process exits */
422 				tube_close_read(ctx->qq_pipe);
423 				tube_close_write(ctx->rr_pipe);
424 				break;
425 		}
426 #endif /* HAVE_FORK */
427 	}
428 	return UB_NOERROR;
429 }
430 
431 /** insert canonname */
432 static int
433 fill_canon(struct ub_result* res, uint8_t* s)
434 {
435 	char buf[255+2];
436 	dname_str(s, buf);
437 	res->canonname = strdup(buf);
438 	return res->canonname != 0;
439 }
440 
441 /** fill data into result */
442 static int
443 fill_res(struct ub_result* res, struct ub_packed_rrset_key* answer,
444 	uint8_t* finalcname, struct query_info* rq, struct reply_info* rep)
445 {
446 	size_t i;
447 	struct packed_rrset_data* data;
448 	res->ttl = 0;
449 	if(!answer) {
450 		if(finalcname) {
451 			if(!fill_canon(res, finalcname))
452 				return 0; /* out of memory */
453 		}
454 		if(rep->rrset_count != 0)
455 			res->ttl = (int)rep->ttl;
456 		res->data = (char**)calloc(1, sizeof(char*));
457 		res->len = (int*)calloc(1, sizeof(int));
458 		return (res->data && res->len);
459 	}
460 	data = (struct packed_rrset_data*)answer->entry.data;
461 	if(query_dname_compare(rq->qname, answer->rk.dname) != 0) {
462 		if(!fill_canon(res, answer->rk.dname))
463 			return 0; /* out of memory */
464 	} else	res->canonname = NULL;
465 	res->data = (char**)calloc(data->count+1, sizeof(char*));
466 	res->len = (int*)calloc(data->count+1, sizeof(int));
467 	if(!res->data || !res->len)
468 		return 0; /* out of memory */
469 	for(i=0; i<data->count; i++) {
470 		/* remove rdlength from rdata */
471 		res->len[i] = (int)(data->rr_len[i] - 2);
472 		res->data[i] = memdup(data->rr_data[i]+2, (size_t)res->len[i]);
473 		if(!res->data[i])
474 			return 0; /* out of memory */
475 	}
476 	/* ttl for positive answers, from CNAME and answer RRs */
477 	if(data->count != 0) {
478 		size_t j;
479 		res->ttl = (int)data->ttl;
480 		for(j=0; j<rep->an_numrrsets; j++) {
481 			struct packed_rrset_data* d =
482 				(struct packed_rrset_data*)rep->rrsets[j]->
483 				entry.data;
484 			if((int)d->ttl < res->ttl)
485 				res->ttl = (int)d->ttl;
486 		}
487 	}
488 	/* ttl for negative answers */
489 	if(data->count == 0 && rep->rrset_count != 0)
490 		res->ttl = (int)rep->ttl;
491 	res->data[data->count] = NULL;
492 	res->len[data->count] = 0;
493 	return 1;
494 }
495 
496 /** fill result from parsed message, on error fills servfail */
497 void
498 libworker_enter_result(struct ub_result* res, sldns_buffer* buf,
499 	struct regional* temp, enum sec_status msg_security)
500 {
501 	struct query_info rq;
502 	struct reply_info* rep;
503 	res->rcode = LDNS_RCODE_SERVFAIL;
504 	rep = parse_reply_in_temp_region(buf, temp, &rq);
505 	if(!rep) {
506 		log_err("cannot parse buf");
507 		return; /* error parsing buf, or out of memory */
508 	}
509 	if(!fill_res(res, reply_find_answer_rrset(&rq, rep),
510 		reply_find_final_cname_target(&rq, rep), &rq, rep))
511 		return; /* out of memory */
512 	/* rcode, havedata, nxdomain, secure, bogus */
513 	res->rcode = (int)FLAGS_GET_RCODE(rep->flags);
514 	if(res->data && res->data[0])
515 		res->havedata = 1;
516 	if(res->rcode == LDNS_RCODE_NXDOMAIN)
517 		res->nxdomain = 1;
518 	if(msg_security == sec_status_secure)
519 		res->secure = 1;
520 	if(msg_security == sec_status_bogus ||
521 		msg_security == sec_status_secure_sentinel_fail)
522 		res->bogus = 1;
523 }
524 
525 /** fillup fg results */
526 static void
527 libworker_fillup_fg(struct ctx_query* q, int rcode, sldns_buffer* buf,
528 	enum sec_status s, char* why_bogus, int was_ratelimited)
529 {
530 	q->res->was_ratelimited = was_ratelimited;
531 	if(why_bogus)
532 		q->res->why_bogus = strdup(why_bogus);
533 	if(rcode != 0) {
534 		q->res->rcode = rcode;
535 		q->msg_security = s;
536 		return;
537 	}
538 
539 	q->res->rcode = LDNS_RCODE_SERVFAIL;
540 	q->msg_security = sec_status_unchecked;
541 	q->msg = memdup(sldns_buffer_begin(buf), sldns_buffer_limit(buf));
542 	q->msg_len = sldns_buffer_limit(buf);
543 	if(!q->msg) {
544 		return; /* the error is in the rcode */
545 	}
546 
547 	/* canonname and results */
548 	q->msg_security = s;
549 	libworker_enter_result(q->res, buf, q->w->env->scratch, s);
550 }
551 
552 void
553 libworker_fg_done_cb(void* arg, int rcode, sldns_buffer* buf, enum sec_status s,
554 	char* why_bogus, int was_ratelimited)
555 {
556 	struct ctx_query* q = (struct ctx_query*)arg;
557 	/* fg query is done; exit comm base */
558 	comm_base_exit(q->w->base);
559 
560 	libworker_fillup_fg(q, rcode, buf, s, why_bogus, was_ratelimited);
561 }
562 
563 /** setup qinfo and edns */
564 static int
565 setup_qinfo_edns(struct libworker* w, struct ctx_query* q,
566 	struct query_info* qinfo, struct edns_data* edns)
567 {
568 	qinfo->qtype = (uint16_t)q->res->qtype;
569 	qinfo->qclass = (uint16_t)q->res->qclass;
570 	qinfo->local_alias = NULL;
571 	qinfo->qname = sldns_str2wire_dname(q->res->qname, &qinfo->qname_len);
572 	if(!qinfo->qname) {
573 		return 0;
574 	}
575 	edns->edns_present = 1;
576 	edns->ext_rcode = 0;
577 	edns->edns_version = 0;
578 	edns->bits = EDNS_DO;
579 	edns->opt_list = NULL;
580 	edns->padding_block_size = 0;
581 	if(sldns_buffer_capacity(w->back->udp_buff) < 65535)
582 		edns->udp_size = (uint16_t)sldns_buffer_capacity(
583 			w->back->udp_buff);
584 	else	edns->udp_size = 65535;
585 	return 1;
586 }
587 
588 int libworker_fg(struct ub_ctx* ctx, struct ctx_query* q)
589 {
590 	struct libworker* w = libworker_setup(ctx, 0, NULL);
591 	uint16_t qflags, qid;
592 	struct query_info qinfo;
593 	struct edns_data edns;
594 	if(!w)
595 		return UB_INITFAIL;
596 	if(!setup_qinfo_edns(w, q, &qinfo, &edns)) {
597 		libworker_delete(w);
598 		return UB_SYNTAX;
599 	}
600 	qid = 0;
601 	qflags = BIT_RD;
602 	q->w = w;
603 	/* see if there is a fixed answer */
604 	sldns_buffer_write_u16_at(w->back->udp_buff, 0, qid);
605 	sldns_buffer_write_u16_at(w->back->udp_buff, 2, qflags);
606 	if(local_zones_answer(ctx->local_zones, w->env, &qinfo, &edns,
607 		w->back->udp_buff, w->env->scratch, NULL, NULL, 0, NULL, 0,
608 		NULL, 0, NULL, 0, NULL)) {
609 		regional_free_all(w->env->scratch);
610 		libworker_fillup_fg(q, LDNS_RCODE_NOERROR,
611 			w->back->udp_buff, sec_status_insecure, NULL, 0);
612 		libworker_delete(w);
613 		free(qinfo.qname);
614 		return UB_NOERROR;
615 	}
616 	if(ctx->env->auth_zones && auth_zones_answer(ctx->env->auth_zones,
617 		w->env, &qinfo, &edns, NULL, w->back->udp_buff, w->env->scratch)) {
618 		regional_free_all(w->env->scratch);
619 		libworker_fillup_fg(q, LDNS_RCODE_NOERROR,
620 			w->back->udp_buff, sec_status_insecure, NULL, 0);
621 		libworker_delete(w);
622 		free(qinfo.qname);
623 		return UB_NOERROR;
624 	}
625 	/* process new query */
626 	if(!mesh_new_callback(w->env->mesh, &qinfo, qflags, &edns,
627 		w->back->udp_buff, qid, libworker_fg_done_cb, q)) {
628 		free(qinfo.qname);
629 		return UB_NOMEM;
630 	}
631 	free(qinfo.qname);
632 
633 	/* wait for reply */
634 	comm_base_dispatch(w->base);
635 
636 	libworker_delete(w);
637 	return UB_NOERROR;
638 }
639 
640 void
641 libworker_event_done_cb(void* arg, int rcode, sldns_buffer* buf,
642 	enum sec_status s, char* why_bogus, int was_ratelimited)
643 {
644 	struct ctx_query* q = (struct ctx_query*)arg;
645 	ub_event_callback_type cb = q->cb_event;
646 	void* cb_arg = q->cb_arg;
647 	int cancelled = q->cancelled;
648 
649 	/* delete it now */
650 	struct ub_ctx* ctx = q->w->ctx;
651 	lock_basic_lock(&ctx->cfglock);
652 	(void)rbtree_delete(&ctx->queries, q->node.key);
653 	ctx->num_async--;
654 	context_query_delete(q);
655 	lock_basic_unlock(&ctx->cfglock);
656 
657 	if(!cancelled) {
658 		/* call callback */
659 		int sec = 0;
660 		if(s == sec_status_bogus)
661 			sec = 1;
662 		else if(s == sec_status_secure)
663 			sec = 2;
664 		(*cb)(cb_arg, rcode, (buf?(void*)sldns_buffer_begin(buf):NULL),
665 			(buf?(int)sldns_buffer_limit(buf):0), sec, why_bogus, was_ratelimited);
666 	}
667 }
668 
669 int libworker_attach_mesh(struct ub_ctx* ctx, struct ctx_query* q,
670 	int* async_id)
671 {
672 	struct libworker* w = ctx->event_worker;
673 	uint16_t qflags, qid;
674 	struct query_info qinfo;
675 	struct edns_data edns;
676 	if(!w)
677 		return UB_INITFAIL;
678 	if(!setup_qinfo_edns(w, q, &qinfo, &edns))
679 		return UB_SYNTAX;
680 	qid = 0;
681 	qflags = BIT_RD;
682 	q->w = w;
683 	/* see if there is a fixed answer */
684 	sldns_buffer_write_u16_at(w->back->udp_buff, 0, qid);
685 	sldns_buffer_write_u16_at(w->back->udp_buff, 2, qflags);
686 	if(local_zones_answer(ctx->local_zones, w->env, &qinfo, &edns,
687 		w->back->udp_buff, w->env->scratch, NULL, NULL, 0, NULL, 0,
688 		NULL, 0, NULL, 0, NULL)) {
689 		regional_free_all(w->env->scratch);
690 		free(qinfo.qname);
691 		libworker_event_done_cb(q, LDNS_RCODE_NOERROR,
692 			w->back->udp_buff, sec_status_insecure, NULL, 0);
693 		return UB_NOERROR;
694 	}
695 	if(ctx->env->auth_zones && auth_zones_answer(ctx->env->auth_zones,
696 		w->env, &qinfo, &edns, NULL, w->back->udp_buff, w->env->scratch)) {
697 		regional_free_all(w->env->scratch);
698 		free(qinfo.qname);
699 		libworker_event_done_cb(q, LDNS_RCODE_NOERROR,
700 			w->back->udp_buff, sec_status_insecure, NULL, 0);
701 		return UB_NOERROR;
702 	}
703 	/* process new query */
704 	if(async_id)
705 		*async_id = q->querynum;
706 	if(!mesh_new_callback(w->env->mesh, &qinfo, qflags, &edns,
707 		w->back->udp_buff, qid, libworker_event_done_cb, q)) {
708 		free(qinfo.qname);
709 		return UB_NOMEM;
710 	}
711 	free(qinfo.qname);
712 	return UB_NOERROR;
713 }
714 
715 /** add result to the bg worker result queue */
716 static void
717 add_bg_result(struct libworker* w, struct ctx_query* q, sldns_buffer* pkt,
718 	int err, char* reason, int was_ratelimited)
719 {
720 	uint8_t* msg = NULL;
721 	uint32_t len = 0;
722 
723 	if(w->want_quit) {
724 		context_query_delete(q);
725 		return;
726 	}
727 	/* serialize and delete unneeded q */
728 	if(w->is_bg_thread) {
729 		lock_basic_lock(&w->ctx->cfglock);
730 		if(reason)
731 			q->res->why_bogus = strdup(reason);
732 		q->res->was_ratelimited = was_ratelimited;
733 		if(pkt) {
734 			q->msg_len = sldns_buffer_remaining(pkt);
735 			q->msg = memdup(sldns_buffer_begin(pkt), q->msg_len);
736 			if(!q->msg) {
737 				msg = context_serialize_answer(q, UB_NOMEM, NULL, &len);
738 			} else {
739 				msg = context_serialize_answer(q, err, NULL, &len);
740 			}
741 		} else {
742 			msg = context_serialize_answer(q, err, NULL, &len);
743 		}
744 		lock_basic_unlock(&w->ctx->cfglock);
745 	} else {
746 		if(reason)
747 			q->res->why_bogus = strdup(reason);
748 		q->res->was_ratelimited = was_ratelimited;
749 		msg = context_serialize_answer(q, err, pkt, &len);
750 		(void)rbtree_delete(&w->ctx->queries, q->node.key);
751 		w->ctx->num_async--;
752 		context_query_delete(q);
753 	}
754 
755 	if(!msg) {
756 		log_err("out of memory for async answer");
757 		return;
758 	}
759 	if(!tube_queue_item(w->ctx->rr_pipe, msg, len)) {
760 		log_err("out of memory for async answer");
761 		return;
762 	}
763 }
764 
765 void
766 libworker_bg_done_cb(void* arg, int rcode, sldns_buffer* buf, enum sec_status s,
767 	char* why_bogus, int was_ratelimited)
768 {
769 	struct ctx_query* q = (struct ctx_query*)arg;
770 
771 	if(q->cancelled || q->w->back->want_to_quit) {
772 		if(q->w->is_bg_thread) {
773 			/* delete it now */
774 			struct ub_ctx* ctx = q->w->ctx;
775 			lock_basic_lock(&ctx->cfglock);
776 			(void)rbtree_delete(&ctx->queries, q->node.key);
777 			ctx->num_async--;
778 			context_query_delete(q);
779 			lock_basic_unlock(&ctx->cfglock);
780 		}
781 		/* cancelled, do not give answer */
782 		return;
783 	}
784 	q->msg_security = s;
785 	if(!buf) {
786 		buf = q->w->env->scratch_buffer;
787 	}
788 	if(rcode != 0) {
789 		error_encode(buf, rcode, NULL, 0, BIT_RD, NULL);
790 	}
791 	add_bg_result(q->w, q, buf, UB_NOERROR, why_bogus, was_ratelimited);
792 }
793 
794 
795 /** handle new query command for bg worker */
796 static void
797 handle_newq(struct libworker* w, uint8_t* buf, uint32_t len)
798 {
799 	uint16_t qflags, qid;
800 	struct query_info qinfo;
801 	struct edns_data edns;
802 	struct ctx_query* q;
803 	if(w->is_bg_thread) {
804 		lock_basic_lock(&w->ctx->cfglock);
805 		q = context_lookup_new_query(w->ctx, buf, len);
806 		lock_basic_unlock(&w->ctx->cfglock);
807 	} else {
808 		q = context_deserialize_new_query(w->ctx, buf, len);
809 	}
810 	free(buf);
811 	if(!q) {
812 		log_err("failed to deserialize newq");
813 		return;
814 	}
815 	if(!setup_qinfo_edns(w, q, &qinfo, &edns)) {
816 		add_bg_result(w, q, NULL, UB_SYNTAX, NULL, 0);
817 		return;
818 	}
819 	qid = 0;
820 	qflags = BIT_RD;
821 	/* see if there is a fixed answer */
822 	sldns_buffer_write_u16_at(w->back->udp_buff, 0, qid);
823 	sldns_buffer_write_u16_at(w->back->udp_buff, 2, qflags);
824 	if(local_zones_answer(w->ctx->local_zones, w->env, &qinfo, &edns,
825 		w->back->udp_buff, w->env->scratch, NULL, NULL, 0, NULL, 0,
826 		NULL, 0, NULL, 0, NULL)) {
827 		regional_free_all(w->env->scratch);
828 		q->msg_security = sec_status_insecure;
829 		add_bg_result(w, q, w->back->udp_buff, UB_NOERROR, NULL, 0);
830 		free(qinfo.qname);
831 		return;
832 	}
833 	if(w->ctx->env->auth_zones && auth_zones_answer(w->ctx->env->auth_zones,
834 		w->env, &qinfo, &edns, NULL, w->back->udp_buff, w->env->scratch)) {
835 		regional_free_all(w->env->scratch);
836 		q->msg_security = sec_status_insecure;
837 		add_bg_result(w, q, w->back->udp_buff, UB_NOERROR, NULL, 0);
838 		free(qinfo.qname);
839 		return;
840 	}
841 	q->w = w;
842 	/* process new query */
843 	if(!mesh_new_callback(w->env->mesh, &qinfo, qflags, &edns,
844 		w->back->udp_buff, qid, libworker_bg_done_cb, q)) {
845 		add_bg_result(w, q, NULL, UB_NOMEM, NULL, 0);
846 	}
847 	free(qinfo.qname);
848 }
849 
850 void libworker_alloc_cleanup(void* arg)
851 {
852 	struct libworker* w = (struct libworker*)arg;
853 	slabhash_clear(&w->env->rrset_cache->table);
854         slabhash_clear(w->env->msg_cache);
855 }
856 
857 struct outbound_entry* libworker_send_query(struct query_info* qinfo,
858 	uint16_t flags, int dnssec, int want_dnssec, int nocaps,
859 	struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
860 	size_t zonelen, int ssl_upstream, char* tls_auth_name,
861 	struct module_qstate* q)
862 {
863 	struct libworker* w = (struct libworker*)q->env->worker;
864 	struct outbound_entry* e = (struct outbound_entry*)regional_alloc(
865 		q->region, sizeof(*e));
866 	if(!e)
867 		return NULL;
868 	e->qstate = q;
869 	e->qsent = outnet_serviced_query(w->back, qinfo, flags, dnssec,
870 		want_dnssec, nocaps, q->env->cfg->tcp_upstream, ssl_upstream,
871 		tls_auth_name, addr, addrlen, zone, zonelen, q,
872 		libworker_handle_service_reply, e, w->back->udp_buff, q->env);
873 	if(!e->qsent) {
874 		return NULL;
875 	}
876 	return e;
877 }
878 
879 int
880 libworker_handle_reply(struct comm_point* c, void* arg, int error,
881         struct comm_reply* reply_info)
882 {
883 	struct module_qstate* q = (struct module_qstate*)arg;
884 	struct libworker* lw = (struct libworker*)q->env->worker;
885 	struct outbound_entry e;
886 	e.qstate = q;
887 	e.qsent = NULL;
888 
889 	if(error != 0) {
890 		mesh_report_reply(lw->env->mesh, &e, reply_info, error);
891 		return 0;
892 	}
893 	/* sanity check. */
894 	if(!LDNS_QR_WIRE(sldns_buffer_begin(c->buffer))
895 		|| LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) !=
896 			LDNS_PACKET_QUERY
897 		|| LDNS_QDCOUNT(sldns_buffer_begin(c->buffer)) > 1) {
898 		/* error becomes timeout for the module as if this reply
899 		 * never arrived. */
900 		mesh_report_reply(lw->env->mesh, &e, reply_info,
901 			NETEVENT_TIMEOUT);
902 		return 0;
903 	}
904 	mesh_report_reply(lw->env->mesh, &e, reply_info, NETEVENT_NOERROR);
905 	return 0;
906 }
907 
908 int
909 libworker_handle_service_reply(struct comm_point* c, void* arg, int error,
910         struct comm_reply* reply_info)
911 {
912 	struct outbound_entry* e = (struct outbound_entry*)arg;
913 	struct libworker* lw = (struct libworker*)e->qstate->env->worker;
914 
915 	if(error != 0) {
916 		mesh_report_reply(lw->env->mesh, e, reply_info, error);
917 		return 0;
918 	}
919 	/* sanity check. */
920 	if(!LDNS_QR_WIRE(sldns_buffer_begin(c->buffer))
921 		|| LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) !=
922 			LDNS_PACKET_QUERY
923 		|| LDNS_QDCOUNT(sldns_buffer_begin(c->buffer)) > 1) {
924 		/* error becomes timeout for the module as if this reply
925 		 * never arrived. */
926 		mesh_report_reply(lw->env->mesh, e, reply_info,
927 			NETEVENT_TIMEOUT);
928 		return 0;
929 	}
930 	mesh_report_reply(lw->env->mesh,  e, reply_info, NETEVENT_NOERROR);
931 	return 0;
932 }
933 
934 /* --- fake callbacks for fptr_wlist to work --- */
935 void worker_handle_control_cmd(struct tube* ATTR_UNUSED(tube),
936 	uint8_t* ATTR_UNUSED(buffer), size_t ATTR_UNUSED(len),
937 	int ATTR_UNUSED(error), void* ATTR_UNUSED(arg))
938 {
939 	log_assert(0);
940 }
941 
942 int worker_handle_request(struct comm_point* ATTR_UNUSED(c),
943 	void* ATTR_UNUSED(arg), int ATTR_UNUSED(error),
944         struct comm_reply* ATTR_UNUSED(repinfo))
945 {
946 	log_assert(0);
947 	return 0;
948 }
949 
950 int worker_handle_reply(struct comm_point* ATTR_UNUSED(c),
951 	void* ATTR_UNUSED(arg), int ATTR_UNUSED(error),
952         struct comm_reply* ATTR_UNUSED(reply_info))
953 {
954 	log_assert(0);
955 	return 0;
956 }
957 
958 int worker_handle_service_reply(struct comm_point* ATTR_UNUSED(c),
959 	void* ATTR_UNUSED(arg), int ATTR_UNUSED(error),
960         struct comm_reply* ATTR_UNUSED(reply_info))
961 {
962 	log_assert(0);
963 	return 0;
964 }
965 
966 int remote_accept_callback(struct comm_point* ATTR_UNUSED(c),
967 	void* ATTR_UNUSED(arg), int ATTR_UNUSED(error),
968         struct comm_reply* ATTR_UNUSED(repinfo))
969 {
970 	log_assert(0);
971 	return 0;
972 }
973 
974 int remote_control_callback(struct comm_point* ATTR_UNUSED(c),
975 	void* ATTR_UNUSED(arg), int ATTR_UNUSED(error),
976         struct comm_reply* ATTR_UNUSED(repinfo))
977 {
978 	log_assert(0);
979 	return 0;
980 }
981 
982 void worker_sighandler(int ATTR_UNUSED(sig), void* ATTR_UNUSED(arg))
983 {
984 	log_assert(0);
985 }
986 
987 struct outbound_entry* worker_send_query(struct query_info* ATTR_UNUSED(qinfo),
988 	uint16_t ATTR_UNUSED(flags), int ATTR_UNUSED(dnssec),
989 	int ATTR_UNUSED(want_dnssec), int ATTR_UNUSED(nocaps),
990 	struct sockaddr_storage* ATTR_UNUSED(addr), socklen_t ATTR_UNUSED(addrlen),
991 	uint8_t* ATTR_UNUSED(zone), size_t ATTR_UNUSED(zonelen),
992 	int ATTR_UNUSED(ssl_upstream), char* ATTR_UNUSED(tls_auth_name),
993 	struct module_qstate* ATTR_UNUSED(q))
994 {
995 	log_assert(0);
996 	return 0;
997 }
998 
999 void
1000 worker_alloc_cleanup(void* ATTR_UNUSED(arg))
1001 {
1002 	log_assert(0);
1003 }
1004 
1005 void worker_stat_timer_cb(void* ATTR_UNUSED(arg))
1006 {
1007 	log_assert(0);
1008 }
1009 
1010 void worker_probe_timer_cb(void* ATTR_UNUSED(arg))
1011 {
1012 	log_assert(0);
1013 }
1014 
1015 void worker_start_accept(void* ATTR_UNUSED(arg))
1016 {
1017 	log_assert(0);
1018 }
1019 
1020 void worker_stop_accept(void* ATTR_UNUSED(arg))
1021 {
1022 	log_assert(0);
1023 }
1024 
1025 int order_lock_cmp(const void* ATTR_UNUSED(e1), const void* ATTR_UNUSED(e2))
1026 {
1027 	log_assert(0);
1028 	return 0;
1029 }
1030 
1031 int
1032 codeline_cmp(const void* ATTR_UNUSED(a), const void* ATTR_UNUSED(b))
1033 {
1034 	log_assert(0);
1035 	return 0;
1036 }
1037 
1038 int replay_var_compare(const void* ATTR_UNUSED(a), const void* ATTR_UNUSED(b))
1039 {
1040         log_assert(0);
1041         return 0;
1042 }
1043 
1044 void remote_get_opt_ssl(char* ATTR_UNUSED(str), void* ATTR_UNUSED(arg))
1045 {
1046         log_assert(0);
1047 }
1048 
1049 #ifdef UB_ON_WINDOWS
1050 void
1051 worker_win_stop_cb(int ATTR_UNUSED(fd), short ATTR_UNUSED(ev), void*
1052         ATTR_UNUSED(arg)) {
1053         log_assert(0);
1054 }
1055 
1056 void
1057 wsvc_cron_cb(void* ATTR_UNUSED(arg))
1058 {
1059         log_assert(0);
1060 }
1061 #endif /* UB_ON_WINDOWS */
1062 
1063 #ifdef USE_DNSTAP
1064 void dtio_tap_callback(int ATTR_UNUSED(fd), short ATTR_UNUSED(ev),
1065 	void* ATTR_UNUSED(arg))
1066 {
1067 	log_assert(0);
1068 }
1069 #endif
1070 
1071 #ifdef USE_DNSTAP
1072 void dtio_mainfdcallback(int ATTR_UNUSED(fd), short ATTR_UNUSED(ev),
1073 	void* ATTR_UNUSED(arg))
1074 {
1075 	log_assert(0);
1076 }
1077 #endif
1078