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