1 /* 2 * daemon/daemon.c - collection of workers that handles requests. 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 * The daemon consists of global settings and a number of workers. 40 */ 41 42 #include "config.h" 43 #ifdef HAVE_OPENSSL_ERR_H 44 #include <openssl/err.h> 45 #endif 46 47 #ifdef HAVE_OPENSSL_RAND_H 48 #include <openssl/rand.h> 49 #endif 50 51 #ifdef HAVE_OPENSSL_CONF_H 52 #include <openssl/conf.h> 53 #endif 54 55 #ifdef HAVE_OPENSSL_ENGINE_H 56 #include <openssl/engine.h> 57 #endif 58 59 #ifdef HAVE_TIME_H 60 #include <time.h> 61 #endif 62 #include <sys/time.h> 63 64 #ifdef HAVE_NSS 65 /* nss3 */ 66 #include "nss.h" 67 #endif 68 69 #include "daemon/daemon.h" 70 #include "daemon/worker.h" 71 #include "daemon/remote.h" 72 #include "daemon/acl_list.h" 73 #include "util/log.h" 74 #include "util/config_file.h" 75 #include "util/data/msgreply.h" 76 #include "util/shm_side/shm_main.h" 77 #include "util/storage/lookup3.h" 78 #include "util/storage/slabhash.h" 79 #include "util/tcp_conn_limit.h" 80 #include "services/listen_dnsport.h" 81 #include "services/cache/rrset.h" 82 #include "services/cache/infra.h" 83 #include "services/localzone.h" 84 #include "services/view.h" 85 #include "services/modstack.h" 86 #include "services/authzone.h" 87 #include "util/module.h" 88 #include "util/random.h" 89 #include "util/tube.h" 90 #include "util/net_help.h" 91 #include "sldns/keyraw.h" 92 #include "respip/respip.h" 93 #include <signal.h> 94 95 #ifdef HAVE_SYSTEMD 96 #include <systemd/sd-daemon.h> 97 #endif 98 99 /** How many quit requests happened. */ 100 static int sig_record_quit = 0; 101 /** How many reload requests happened. */ 102 static int sig_record_reload = 0; 103 104 #if HAVE_DECL_SSL_COMP_GET_COMPRESSION_METHODS 105 /** cleaner ssl memory freeup */ 106 static void* comp_meth = NULL; 107 #endif 108 /** remove buffers for parsing and init */ 109 int ub_c_lex_destroy(void); 110 111 /** used when no other sighandling happens, so we don't die 112 * when multiple signals in quick succession are sent to us. 113 * @param sig: signal number. 114 * @return signal handler return type (void or int). 115 */ 116 static RETSIGTYPE record_sigh(int sig) 117 { 118 #ifdef LIBEVENT_SIGNAL_PROBLEM 119 /* cannot log, verbose here because locks may be held */ 120 /* quit on signal, no cleanup and statistics, 121 because installed libevent version is not threadsafe */ 122 exit(0); 123 #endif 124 switch(sig) 125 { 126 case SIGTERM: 127 #ifdef SIGQUIT 128 case SIGQUIT: 129 #endif 130 #ifdef SIGBREAK 131 case SIGBREAK: 132 #endif 133 case SIGINT: 134 sig_record_quit++; 135 break; 136 #ifdef SIGHUP 137 case SIGHUP: 138 sig_record_reload++; 139 break; 140 #endif 141 #ifdef SIGPIPE 142 case SIGPIPE: 143 break; 144 #endif 145 default: 146 /* ignoring signal */ 147 break; 148 } 149 } 150 151 /** 152 * Signal handling during the time when netevent is disabled. 153 * Stores signals to replay later. 154 */ 155 static void 156 signal_handling_record(void) 157 { 158 if( signal(SIGTERM, record_sigh) == SIG_ERR || 159 #ifdef SIGQUIT 160 signal(SIGQUIT, record_sigh) == SIG_ERR || 161 #endif 162 #ifdef SIGBREAK 163 signal(SIGBREAK, record_sigh) == SIG_ERR || 164 #endif 165 #ifdef SIGHUP 166 signal(SIGHUP, record_sigh) == SIG_ERR || 167 #endif 168 #ifdef SIGPIPE 169 signal(SIGPIPE, SIG_IGN) == SIG_ERR || 170 #endif 171 signal(SIGINT, record_sigh) == SIG_ERR 172 ) 173 log_err("install sighandler: %s", strerror(errno)); 174 } 175 176 /** 177 * Replay old signals. 178 * @param wrk: worker that handles signals. 179 */ 180 static void 181 signal_handling_playback(struct worker* wrk) 182 { 183 #ifdef SIGHUP 184 if(sig_record_reload) 185 worker_sighandler(SIGHUP, wrk); 186 #endif 187 if(sig_record_quit) 188 worker_sighandler(SIGTERM, wrk); 189 sig_record_quit = 0; 190 sig_record_reload = 0; 191 } 192 193 struct daemon* 194 daemon_init(void) 195 { 196 struct daemon* daemon = (struct daemon*)calloc(1, 197 sizeof(struct daemon)); 198 #ifdef USE_WINSOCK 199 int r; 200 WSADATA wsa_data; 201 #endif 202 if(!daemon) 203 return NULL; 204 #ifdef USE_WINSOCK 205 r = WSAStartup(MAKEWORD(2,2), &wsa_data); 206 if(r != 0) { 207 fatal_exit("could not init winsock. WSAStartup: %s", 208 wsa_strerror(r)); 209 } 210 #endif /* USE_WINSOCK */ 211 signal_handling_record(); 212 checklock_start(); 213 #ifdef HAVE_SSL 214 # ifdef HAVE_ERR_LOAD_CRYPTO_STRINGS 215 ERR_load_crypto_strings(); 216 # endif 217 #if OPENSSL_VERSION_NUMBER < 0x10100000 || !defined(HAVE_OPENSSL_INIT_SSL) 218 ERR_load_SSL_strings(); 219 #endif 220 # ifdef USE_GOST 221 (void)sldns_key_EVP_load_gost_id(); 222 # endif 223 # if OPENSSL_VERSION_NUMBER < 0x10100000 || !defined(HAVE_OPENSSL_INIT_CRYPTO) 224 OpenSSL_add_all_algorithms(); 225 # else 226 OPENSSL_init_crypto(OPENSSL_INIT_ADD_ALL_CIPHERS 227 | OPENSSL_INIT_ADD_ALL_DIGESTS 228 | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, NULL); 229 # endif 230 # if HAVE_DECL_SSL_COMP_GET_COMPRESSION_METHODS 231 /* grab the COMP method ptr because openssl leaks it */ 232 comp_meth = (void*)SSL_COMP_get_compression_methods(); 233 # endif 234 # if OPENSSL_VERSION_NUMBER < 0x10100000 || !defined(HAVE_OPENSSL_INIT_SSL) 235 (void)SSL_library_init(); 236 # else 237 (void)OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL); 238 # endif 239 # if defined(HAVE_SSL) && defined(OPENSSL_THREADS) && !defined(THREADS_DISABLED) 240 if(!ub_openssl_lock_init()) 241 fatal_exit("could not init openssl locks"); 242 # endif 243 #elif defined(HAVE_NSS) 244 if(NSS_NoDB_Init(NULL) != SECSuccess) 245 fatal_exit("could not init NSS"); 246 #endif /* HAVE_SSL or HAVE_NSS */ 247 #ifdef HAVE_TZSET 248 /* init timezone info while we are not chrooted yet */ 249 tzset(); 250 #endif 251 /* open /dev/random if needed */ 252 ub_systemseed((unsigned)time(NULL)^(unsigned)getpid()^0xe67); 253 daemon->need_to_exit = 0; 254 modstack_init(&daemon->mods); 255 if(!(daemon->env = (struct module_env*)calloc(1, 256 sizeof(*daemon->env)))) { 257 free(daemon); 258 return NULL; 259 } 260 /* init edns_known_options */ 261 if(!edns_known_options_init(daemon->env)) { 262 free(daemon->env); 263 free(daemon); 264 return NULL; 265 } 266 alloc_init(&daemon->superalloc, NULL, 0); 267 daemon->acl = acl_list_create(); 268 if(!daemon->acl) { 269 edns_known_options_delete(daemon->env); 270 free(daemon->env); 271 free(daemon); 272 return NULL; 273 } 274 daemon->tcl = tcl_list_create(); 275 if(!daemon->tcl) { 276 acl_list_delete(daemon->acl); 277 edns_known_options_delete(daemon->env); 278 free(daemon->env); 279 free(daemon); 280 return NULL; 281 } 282 if(gettimeofday(&daemon->time_boot, NULL) < 0) 283 log_err("gettimeofday: %s", strerror(errno)); 284 daemon->time_last_stat = daemon->time_boot; 285 if((daemon->env->auth_zones = auth_zones_create()) == 0) { 286 acl_list_delete(daemon->acl); 287 tcl_list_delete(daemon->tcl); 288 edns_known_options_delete(daemon->env); 289 free(daemon->env); 290 free(daemon); 291 return NULL; 292 } 293 return daemon; 294 } 295 296 int 297 daemon_open_shared_ports(struct daemon* daemon) 298 { 299 log_assert(daemon); 300 if(daemon->cfg->port != daemon->listening_port) { 301 size_t i; 302 struct listen_port* p0; 303 daemon->reuseport = 0; 304 /* free and close old ports */ 305 if(daemon->ports != NULL) { 306 for(i=0; i<daemon->num_ports; i++) 307 listening_ports_free(daemon->ports[i]); 308 free(daemon->ports); 309 daemon->ports = NULL; 310 } 311 /* see if we want to reuseport */ 312 #ifdef SO_REUSEPORT 313 if(daemon->cfg->so_reuseport && daemon->cfg->num_threads > 0) 314 daemon->reuseport = 1; 315 #endif 316 /* try to use reuseport */ 317 p0 = listening_ports_open(daemon->cfg, &daemon->reuseport); 318 if(!p0) { 319 listening_ports_free(p0); 320 return 0; 321 } 322 if(daemon->reuseport) { 323 /* reuseport was successful, allocate for it */ 324 daemon->num_ports = (size_t)daemon->cfg->num_threads; 325 } else { 326 /* do the normal, singleportslist thing, 327 * reuseport not enabled or did not work */ 328 daemon->num_ports = 1; 329 } 330 if(!(daemon->ports = (struct listen_port**)calloc( 331 daemon->num_ports, sizeof(*daemon->ports)))) { 332 listening_ports_free(p0); 333 return 0; 334 } 335 daemon->ports[0] = p0; 336 if(daemon->reuseport) { 337 /* continue to use reuseport */ 338 for(i=1; i<daemon->num_ports; i++) { 339 if(!(daemon->ports[i]= 340 listening_ports_open(daemon->cfg, 341 &daemon->reuseport)) 342 || !daemon->reuseport ) { 343 for(i=0; i<daemon->num_ports; i++) 344 listening_ports_free(daemon->ports[i]); 345 free(daemon->ports); 346 daemon->ports = NULL; 347 return 0; 348 } 349 } 350 } 351 daemon->listening_port = daemon->cfg->port; 352 } 353 if(!daemon->cfg->remote_control_enable && daemon->rc_port) { 354 listening_ports_free(daemon->rc_ports); 355 daemon->rc_ports = NULL; 356 daemon->rc_port = 0; 357 } 358 if(daemon->cfg->remote_control_enable && 359 daemon->cfg->control_port != daemon->rc_port) { 360 listening_ports_free(daemon->rc_ports); 361 if(!(daemon->rc_ports=daemon_remote_open_ports(daemon->cfg))) 362 return 0; 363 daemon->rc_port = daemon->cfg->control_port; 364 } 365 return 1; 366 } 367 368 /** 369 * Setup modules. setup module stack. 370 * @param daemon: the daemon 371 */ 372 static void daemon_setup_modules(struct daemon* daemon) 373 { 374 daemon->env->cfg = daemon->cfg; 375 daemon->env->alloc = &daemon->superalloc; 376 daemon->env->worker = NULL; 377 daemon->env->need_to_validate = 0; /* set by module init below */ 378 if(!modstack_setup(&daemon->mods, daemon->cfg->module_conf, 379 daemon->env)) { 380 fatal_exit("failed to setup modules"); 381 } 382 log_edns_known_options(VERB_ALGO, daemon->env); 383 } 384 385 /** 386 * Obtain allowed port numbers, concatenate the list, and shuffle them 387 * (ready to be handed out to threads). 388 * @param daemon: the daemon. Uses rand and cfg. 389 * @param shufport: the portlist output. 390 * @return number of ports available. 391 */ 392 static int daemon_get_shufport(struct daemon* daemon, int* shufport) 393 { 394 int i, n, k, temp; 395 int avail = 0; 396 for(i=0; i<65536; i++) { 397 if(daemon->cfg->outgoing_avail_ports[i]) { 398 shufport[avail++] = daemon->cfg-> 399 outgoing_avail_ports[i]; 400 } 401 } 402 if(avail == 0) 403 fatal_exit("no ports are permitted for UDP, add " 404 "with outgoing-port-permit"); 405 /* Knuth shuffle */ 406 n = avail; 407 while(--n > 0) { 408 k = ub_random_max(daemon->rand, n+1); /* 0<= k<= n */ 409 temp = shufport[k]; 410 shufport[k] = shufport[n]; 411 shufport[n] = temp; 412 } 413 return avail; 414 } 415 416 /** 417 * Allocate empty worker structures. With backptr and thread-number, 418 * from 0..numthread initialised. Used as user arguments to new threads. 419 * Creates the daemon random generator if it does not exist yet. 420 * The random generator stays existing between reloads with a unique state. 421 * @param daemon: the daemon with (new) config settings. 422 */ 423 static void 424 daemon_create_workers(struct daemon* daemon) 425 { 426 int i, numport; 427 int* shufport; 428 log_assert(daemon && daemon->cfg); 429 if(!daemon->rand) { 430 unsigned int seed = (unsigned int)time(NULL) ^ 431 (unsigned int)getpid() ^ 0x438; 432 daemon->rand = ub_initstate(seed, NULL); 433 if(!daemon->rand) 434 fatal_exit("could not init random generator"); 435 hash_set_raninit((uint32_t)ub_random(daemon->rand)); 436 } 437 shufport = (int*)calloc(65536, sizeof(int)); 438 if(!shufport) 439 fatal_exit("out of memory during daemon init"); 440 numport = daemon_get_shufport(daemon, shufport); 441 verbose(VERB_ALGO, "total of %d outgoing ports available", numport); 442 443 daemon->num = (daemon->cfg->num_threads?daemon->cfg->num_threads:1); 444 if(daemon->reuseport && (int)daemon->num < (int)daemon->num_ports) { 445 log_warn("cannot reduce num-threads to %d because so-reuseport " 446 "so continuing with %d threads.", (int)daemon->num, 447 (int)daemon->num_ports); 448 daemon->num = (int)daemon->num_ports; 449 } 450 daemon->workers = (struct worker**)calloc((size_t)daemon->num, 451 sizeof(struct worker*)); 452 if(!daemon->workers) 453 fatal_exit("out of memory during daemon init"); 454 if(daemon->cfg->dnstap) { 455 #ifdef USE_DNSTAP 456 daemon->dtenv = dt_create(daemon->cfg->dnstap_socket_path, 457 (unsigned int)daemon->num); 458 if (!daemon->dtenv) 459 fatal_exit("dt_create failed"); 460 dt_apply_cfg(daemon->dtenv, daemon->cfg); 461 #else 462 fatal_exit("dnstap enabled in config but not built with dnstap support"); 463 #endif 464 } 465 for(i=0; i<daemon->num; i++) { 466 if(!(daemon->workers[i] = worker_create(daemon, i, 467 shufport+numport*i/daemon->num, 468 numport*(i+1)/daemon->num - numport*i/daemon->num))) 469 /* the above is not ports/numthr, due to rounding */ 470 fatal_exit("could not create worker"); 471 } 472 free(shufport); 473 } 474 475 #ifdef THREADS_DISABLED 476 /** 477 * Close all pipes except for the numbered thread. 478 * @param daemon: daemon to close pipes in. 479 * @param thr: thread number 0..num-1 of thread to skip. 480 */ 481 static void close_other_pipes(struct daemon* daemon, int thr) 482 { 483 int i; 484 for(i=0; i<daemon->num; i++) 485 if(i!=thr) { 486 if(i==0) { 487 /* only close read part, need to write stats */ 488 tube_close_read(daemon->workers[i]->cmd); 489 } else { 490 /* complete close channel to others */ 491 tube_delete(daemon->workers[i]->cmd); 492 daemon->workers[i]->cmd = NULL; 493 } 494 } 495 } 496 #endif /* THREADS_DISABLED */ 497 498 /** 499 * Function to start one thread. 500 * @param arg: user argument. 501 * @return: void* user return value could be used for thread_join results. 502 */ 503 static void* 504 thread_start(void* arg) 505 { 506 struct worker* worker = (struct worker*)arg; 507 int port_num = 0; 508 log_thread_set(&worker->thread_num); 509 ub_thread_blocksigs(); 510 #ifdef THREADS_DISABLED 511 /* close pipe ends used by main */ 512 tube_close_write(worker->cmd); 513 close_other_pipes(worker->daemon, worker->thread_num); 514 #endif 515 #ifdef SO_REUSEPORT 516 if(worker->daemon->cfg->so_reuseport) 517 port_num = worker->thread_num % worker->daemon->num_ports; 518 else 519 port_num = 0; 520 #endif 521 if(!worker_init(worker, worker->daemon->cfg, 522 worker->daemon->ports[port_num], 0)) 523 fatal_exit("Could not initialize thread"); 524 525 worker_work(worker); 526 return NULL; 527 } 528 529 /** 530 * Fork and init the other threads. Main thread returns for special handling. 531 * @param daemon: the daemon with other threads to fork. 532 */ 533 static void 534 daemon_start_others(struct daemon* daemon) 535 { 536 int i; 537 log_assert(daemon); 538 verbose(VERB_ALGO, "start threads"); 539 /* skip i=0, is this thread */ 540 for(i=1; i<daemon->num; i++) { 541 ub_thread_create(&daemon->workers[i]->thr_id, 542 thread_start, daemon->workers[i]); 543 #ifdef THREADS_DISABLED 544 /* close pipe end of child */ 545 tube_close_read(daemon->workers[i]->cmd); 546 #endif /* no threads */ 547 } 548 } 549 550 /** 551 * Stop the other threads. 552 * @param daemon: the daemon with other threads. 553 */ 554 static void 555 daemon_stop_others(struct daemon* daemon) 556 { 557 int i; 558 log_assert(daemon); 559 verbose(VERB_ALGO, "stop threads"); 560 /* skip i=0, is this thread */ 561 /* use i=0 buffer for sending cmds; because we are #0 */ 562 for(i=1; i<daemon->num; i++) { 563 worker_send_cmd(daemon->workers[i], worker_cmd_quit); 564 } 565 /* wait for them to quit */ 566 for(i=1; i<daemon->num; i++) { 567 /* join it to make sure its dead */ 568 verbose(VERB_ALGO, "join %d", i); 569 ub_thread_join(daemon->workers[i]->thr_id); 570 verbose(VERB_ALGO, "join success %d", i); 571 } 572 } 573 574 void 575 daemon_fork(struct daemon* daemon) 576 { 577 int have_view_respip_cfg = 0; 578 579 log_assert(daemon); 580 if(!(daemon->views = views_create())) 581 fatal_exit("Could not create views: out of memory"); 582 /* create individual views and their localzone/data trees */ 583 if(!views_apply_cfg(daemon->views, daemon->cfg)) 584 fatal_exit("Could not set up views"); 585 586 if(!acl_list_apply_cfg(daemon->acl, daemon->cfg, daemon->views)) 587 fatal_exit("Could not setup access control list"); 588 if(!tcl_list_apply_cfg(daemon->tcl, daemon->cfg)) 589 fatal_exit("Could not setup TCP connection limits"); 590 if(daemon->cfg->dnscrypt) { 591 #ifdef USE_DNSCRYPT 592 daemon->dnscenv = dnsc_create(); 593 if (!daemon->dnscenv) 594 fatal_exit("dnsc_create failed"); 595 dnsc_apply_cfg(daemon->dnscenv, daemon->cfg); 596 #else 597 fatal_exit("dnscrypt enabled in config but unbound was not built with " 598 "dnscrypt support"); 599 #endif 600 } 601 /* create global local_zones */ 602 if(!(daemon->local_zones = local_zones_create())) 603 fatal_exit("Could not create local zones: out of memory"); 604 if(!local_zones_apply_cfg(daemon->local_zones, daemon->cfg)) 605 fatal_exit("Could not set up local zones"); 606 607 /* process raw response-ip configuration data */ 608 if(!(daemon->respip_set = respip_set_create())) 609 fatal_exit("Could not create response IP set"); 610 if(!respip_global_apply_cfg(daemon->respip_set, daemon->cfg)) 611 fatal_exit("Could not set up response IP set"); 612 if(!respip_views_apply_cfg(daemon->views, daemon->cfg, 613 &have_view_respip_cfg)) 614 fatal_exit("Could not set up per-view response IP sets"); 615 daemon->use_response_ip = !respip_set_is_empty(daemon->respip_set) || 616 have_view_respip_cfg; 617 618 /* read auth zonefiles */ 619 if(!auth_zones_apply_cfg(daemon->env->auth_zones, daemon->cfg, 1)) 620 fatal_exit("auth_zones could not be setup"); 621 622 /* setup modules */ 623 daemon_setup_modules(daemon); 624 625 /* response-ip-xxx options don't work as expected without the respip 626 * module. To avoid run-time operational surprise we reject such 627 * configuration. */ 628 if(daemon->use_response_ip && 629 modstack_find(&daemon->mods, "respip") < 0) 630 fatal_exit("response-ip options require respip module"); 631 632 /* first create all the worker structures, so we can pass 633 * them to the newly created threads. 634 */ 635 daemon_create_workers(daemon); 636 637 #if defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP) 638 /* in libev the first inited base gets signals */ 639 if(!worker_init(daemon->workers[0], daemon->cfg, daemon->ports[0], 1)) 640 fatal_exit("Could not initialize main thread"); 641 #endif 642 643 /* Now create the threads and init the workers. 644 * By the way, this is thread #0 (the main thread). 645 */ 646 daemon_start_others(daemon); 647 648 /* Special handling for the main thread. This is the thread 649 * that handles signals and remote control. 650 */ 651 #if !(defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP)) 652 /* libevent has the last inited base get signals (or any base) */ 653 if(!worker_init(daemon->workers[0], daemon->cfg, daemon->ports[0], 1)) 654 fatal_exit("Could not initialize main thread"); 655 #endif 656 signal_handling_playback(daemon->workers[0]); 657 658 if (!shm_main_init(daemon)) 659 log_warn("SHM has failed"); 660 661 /* Start resolver service on main thread. */ 662 #ifdef HAVE_SYSTEMD 663 sd_notify(0, "READY=1"); 664 #endif 665 log_info("start of service (%s).", PACKAGE_STRING); 666 worker_work(daemon->workers[0]); 667 #ifdef HAVE_SYSTEMD 668 if (daemon->workers[0]->need_to_exit) 669 sd_notify(0, "STOPPING=1"); 670 else 671 sd_notify(0, "RELOADING=1"); 672 #endif 673 log_info("service stopped (%s).", PACKAGE_STRING); 674 675 /* we exited! a signal happened! Stop other threads */ 676 daemon_stop_others(daemon); 677 678 /* Shutdown SHM */ 679 shm_main_shutdown(daemon); 680 681 daemon->need_to_exit = daemon->workers[0]->need_to_exit; 682 } 683 684 void 685 daemon_cleanup(struct daemon* daemon) 686 { 687 int i; 688 log_assert(daemon); 689 /* before stopping main worker, handle signals ourselves, so we 690 don't die on multiple reload signals for example. */ 691 signal_handling_record(); 692 log_thread_set(NULL); 693 /* clean up caches because 694 * a) RRset IDs will be recycled after a reload, causing collisions 695 * b) validation config can change, thus rrset, msg, keycache clear */ 696 slabhash_clear(&daemon->env->rrset_cache->table); 697 slabhash_clear(daemon->env->msg_cache); 698 local_zones_delete(daemon->local_zones); 699 daemon->local_zones = NULL; 700 respip_set_delete(daemon->respip_set); 701 daemon->respip_set = NULL; 702 views_delete(daemon->views); 703 daemon->views = NULL; 704 if(daemon->env->auth_zones) 705 auth_zones_cleanup(daemon->env->auth_zones); 706 /* key cache is cleared by module desetup during next daemon_fork() */ 707 daemon_remote_clear(daemon->rc); 708 for(i=0; i<daemon->num; i++) 709 worker_delete(daemon->workers[i]); 710 free(daemon->workers); 711 daemon->workers = NULL; 712 daemon->num = 0; 713 alloc_clear_special(&daemon->superalloc); 714 #ifdef USE_DNSTAP 715 dt_delete(daemon->dtenv); 716 daemon->dtenv = NULL; 717 #endif 718 #ifdef USE_DNSCRYPT 719 dnsc_delete(daemon->dnscenv); 720 daemon->dnscenv = NULL; 721 #endif 722 daemon->cfg = NULL; 723 } 724 725 void 726 daemon_delete(struct daemon* daemon) 727 { 728 size_t i; 729 if(!daemon) 730 return; 731 modstack_desetup(&daemon->mods, daemon->env); 732 daemon_remote_delete(daemon->rc); 733 for(i = 0; i < daemon->num_ports; i++) 734 listening_ports_free(daemon->ports[i]); 735 free(daemon->ports); 736 listening_ports_free(daemon->rc_ports); 737 if(daemon->env) { 738 slabhash_delete(daemon->env->msg_cache); 739 rrset_cache_delete(daemon->env->rrset_cache); 740 infra_delete(daemon->env->infra_cache); 741 edns_known_options_delete(daemon->env); 742 auth_zones_delete(daemon->env->auth_zones); 743 } 744 ub_randfree(daemon->rand); 745 alloc_clear(&daemon->superalloc); 746 acl_list_delete(daemon->acl); 747 tcl_list_delete(daemon->tcl); 748 free(daemon->chroot); 749 free(daemon->pidfile); 750 free(daemon->env); 751 #ifdef HAVE_SSL 752 SSL_CTX_free((SSL_CTX*)daemon->listen_sslctx); 753 SSL_CTX_free((SSL_CTX*)daemon->connect_sslctx); 754 #endif 755 free(daemon); 756 /* lex cleanup */ 757 ub_c_lex_destroy(); 758 /* libcrypto cleanup */ 759 #ifdef HAVE_SSL 760 # if defined(USE_GOST) && defined(HAVE_LDNS_KEY_EVP_UNLOAD_GOST) 761 sldns_key_EVP_unload_gost(); 762 # endif 763 # if HAVE_DECL_SSL_COMP_GET_COMPRESSION_METHODS && HAVE_DECL_SK_SSL_COMP_POP_FREE 764 # ifndef S_SPLINT_S 765 # if OPENSSL_VERSION_NUMBER < 0x10100000 766 sk_SSL_COMP_pop_free(comp_meth, (void(*)())CRYPTO_free); 767 # endif 768 # endif 769 # endif 770 # ifdef HAVE_OPENSSL_CONFIG 771 EVP_cleanup(); 772 # if OPENSSL_VERSION_NUMBER < 0x10100000 773 ENGINE_cleanup(); 774 # endif 775 CONF_modules_free(); 776 # endif 777 # ifdef HAVE_CRYPTO_CLEANUP_ALL_EX_DATA 778 CRYPTO_cleanup_all_ex_data(); /* safe, no more threads right now */ 779 # endif 780 # ifdef HAVE_ERR_FREE_STRINGS 781 ERR_free_strings(); 782 # endif 783 # if OPENSSL_VERSION_NUMBER < 0x10100000 784 RAND_cleanup(); 785 # endif 786 # if defined(HAVE_SSL) && defined(OPENSSL_THREADS) && !defined(THREADS_DISABLED) 787 ub_openssl_lock_delete(); 788 # endif 789 #ifndef HAVE_ARC4RANDOM 790 _ARC4_LOCK_DESTROY(); 791 #endif 792 #elif defined(HAVE_NSS) 793 NSS_Shutdown(); 794 #endif /* HAVE_SSL or HAVE_NSS */ 795 checklock_stop(); 796 #ifdef USE_WINSOCK 797 if(WSACleanup() != 0) { 798 log_err("Could not WSACleanup: %s", 799 wsa_strerror(WSAGetLastError())); 800 } 801 #endif 802 } 803 804 void daemon_apply_cfg(struct daemon* daemon, struct config_file* cfg) 805 { 806 daemon->cfg = cfg; 807 config_apply(cfg); 808 if(!slabhash_is_size(daemon->env->msg_cache, cfg->msg_cache_size, 809 cfg->msg_cache_slabs)) { 810 slabhash_delete(daemon->env->msg_cache); 811 daemon->env->msg_cache = slabhash_create(cfg->msg_cache_slabs, 812 HASH_DEFAULT_STARTARRAY, cfg->msg_cache_size, 813 msgreply_sizefunc, query_info_compare, 814 query_entry_delete, reply_info_delete, NULL); 815 if(!daemon->env->msg_cache) { 816 fatal_exit("malloc failure updating config settings"); 817 } 818 } 819 if((daemon->env->rrset_cache = rrset_cache_adjust( 820 daemon->env->rrset_cache, cfg, &daemon->superalloc)) == 0) 821 fatal_exit("malloc failure updating config settings"); 822 if((daemon->env->infra_cache = infra_adjust(daemon->env->infra_cache, 823 cfg))==0) 824 fatal_exit("malloc failure updating config settings"); 825 } 826