1/* 2 * unbound.c - unbound validating resolver public API implementation 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 functions to resolve DNS queries and 40 * validate the answers. Synchronously and asynchronously. 41 * 42 */ 43 44/* include the public api first, it should be able to stand alone */ 45#include "libunbound/unbound.h" 46#include "libunbound/unbound-event.h" 47#include "config.h" 48#include <ctype.h> 49#include "libunbound/context.h" 50#include "libunbound/libworker.h" 51#include "util/locks.h" 52#include "util/config_file.h" 53#include "util/alloc.h" 54#include "util/module.h" 55#include "util/regional.h" 56#include "util/log.h" 57#include "util/random.h" 58#include "util/net_help.h" 59#include "util/tube.h" 60#include "util/ub_event.h" 61#include "util/edns.h" 62#include "services/modstack.h" 63#include "services/localzone.h" 64#include "services/cache/infra.h" 65#include "services/cache/rrset.h" 66#include "services/authzone.h" 67#include "sldns/sbuffer.h" 68#ifdef HAVE_PTHREAD 69#include <signal.h> 70#endif 71#ifdef HAVE_SYS_WAIT_H 72#include <sys/wait.h> 73#endif 74#ifdef HAVE_TIME_H 75#include <time.h> 76#endif 77 78#if defined(UB_ON_WINDOWS) && defined (HAVE_WINDOWS_H) 79#include <windows.h> 80#include <iphlpapi.h> 81#endif /* UB_ON_WINDOWS */ 82 83/** store that the logfile has a debug override */ 84int ctx_logfile_overridden = 0; 85 86/** create context functionality, but no pipes */ 87static struct ub_ctx* ub_ctx_create_nopipe(void) 88{ 89 struct ub_ctx* ctx; 90#ifdef USE_WINSOCK 91 int r; 92 WSADATA wsa_data; 93#endif 94 95 checklock_start(); 96 if(!ctx_logfile_overridden) 97 log_init(NULL, 0, NULL); /* logs to stderr */ 98 log_ident_set("libunbound"); 99#ifdef USE_WINSOCK 100 if((r = WSAStartup(MAKEWORD(2,2), &wsa_data)) != 0) { 101 log_err("could not init winsock. WSAStartup: %s", 102 wsa_strerror(r)); 103 return NULL; 104 } 105#endif 106 verbosity = NO_VERBOSE; /* errors only */ 107 checklock_start(); 108 ctx = (struct ub_ctx*)calloc(1, sizeof(*ctx)); 109 if(!ctx) { 110 errno = ENOMEM; 111 return NULL; 112 } 113 alloc_init(&ctx->superalloc, NULL, 0); 114 if(!(ctx->seed_rnd = ub_initstate(NULL))) { 115 ub_randfree(ctx->seed_rnd); 116 free(ctx); 117 errno = ENOMEM; 118 return NULL; 119 } 120 lock_basic_init(&ctx->qqpipe_lock); 121 lock_basic_init(&ctx->rrpipe_lock); 122 lock_basic_init(&ctx->cfglock); 123 ctx->env = (struct module_env*)calloc(1, sizeof(*ctx->env)); 124 if(!ctx->env) { 125 ub_randfree(ctx->seed_rnd); 126 free(ctx); 127 errno = ENOMEM; 128 return NULL; 129 } 130 ctx->env->cfg = config_create_forlib(); 131 if(!ctx->env->cfg) { 132 free(ctx->env); 133 ub_randfree(ctx->seed_rnd); 134 free(ctx); 135 errno = ENOMEM; 136 return NULL; 137 } 138 /* init edns_known_options */ 139 if(!edns_known_options_init(ctx->env)) { 140 config_delete(ctx->env->cfg); 141 free(ctx->env); 142 ub_randfree(ctx->seed_rnd); 143 free(ctx); 144 errno = ENOMEM; 145 return NULL; 146 } 147 ctx->env->auth_zones = auth_zones_create(); 148 if(!ctx->env->auth_zones) { 149 edns_known_options_delete(ctx->env); 150 config_delete(ctx->env->cfg); 151 free(ctx->env); 152 ub_randfree(ctx->seed_rnd); 153 free(ctx); 154 errno = ENOMEM; 155 return NULL; 156 } 157 ctx->env->edns_strings = edns_strings_create(); 158 if(!ctx->env->edns_strings) { 159 auth_zones_delete(ctx->env->auth_zones); 160 edns_known_options_delete(ctx->env); 161 config_delete(ctx->env->cfg); 162 free(ctx->env); 163 ub_randfree(ctx->seed_rnd); 164 free(ctx); 165 errno = ENOMEM; 166 return NULL; 167 } 168 169 ctx->env->alloc = &ctx->superalloc; 170 ctx->env->worker = NULL; 171 ctx->env->need_to_validate = 0; 172 modstack_init(&ctx->mods); 173 rbtree_init(&ctx->queries, &context_query_cmp); 174 return ctx; 175} 176 177struct ub_ctx* 178ub_ctx_create(void) 179{ 180 struct ub_ctx* ctx = ub_ctx_create_nopipe(); 181 if(!ctx) 182 return NULL; 183 if((ctx->qq_pipe = tube_create()) == NULL) { 184 int e = errno; 185 ub_randfree(ctx->seed_rnd); 186 config_delete(ctx->env->cfg); 187 modstack_desetup(&ctx->mods, ctx->env); 188 edns_known_options_delete(ctx->env); 189 edns_strings_delete(ctx->env->edns_strings); 190 free(ctx->env); 191 free(ctx); 192 errno = e; 193 return NULL; 194 } 195 if((ctx->rr_pipe = tube_create()) == NULL) { 196 int e = errno; 197 tube_delete(ctx->qq_pipe); 198 ub_randfree(ctx->seed_rnd); 199 config_delete(ctx->env->cfg); 200 modstack_desetup(&ctx->mods, ctx->env); 201 edns_known_options_delete(ctx->env); 202 edns_strings_delete(ctx->env->edns_strings); 203 free(ctx->env); 204 free(ctx); 205 errno = e; 206 return NULL; 207 } 208 return ctx; 209} 210 211struct ub_ctx* 212ub_ctx_create_ub_event(struct ub_event_base* ueb) 213{ 214 struct ub_ctx* ctx = ub_ctx_create_nopipe(); 215 if(!ctx) 216 return NULL; 217 /* no pipes, but we have the locks to make sure everything works */ 218 ctx->created_bg = 0; 219 ctx->dothread = 1; /* the processing is in the same process, 220 makes ub_cancel and ub_ctx_delete do the right thing */ 221 ctx->event_base = ueb; 222 return ctx; 223} 224 225struct ub_ctx* 226ub_ctx_create_event(struct event_base* eb) 227{ 228 struct ub_ctx* ctx = ub_ctx_create_nopipe(); 229 if(!ctx) 230 return NULL; 231 /* no pipes, but we have the locks to make sure everything works */ 232 ctx->created_bg = 0; 233 ctx->dothread = 1; /* the processing is in the same process, 234 makes ub_cancel and ub_ctx_delete do the right thing */ 235 ctx->event_base = ub_libevent_event_base(eb); 236 if (!ctx->event_base) { 237 ub_ctx_delete(ctx); 238 return NULL; 239 } 240 ctx->event_base_malloced = 1; 241 return ctx; 242} 243 244/** delete q */ 245static void 246delq(rbnode_type* n, void* ATTR_UNUSED(arg)) 247{ 248 struct ctx_query* q = (struct ctx_query*)n; 249 context_query_delete(q); 250} 251 252/** stop the bg thread */ 253static void ub_stop_bg(struct ub_ctx* ctx) 254{ 255 /* stop the bg thread */ 256 lock_basic_lock(&ctx->cfglock); 257 if(ctx->created_bg) { 258 uint8_t* msg; 259 uint32_t len; 260 uint32_t cmd = UB_LIBCMD_QUIT; 261 lock_basic_unlock(&ctx->cfglock); 262 lock_basic_lock(&ctx->qqpipe_lock); 263 (void)tube_write_msg(ctx->qq_pipe, (uint8_t*)&cmd, 264 (uint32_t)sizeof(cmd), 0); 265 lock_basic_unlock(&ctx->qqpipe_lock); 266 lock_basic_lock(&ctx->rrpipe_lock); 267 while(tube_read_msg(ctx->rr_pipe, &msg, &len, 0)) { 268 /* discard all results except a quit confirm */ 269 if(context_serial_getcmd(msg, len) == UB_LIBCMD_QUIT) { 270 free(msg); 271 break; 272 } 273 free(msg); 274 } 275 lock_basic_unlock(&ctx->rrpipe_lock); 276 277 /* if bg worker is a thread, wait for it to exit, so that all 278 * resources are really gone. */ 279 lock_basic_lock(&ctx->cfglock); 280 if(ctx->dothread) { 281 lock_basic_unlock(&ctx->cfglock); 282 ub_thread_join(ctx->bg_tid); 283 } else { 284 lock_basic_unlock(&ctx->cfglock); 285#ifndef UB_ON_WINDOWS 286 if(waitpid(ctx->bg_pid, NULL, 0) == -1) { 287 if(verbosity > 2) 288 log_err("waitpid: %s", strerror(errno)); 289 } 290#endif 291 } 292 } 293 else { 294 lock_basic_unlock(&ctx->cfglock); 295 } 296} 297 298void 299ub_ctx_delete(struct ub_ctx* ctx) 300{ 301 struct alloc_cache* a, *na; 302 int do_stop = 1; 303 if(!ctx) return; 304 305 /* see if bg thread is created and if threads have been killed */ 306 /* no locks, because those may be held by terminated threads */ 307 /* for processes the read pipe is closed and we see that on read */ 308#ifdef HAVE_PTHREAD 309 if(ctx->created_bg && ctx->dothread) { 310 if(pthread_kill(ctx->bg_tid, 0) == ESRCH) { 311 /* thread has been killed */ 312 do_stop = 0; 313 } 314 } 315#endif /* HAVE_PTHREAD */ 316 if(do_stop) 317 ub_stop_bg(ctx); 318 libworker_delete_event(ctx->event_worker); 319 320 modstack_desetup(&ctx->mods, ctx->env); 321 a = ctx->alloc_list; 322 while(a) { 323 na = a->super; 324 a->super = &ctx->superalloc; 325 alloc_clear(a); 326 free(a); 327 a = na; 328 } 329 local_zones_delete(ctx->local_zones); 330 lock_basic_destroy(&ctx->qqpipe_lock); 331 lock_basic_destroy(&ctx->rrpipe_lock); 332 lock_basic_destroy(&ctx->cfglock); 333 tube_delete(ctx->qq_pipe); 334 tube_delete(ctx->rr_pipe); 335 if(ctx->env) { 336 slabhash_delete(ctx->env->msg_cache); 337 rrset_cache_delete(ctx->env->rrset_cache); 338 infra_delete(ctx->env->infra_cache); 339 config_delete(ctx->env->cfg); 340 edns_known_options_delete(ctx->env); 341 edns_strings_delete(ctx->env->edns_strings); 342 auth_zones_delete(ctx->env->auth_zones); 343 free(ctx->env); 344 } 345 ub_randfree(ctx->seed_rnd); 346 alloc_clear(&ctx->superalloc); 347 traverse_postorder(&ctx->queries, delq, NULL); 348 if(ctx_logfile_overridden) { 349 log_file(NULL); 350 ctx_logfile_overridden = 0; 351 } 352 if(ctx->event_base_malloced) 353 free(ctx->event_base); 354 free(ctx); 355#ifdef USE_WINSOCK 356 WSACleanup(); 357#endif 358} 359 360int 361ub_ctx_set_option(struct ub_ctx* ctx, const char* opt, const char* val) 362{ 363 lock_basic_lock(&ctx->cfglock); 364 if(ctx->finalized) { 365 lock_basic_unlock(&ctx->cfglock); 366 return UB_AFTERFINAL; 367 } 368 if(!config_set_option(ctx->env->cfg, opt, val)) { 369 lock_basic_unlock(&ctx->cfglock); 370 return UB_SYNTAX; 371 } 372 lock_basic_unlock(&ctx->cfglock); 373 return UB_NOERROR; 374} 375 376int 377ub_ctx_get_option(struct ub_ctx* ctx, const char* opt, char** str) 378{ 379 int r; 380 lock_basic_lock(&ctx->cfglock); 381 r = config_get_option_collate(ctx->env->cfg, opt, str); 382 lock_basic_unlock(&ctx->cfglock); 383 if(r == 0) r = UB_NOERROR; 384 else if(r == 1) r = UB_SYNTAX; 385 else if(r == 2) r = UB_NOMEM; 386 return r; 387} 388 389int 390ub_ctx_config(struct ub_ctx* ctx, const char* fname) 391{ 392 lock_basic_lock(&ctx->cfglock); 393 if(ctx->finalized) { 394 lock_basic_unlock(&ctx->cfglock); 395 return UB_AFTERFINAL; 396 } 397 if(!config_read(ctx->env->cfg, fname, NULL)) { 398 lock_basic_unlock(&ctx->cfglock); 399 return UB_SYNTAX; 400 } 401 lock_basic_unlock(&ctx->cfglock); 402 return UB_NOERROR; 403} 404 405int 406ub_ctx_add_ta(struct ub_ctx* ctx, const char* ta) 407{ 408 char* dup = strdup(ta); 409 if(!dup) return UB_NOMEM; 410 lock_basic_lock(&ctx->cfglock); 411 if(ctx->finalized) { 412 lock_basic_unlock(&ctx->cfglock); 413 free(dup); 414 return UB_AFTERFINAL; 415 } 416 if(!cfg_strlist_insert(&ctx->env->cfg->trust_anchor_list, dup)) { 417 lock_basic_unlock(&ctx->cfglock); 418 return UB_NOMEM; 419 } 420 lock_basic_unlock(&ctx->cfglock); 421 return UB_NOERROR; 422} 423 424int 425ub_ctx_add_ta_file(struct ub_ctx* ctx, const char* fname) 426{ 427 char* dup = strdup(fname); 428 if(!dup) return UB_NOMEM; 429 lock_basic_lock(&ctx->cfglock); 430 if(ctx->finalized) { 431 lock_basic_unlock(&ctx->cfglock); 432 free(dup); 433 return UB_AFTERFINAL; 434 } 435 if(!cfg_strlist_insert(&ctx->env->cfg->trust_anchor_file_list, dup)) { 436 lock_basic_unlock(&ctx->cfglock); 437 return UB_NOMEM; 438 } 439 lock_basic_unlock(&ctx->cfglock); 440 return UB_NOERROR; 441} 442 443int ub_ctx_add_ta_autr(struct ub_ctx* ctx, const char* fname) 444{ 445 char* dup = strdup(fname); 446 if(!dup) return UB_NOMEM; 447 lock_basic_lock(&ctx->cfglock); 448 if(ctx->finalized) { 449 lock_basic_unlock(&ctx->cfglock); 450 free(dup); 451 return UB_AFTERFINAL; 452 } 453 if(!cfg_strlist_insert(&ctx->env->cfg->auto_trust_anchor_file_list, 454 dup)) { 455 lock_basic_unlock(&ctx->cfglock); 456 return UB_NOMEM; 457 } 458 lock_basic_unlock(&ctx->cfglock); 459 return UB_NOERROR; 460} 461 462int 463ub_ctx_trustedkeys(struct ub_ctx* ctx, const char* fname) 464{ 465 char* dup = strdup(fname); 466 if(!dup) return UB_NOMEM; 467 lock_basic_lock(&ctx->cfglock); 468 if(ctx->finalized) { 469 lock_basic_unlock(&ctx->cfglock); 470 free(dup); 471 return UB_AFTERFINAL; 472 } 473 if(!cfg_strlist_insert(&ctx->env->cfg->trusted_keys_file_list, dup)) { 474 lock_basic_unlock(&ctx->cfglock); 475 return UB_NOMEM; 476 } 477 lock_basic_unlock(&ctx->cfglock); 478 return UB_NOERROR; 479} 480 481int 482ub_ctx_debuglevel(struct ub_ctx* ctx, int d) 483{ 484 lock_basic_lock(&ctx->cfglock); 485 verbosity = d; 486 ctx->env->cfg->verbosity = d; 487 lock_basic_unlock(&ctx->cfglock); 488 return UB_NOERROR; 489} 490 491int ub_ctx_debugout(struct ub_ctx* ctx, void* out) 492{ 493 lock_basic_lock(&ctx->cfglock); 494 log_file((FILE*)out); 495 ctx_logfile_overridden = 1; 496 ctx->logfile_override = 1; 497 ctx->log_out = out; 498 lock_basic_unlock(&ctx->cfglock); 499 return UB_NOERROR; 500} 501 502int 503ub_ctx_async(struct ub_ctx* ctx, int dothread) 504{ 505#ifdef THREADS_DISABLED 506 if(dothread) /* cannot do threading */ 507 return UB_NOERROR; 508#endif 509 lock_basic_lock(&ctx->cfglock); 510 if(ctx->finalized) { 511 lock_basic_unlock(&ctx->cfglock); 512 return UB_AFTERFINAL; 513 } 514 ctx->dothread = dothread; 515 lock_basic_unlock(&ctx->cfglock); 516 return UB_NOERROR; 517} 518 519int 520ub_poll(struct ub_ctx* ctx) 521{ 522 /* no need to hold lock while testing for readability. */ 523 return tube_poll(ctx->rr_pipe); 524} 525 526int 527ub_fd(struct ub_ctx* ctx) 528{ 529 return tube_read_fd(ctx->rr_pipe); 530} 531 532/** process answer from bg worker */ 533static int 534process_answer_detail(struct ub_ctx* ctx, uint8_t* msg, uint32_t len, 535 ub_callback_type* cb, void** cbarg, int* err, 536 struct ub_result** res) 537{ 538 struct ctx_query* q; 539 if(context_serial_getcmd(msg, len) != UB_LIBCMD_ANSWER) { 540 log_err("error: bad data from bg worker %d", 541 (int)context_serial_getcmd(msg, len)); 542 return 0; 543 } 544 545 lock_basic_lock(&ctx->cfglock); 546 q = context_deserialize_answer(ctx, msg, len, err); 547 if(!q) { 548 lock_basic_unlock(&ctx->cfglock); 549 /* probably simply the lookup that failed, i.e. 550 * response returned before cancel was sent out, so noerror */ 551 return 1; 552 } 553 log_assert(q->async); 554 555 /* grab cb while locked */ 556 if(q->cancelled) { 557 *cb = NULL; 558 *cbarg = NULL; 559 } else { 560 *cb = q->cb; 561 *cbarg = q->cb_arg; 562 } 563 if(*err) { 564 *res = NULL; 565 ub_resolve_free(q->res); 566 } else { 567 /* parse the message, extract rcode, fill result */ 568 sldns_buffer* buf = sldns_buffer_new(q->msg_len); 569 struct regional* region = regional_create(); 570 *res = q->res; 571 (*res)->rcode = LDNS_RCODE_SERVFAIL; 572 if(region && buf) { 573 sldns_buffer_clear(buf); 574 sldns_buffer_write(buf, q->msg, q->msg_len); 575 sldns_buffer_flip(buf); 576 libworker_enter_result(*res, buf, region, 577 q->msg_security); 578 } 579 (*res)->answer_packet = q->msg; 580 (*res)->answer_len = (int)q->msg_len; 581 q->msg = NULL; 582 sldns_buffer_free(buf); 583 regional_destroy(region); 584 } 585 q->res = NULL; 586 /* delete the q from list */ 587 (void)rbtree_delete(&ctx->queries, q->node.key); 588 ctx->num_async--; 589 context_query_delete(q); 590 lock_basic_unlock(&ctx->cfglock); 591 592 if(*cb) return 2; 593 ub_resolve_free(*res); 594 return 1; 595} 596 597/** process answer from bg worker */ 598static int 599process_answer(struct ub_ctx* ctx, uint8_t* msg, uint32_t len) 600{ 601 int err; 602 ub_callback_type cb; 603 void* cbarg; 604 struct ub_result* res; 605 int r; 606 607 r = process_answer_detail(ctx, msg, len, &cb, &cbarg, &err, &res); 608 609 /* no locks held while calling callback, so that library is 610 * re-entrant. */ 611 if(r == 2) 612 (*cb)(cbarg, err, res); 613 614 return r; 615} 616 617int 618ub_process(struct ub_ctx* ctx) 619{ 620 int r; 621 uint8_t* msg; 622 uint32_t len; 623 while(1) { 624 msg = NULL; 625 lock_basic_lock(&ctx->rrpipe_lock); 626 r = tube_read_msg(ctx->rr_pipe, &msg, &len, 1); 627 lock_basic_unlock(&ctx->rrpipe_lock); 628 if(r == 0) 629 return UB_PIPE; 630 else if(r == -1) 631 break; 632 if(!process_answer(ctx, msg, len)) { 633 free(msg); 634 return UB_PIPE; 635 } 636 free(msg); 637 } 638 return UB_NOERROR; 639} 640 641int 642ub_wait(struct ub_ctx* ctx) 643{ 644 int err; 645 ub_callback_type cb; 646 void* cbarg; 647 struct ub_result* res; 648 int r; 649 uint8_t* msg; 650 uint32_t len; 651 /* this is basically the same loop as _process(), but with changes. 652 * holds the rrpipe lock and waits with tube_wait */ 653 while(1) { 654 lock_basic_lock(&ctx->rrpipe_lock); 655 lock_basic_lock(&ctx->cfglock); 656 if(ctx->num_async == 0) { 657 lock_basic_unlock(&ctx->cfglock); 658 lock_basic_unlock(&ctx->rrpipe_lock); 659 break; 660 } 661 lock_basic_unlock(&ctx->cfglock); 662 663 /* keep rrpipe locked, while 664 * o waiting for pipe readable 665 * o parsing message 666 * o possibly decrementing num_async 667 * do callback without lock 668 */ 669 r = tube_wait(ctx->rr_pipe); 670 if(r) { 671 r = tube_read_msg(ctx->rr_pipe, &msg, &len, 1); 672 if(r == 0) { 673 lock_basic_unlock(&ctx->rrpipe_lock); 674 return UB_PIPE; 675 } 676 if(r == -1) { 677 lock_basic_unlock(&ctx->rrpipe_lock); 678 continue; 679 } 680 r = process_answer_detail(ctx, msg, len, 681 &cb, &cbarg, &err, &res); 682 lock_basic_unlock(&ctx->rrpipe_lock); 683 free(msg); 684 if(r == 0) 685 return UB_PIPE; 686 if(r == 2) 687 (*cb)(cbarg, err, res); 688 } else { 689 lock_basic_unlock(&ctx->rrpipe_lock); 690 } 691 } 692 return UB_NOERROR; 693} 694 695int 696ub_resolve(struct ub_ctx* ctx, const char* name, int rrtype, 697 int rrclass, struct ub_result** result) 698{ 699 struct ctx_query* q; 700 int r; 701 *result = NULL; 702 703 lock_basic_lock(&ctx->cfglock); 704 if(!ctx->finalized) { 705 r = context_finalize(ctx); 706 if(r) { 707 lock_basic_unlock(&ctx->cfglock); 708 return r; 709 } 710 } 711 /* create new ctx_query and attempt to add to the list */ 712 lock_basic_unlock(&ctx->cfglock); 713 q = context_new(ctx, name, rrtype, rrclass, NULL, NULL, NULL); 714 if(!q) 715 return UB_NOMEM; 716 /* become a resolver thread for a bit */ 717 718 r = libworker_fg(ctx, q); 719 if(r) { 720 lock_basic_lock(&ctx->cfglock); 721 (void)rbtree_delete(&ctx->queries, q->node.key); 722 context_query_delete(q); 723 lock_basic_unlock(&ctx->cfglock); 724 return r; 725 } 726 q->res->answer_packet = q->msg; 727 q->res->answer_len = (int)q->msg_len; 728 q->msg = NULL; 729 *result = q->res; 730 q->res = NULL; 731 732 lock_basic_lock(&ctx->cfglock); 733 (void)rbtree_delete(&ctx->queries, q->node.key); 734 context_query_delete(q); 735 lock_basic_unlock(&ctx->cfglock); 736 return UB_NOERROR; 737} 738 739int 740ub_resolve_event(struct ub_ctx* ctx, const char* name, int rrtype, 741 int rrclass, void* mydata, ub_event_callback_type callback, 742 int* async_id) 743{ 744 struct ctx_query* q; 745 int r; 746 747 if(async_id) 748 *async_id = 0; 749 lock_basic_lock(&ctx->cfglock); 750 if(!ctx->finalized) { 751 r = context_finalize(ctx); 752 if(r) { 753 lock_basic_unlock(&ctx->cfglock); 754 return r; 755 } 756 } 757 lock_basic_unlock(&ctx->cfglock); 758 if(!ctx->event_worker) { 759 ctx->event_worker = libworker_create_event(ctx, 760 ctx->event_base); 761 if(!ctx->event_worker) { 762 return UB_INITFAIL; 763 } 764 } 765 766 /* set time in case answer comes from cache */ 767 ub_comm_base_now(ctx->event_worker->base); 768 769 /* create new ctx_query and attempt to add to the list */ 770 q = context_new(ctx, name, rrtype, rrclass, NULL, callback, mydata); 771 if(!q) 772 return UB_NOMEM; 773 774 /* attach to mesh */ 775 if((r=libworker_attach_mesh(ctx, q, async_id)) != 0) 776 return r; 777 return UB_NOERROR; 778} 779 780 781int 782ub_resolve_async(struct ub_ctx* ctx, const char* name, int rrtype, 783 int rrclass, void* mydata, ub_callback_type callback, int* async_id) 784{ 785 struct ctx_query* q; 786 uint8_t* msg = NULL; 787 uint32_t len = 0; 788 789 if(async_id) 790 *async_id = 0; 791 lock_basic_lock(&ctx->cfglock); 792 if(!ctx->finalized) { 793 int r = context_finalize(ctx); 794 if(r) { 795 lock_basic_unlock(&ctx->cfglock); 796 return r; 797 } 798 } 799 if(!ctx->created_bg) { 800 int r; 801 ctx->created_bg = 1; 802 lock_basic_unlock(&ctx->cfglock); 803 r = libworker_bg(ctx); 804 if(r) { 805 lock_basic_lock(&ctx->cfglock); 806 ctx->created_bg = 0; 807 lock_basic_unlock(&ctx->cfglock); 808 return r; 809 } 810 } else { 811 lock_basic_unlock(&ctx->cfglock); 812 } 813 814 /* create new ctx_query and attempt to add to the list */ 815 q = context_new(ctx, name, rrtype, rrclass, callback, NULL, mydata); 816 if(!q) 817 return UB_NOMEM; 818 819 /* write over pipe to background worker */ 820 lock_basic_lock(&ctx->cfglock); 821 msg = context_serialize_new_query(q, &len); 822 if(!msg) { 823 (void)rbtree_delete(&ctx->queries, q->node.key); 824 ctx->num_async--; 825 context_query_delete(q); 826 lock_basic_unlock(&ctx->cfglock); 827 return UB_NOMEM; 828 } 829 if(async_id) 830 *async_id = q->querynum; 831 lock_basic_unlock(&ctx->cfglock); 832 833 lock_basic_lock(&ctx->qqpipe_lock); 834 if(!tube_write_msg(ctx->qq_pipe, msg, len, 0)) { 835 lock_basic_unlock(&ctx->qqpipe_lock); 836 free(msg); 837 return UB_PIPE; 838 } 839 lock_basic_unlock(&ctx->qqpipe_lock); 840 free(msg); 841 return UB_NOERROR; 842} 843 844int 845ub_cancel(struct ub_ctx* ctx, int async_id) 846{ 847 struct ctx_query* q; 848 uint8_t* msg = NULL; 849 uint32_t len = 0; 850 lock_basic_lock(&ctx->cfglock); 851 q = (struct ctx_query*)rbtree_search(&ctx->queries, &async_id); 852 if(!q || !q->async) { 853 /* it is not there, so nothing to do */ 854 lock_basic_unlock(&ctx->cfglock); 855 return UB_NOID; 856 } 857 log_assert(q->async); 858 q->cancelled = 1; 859 860 /* delete it */ 861 if(!ctx->dothread) { /* if forked */ 862 (void)rbtree_delete(&ctx->queries, q->node.key); 863 ctx->num_async--; 864 msg = context_serialize_cancel(q, &len); 865 context_query_delete(q); 866 lock_basic_unlock(&ctx->cfglock); 867 if(!msg) { 868 return UB_NOMEM; 869 } 870 /* send cancel to background worker */ 871 lock_basic_lock(&ctx->qqpipe_lock); 872 if(!tube_write_msg(ctx->qq_pipe, msg, len, 0)) { 873 lock_basic_unlock(&ctx->qqpipe_lock); 874 free(msg); 875 return UB_PIPE; 876 } 877 lock_basic_unlock(&ctx->qqpipe_lock); 878 free(msg); 879 } else { 880 lock_basic_unlock(&ctx->cfglock); 881 } 882 return UB_NOERROR; 883} 884 885void 886ub_resolve_free(struct ub_result* result) 887{ 888 char** p; 889 if(!result) return; 890 free(result->qname); 891 if(result->canonname != result->qname) 892 free(result->canonname); 893 if(result->data) 894 for(p = result->data; *p; p++) 895 free(*p); 896 free(result->data); 897 free(result->len); 898 free(result->answer_packet); 899 free(result->why_bogus); 900 free(result); 901} 902 903const char* 904ub_strerror(int err) 905{ 906 switch(err) { 907 case UB_NOERROR: return "no error"; 908 case UB_SOCKET: return "socket io error"; 909 case UB_NOMEM: return "out of memory"; 910 case UB_SYNTAX: return "syntax error"; 911 case UB_SERVFAIL: return "server failure"; 912 case UB_FORKFAIL: return "could not fork"; 913 case UB_INITFAIL: return "initialization failure"; 914 case UB_AFTERFINAL: return "setting change after finalize"; 915 case UB_PIPE: return "error in pipe communication with async"; 916 case UB_READFILE: return "error reading file"; 917 case UB_NOID: return "error async_id does not exist"; 918 default: return "unknown error"; 919 } 920} 921 922int 923ub_ctx_set_fwd(struct ub_ctx* ctx, const char* addr) 924{ 925 struct sockaddr_storage storage; 926 socklen_t stlen; 927 struct config_stub* s; 928 char* dupl; 929 lock_basic_lock(&ctx->cfglock); 930 if(ctx->finalized) { 931 lock_basic_unlock(&ctx->cfglock); 932 errno=EINVAL; 933 return UB_AFTERFINAL; 934 } 935 if(!addr) { 936 /* disable fwd mode - the root stub should be first. */ 937 if(ctx->env->cfg->forwards && 938 strcmp(ctx->env->cfg->forwards->name, ".") == 0) { 939 s = ctx->env->cfg->forwards; 940 ctx->env->cfg->forwards = s->next; 941 s->next = NULL; 942 config_delstubs(s); 943 } 944 lock_basic_unlock(&ctx->cfglock); 945 return UB_NOERROR; 946 } 947 lock_basic_unlock(&ctx->cfglock); 948 949 /* check syntax for addr */ 950 if(!extstrtoaddr(addr, &storage, &stlen)) { 951 errno=EINVAL; 952 return UB_SYNTAX; 953 } 954 955 /* it parses, add root stub in front of list */ 956 lock_basic_lock(&ctx->cfglock); 957 if(!ctx->env->cfg->forwards || 958 strcmp(ctx->env->cfg->forwards->name, ".") != 0) { 959 s = calloc(1, sizeof(*s)); 960 if(!s) { 961 lock_basic_unlock(&ctx->cfglock); 962 errno=ENOMEM; 963 return UB_NOMEM; 964 } 965 s->name = strdup("."); 966 if(!s->name) { 967 free(s); 968 lock_basic_unlock(&ctx->cfglock); 969 errno=ENOMEM; 970 return UB_NOMEM; 971 } 972 s->next = ctx->env->cfg->forwards; 973 ctx->env->cfg->forwards = s; 974 } else { 975 log_assert(ctx->env->cfg->forwards); 976 s = ctx->env->cfg->forwards; 977 } 978 dupl = strdup(addr); 979 if(!dupl) { 980 lock_basic_unlock(&ctx->cfglock); 981 errno=ENOMEM; 982 return UB_NOMEM; 983 } 984 if(!cfg_strlist_insert(&s->addrs, dupl)) { 985 lock_basic_unlock(&ctx->cfglock); 986 errno=ENOMEM; 987 return UB_NOMEM; 988 } 989 lock_basic_unlock(&ctx->cfglock); 990 return UB_NOERROR; 991} 992 993int ub_ctx_set_tls(struct ub_ctx* ctx, int tls) 994{ 995 lock_basic_lock(&ctx->cfglock); 996 if(ctx->finalized) { 997 lock_basic_unlock(&ctx->cfglock); 998 errno=EINVAL; 999 return UB_AFTERFINAL; 1000 } 1001 ctx->env->cfg->ssl_upstream = tls; 1002 lock_basic_unlock(&ctx->cfglock); 1003 return UB_NOERROR; 1004} 1005 1006int ub_ctx_set_stub(struct ub_ctx* ctx, const char* zone, const char* addr, 1007 int isprime) 1008{ 1009 char* a; 1010 struct config_stub **prev, *elem; 1011 1012 /* check syntax for zone name */ 1013 if(zone) { 1014 uint8_t* nm; 1015 int nmlabs; 1016 size_t nmlen; 1017 if(!parse_dname(zone, &nm, &nmlen, &nmlabs)) { 1018 errno=EINVAL; 1019 return UB_SYNTAX; 1020 } 1021 free(nm); 1022 } else { 1023 zone = "."; 1024 } 1025 1026 /* check syntax for addr (if not NULL) */ 1027 if(addr) { 1028 struct sockaddr_storage storage; 1029 socklen_t stlen; 1030 if(!extstrtoaddr(addr, &storage, &stlen)) { 1031 errno=EINVAL; 1032 return UB_SYNTAX; 1033 } 1034 } 1035 1036 lock_basic_lock(&ctx->cfglock); 1037 if(ctx->finalized) { 1038 lock_basic_unlock(&ctx->cfglock); 1039 errno=EINVAL; 1040 return UB_AFTERFINAL; 1041 } 1042 1043 /* arguments all right, now find or add the stub */ 1044 prev = &ctx->env->cfg->stubs; 1045 elem = cfg_stub_find(&prev, zone); 1046 if(!elem && !addr) { 1047 /* not found and we want to delete, nothing to do */ 1048 lock_basic_unlock(&ctx->cfglock); 1049 return UB_NOERROR; 1050 } else if(elem && !addr) { 1051 /* found, and we want to delete */ 1052 *prev = elem->next; 1053 config_delstub(elem); 1054 lock_basic_unlock(&ctx->cfglock); 1055 return UB_NOERROR; 1056 } else if(!elem) { 1057 /* not found, create the stub entry */ 1058 elem=(struct config_stub*)calloc(1, sizeof(struct config_stub)); 1059 if(elem) elem->name = strdup(zone); 1060 if(!elem || !elem->name) { 1061 free(elem); 1062 lock_basic_unlock(&ctx->cfglock); 1063 errno = ENOMEM; 1064 return UB_NOMEM; 1065 } 1066 elem->next = ctx->env->cfg->stubs; 1067 ctx->env->cfg->stubs = elem; 1068 } 1069 1070 /* add the address to the list and set settings */ 1071 elem->isprime = isprime; 1072 a = strdup(addr); 1073 if(!a) { 1074 lock_basic_unlock(&ctx->cfglock); 1075 errno = ENOMEM; 1076 return UB_NOMEM; 1077 } 1078 if(!cfg_strlist_insert(&elem->addrs, a)) { 1079 lock_basic_unlock(&ctx->cfglock); 1080 errno = ENOMEM; 1081 return UB_NOMEM; 1082 } 1083 lock_basic_unlock(&ctx->cfglock); 1084 return UB_NOERROR; 1085} 1086 1087int 1088ub_ctx_resolvconf(struct ub_ctx* ctx, const char* fname) 1089{ 1090 FILE* in; 1091 int numserv = 0; 1092 char buf[1024]; 1093 char* parse, *addr; 1094 int r; 1095 1096 if(fname == NULL) { 1097#if !defined(UB_ON_WINDOWS) || !defined(HAVE_WINDOWS_H) 1098 fname = "/etc/resolv.conf"; 1099#else 1100 FIXED_INFO *info; 1101 ULONG buflen = sizeof(*info); 1102 IP_ADDR_STRING *ptr; 1103 1104 info = (FIXED_INFO *) malloc(sizeof (FIXED_INFO)); 1105 if (info == NULL) 1106 return UB_READFILE; 1107 1108 if (GetNetworkParams(info, &buflen) == ERROR_BUFFER_OVERFLOW) { 1109 free(info); 1110 info = (FIXED_INFO *) malloc(buflen); 1111 if (info == NULL) 1112 return UB_READFILE; 1113 } 1114 1115 if (GetNetworkParams(info, &buflen) == NO_ERROR) { 1116 int retval=0; 1117 ptr = &(info->DnsServerList); 1118 while (ptr) { 1119 numserv++; 1120 if((retval=ub_ctx_set_fwd(ctx, 1121 ptr->IpAddress.String))!=0) { 1122 free(info); 1123 return retval; 1124 } 1125 ptr = ptr->Next; 1126 } 1127 free(info); 1128 if (numserv==0) 1129 return UB_READFILE; 1130 return UB_NOERROR; 1131 } 1132 free(info); 1133 return UB_READFILE; 1134#endif /* WINDOWS */ 1135 } 1136 in = fopen(fname, "r"); 1137 if(!in) { 1138 /* error in errno! perror(fname) */ 1139 return UB_READFILE; 1140 } 1141 while(fgets(buf, (int)sizeof(buf), in)) { 1142 buf[sizeof(buf)-1] = 0; 1143 parse=buf; 1144 while(*parse == ' ' || *parse == '\t') 1145 parse++; 1146 if(strncmp(parse, "nameserver", 10) == 0) { 1147 numserv++; 1148 parse += 10; /* skip 'nameserver' */ 1149 /* skip whitespace */ 1150 while(*parse == ' ' || *parse == '\t') 1151 parse++; 1152 addr = parse; 1153 /* skip [0-9a-fA-F.:]*, i.e. IP4 and IP6 address */ 1154 while(isxdigit((unsigned char)*parse) || *parse=='.' || *parse==':') 1155 parse++; 1156 /* terminate after the address, remove newline */ 1157 *parse = 0; 1158 1159 if((r = ub_ctx_set_fwd(ctx, addr)) != UB_NOERROR) { 1160 fclose(in); 1161 return r; 1162 } 1163 } 1164 } 1165 fclose(in); 1166 if(numserv == 0) { 1167 /* from resolv.conf(5) if none given, use localhost */ 1168 return ub_ctx_set_fwd(ctx, "127.0.0.1"); 1169 } 1170 return UB_NOERROR; 1171} 1172 1173int 1174ub_ctx_hosts(struct ub_ctx* ctx, const char* fname) 1175{ 1176 FILE* in; 1177 char buf[1024], ldata[2048]; 1178 char* parse, *addr, *name, *ins; 1179 lock_basic_lock(&ctx->cfglock); 1180 if(ctx->finalized) { 1181 lock_basic_unlock(&ctx->cfglock); 1182 errno=EINVAL; 1183 return UB_AFTERFINAL; 1184 } 1185 lock_basic_unlock(&ctx->cfglock); 1186 if(fname == NULL) { 1187#if defined(UB_ON_WINDOWS) && defined(HAVE_WINDOWS_H) 1188 /* 1189 * If this is Windows NT/XP/2K it's in 1190 * %WINDIR%\system32\drivers\etc\hosts. 1191 * If this is Windows 95/98/Me it's in %WINDIR%\hosts. 1192 */ 1193 name = getenv("WINDIR"); 1194 if (name != NULL) { 1195 int retval=0; 1196 snprintf(buf, sizeof(buf), "%s%s", name, 1197 "\\system32\\drivers\\etc\\hosts"); 1198 if((retval=ub_ctx_hosts(ctx, buf)) !=0 ) { 1199 snprintf(buf, sizeof(buf), "%s%s", name, 1200 "\\hosts"); 1201 retval=ub_ctx_hosts(ctx, buf); 1202 } 1203 return retval; 1204 } 1205 return UB_READFILE; 1206#else 1207 fname = "/etc/hosts"; 1208#endif /* WIN32 */ 1209 } 1210 in = fopen(fname, "r"); 1211 if(!in) { 1212 /* error in errno! perror(fname) */ 1213 return UB_READFILE; 1214 } 1215 while(fgets(buf, (int)sizeof(buf), in)) { 1216 buf[sizeof(buf)-1] = 0; 1217 parse=buf; 1218 while(*parse == ' ' || *parse == '\t') 1219 parse++; 1220 if(*parse == '#') 1221 continue; /* skip comment */ 1222 /* format: <addr> spaces <name> spaces <name> ... */ 1223 addr = parse; 1224 /* skip addr */ 1225 while(isxdigit((unsigned char)*parse) || *parse == '.' || *parse == ':') 1226 parse++; 1227 if(*parse == '\r') 1228 parse++; 1229 if(*parse == '\n' || *parse == 0) 1230 continue; 1231 if(*parse == '%') 1232 continue; /* ignore macOSX fe80::1%lo0 localhost */ 1233 if(*parse != ' ' && *parse != '\t') { 1234 /* must have whitespace after address */ 1235 fclose(in); 1236 errno=EINVAL; 1237 return UB_SYNTAX; 1238 } 1239 *parse++ = 0; /* end delimiter for addr ... */ 1240 /* go to names and add them */ 1241 while(*parse) { 1242 while(*parse == ' ' || *parse == '\t' || *parse=='\n' 1243 || *parse=='\r') 1244 parse++; 1245 if(*parse == 0 || *parse == '#') 1246 break; 1247 /* skip name, allows (too) many printable characters */ 1248 name = parse; 1249 while('!' <= *parse && *parse <= '~') 1250 parse++; 1251 if(*parse) 1252 *parse++ = 0; /* end delimiter for name */ 1253 snprintf(ldata, sizeof(ldata), "%s %s %s", 1254 name, str_is_ip6(addr)?"AAAA":"A", addr); 1255 ins = strdup(ldata); 1256 if(!ins) { 1257 /* out of memory */ 1258 fclose(in); 1259 errno=ENOMEM; 1260 return UB_NOMEM; 1261 } 1262 lock_basic_lock(&ctx->cfglock); 1263 if(!cfg_strlist_insert(&ctx->env->cfg->local_data, 1264 ins)) { 1265 lock_basic_unlock(&ctx->cfglock); 1266 fclose(in); 1267 errno=ENOMEM; 1268 return UB_NOMEM; 1269 } 1270 lock_basic_unlock(&ctx->cfglock); 1271 } 1272 } 1273 fclose(in); 1274 return UB_NOERROR; 1275} 1276 1277/** finalize the context, if not already finalized */ 1278static int ub_ctx_finalize(struct ub_ctx* ctx) 1279{ 1280 int res = 0; 1281 lock_basic_lock(&ctx->cfglock); 1282 if (!ctx->finalized) { 1283 res = context_finalize(ctx); 1284 } 1285 lock_basic_unlock(&ctx->cfglock); 1286 return res; 1287} 1288 1289/* Print local zones and RR data */ 1290int ub_ctx_print_local_zones(struct ub_ctx* ctx) 1291{ 1292 int res = ub_ctx_finalize(ctx); 1293 if (res) return res; 1294 1295 local_zones_print(ctx->local_zones); 1296 1297 return UB_NOERROR; 1298} 1299 1300/* Add a new zone */ 1301int ub_ctx_zone_add(struct ub_ctx* ctx, const char *zone_name, 1302 const char *zone_type) 1303{ 1304 enum localzone_type t; 1305 struct local_zone* z; 1306 uint8_t* nm; 1307 int nmlabs; 1308 size_t nmlen; 1309 1310 int res = ub_ctx_finalize(ctx); 1311 if (res) return res; 1312 1313 if(!local_zone_str2type(zone_type, &t)) { 1314 return UB_SYNTAX; 1315 } 1316 1317 if(!parse_dname(zone_name, &nm, &nmlen, &nmlabs)) { 1318 return UB_SYNTAX; 1319 } 1320 1321 lock_rw_wrlock(&ctx->local_zones->lock); 1322 if((z=local_zones_find(ctx->local_zones, nm, nmlen, nmlabs, 1323 LDNS_RR_CLASS_IN))) { 1324 /* already present in tree */ 1325 lock_rw_wrlock(&z->lock); 1326 z->type = t; /* update type anyway */ 1327 lock_rw_unlock(&z->lock); 1328 lock_rw_unlock(&ctx->local_zones->lock); 1329 free(nm); 1330 return UB_NOERROR; 1331 } 1332 if(!local_zones_add_zone(ctx->local_zones, nm, nmlen, nmlabs, 1333 LDNS_RR_CLASS_IN, t)) { 1334 lock_rw_unlock(&ctx->local_zones->lock); 1335 return UB_NOMEM; 1336 } 1337 lock_rw_unlock(&ctx->local_zones->lock); 1338 return UB_NOERROR; 1339} 1340 1341/* Remove zone */ 1342int ub_ctx_zone_remove(struct ub_ctx* ctx, const char *zone_name) 1343{ 1344 struct local_zone* z; 1345 uint8_t* nm; 1346 int nmlabs; 1347 size_t nmlen; 1348 1349 int res = ub_ctx_finalize(ctx); 1350 if (res) return res; 1351 1352 if(!parse_dname(zone_name, &nm, &nmlen, &nmlabs)) { 1353 return UB_SYNTAX; 1354 } 1355 1356 lock_rw_wrlock(&ctx->local_zones->lock); 1357 if((z=local_zones_find(ctx->local_zones, nm, nmlen, nmlabs, 1358 LDNS_RR_CLASS_IN))) { 1359 /* present in tree */ 1360 local_zones_del_zone(ctx->local_zones, z); 1361 } 1362 lock_rw_unlock(&ctx->local_zones->lock); 1363 free(nm); 1364 return UB_NOERROR; 1365} 1366 1367/* Add new RR data */ 1368int ub_ctx_data_add(struct ub_ctx* ctx, const char *data) 1369{ 1370 int res = ub_ctx_finalize(ctx); 1371 if (res) return res; 1372 1373 res = local_zones_add_RR(ctx->local_zones, data); 1374 return (!res) ? UB_NOMEM : UB_NOERROR; 1375} 1376 1377/* Remove RR data */ 1378int ub_ctx_data_remove(struct ub_ctx* ctx, const char *data) 1379{ 1380 uint8_t* nm; 1381 int nmlabs; 1382 size_t nmlen; 1383 int res = ub_ctx_finalize(ctx); 1384 if (res) return res; 1385 1386 if(!parse_dname(data, &nm, &nmlen, &nmlabs)) 1387 return UB_SYNTAX; 1388 1389 local_zones_del_data(ctx->local_zones, nm, nmlen, nmlabs, 1390 LDNS_RR_CLASS_IN); 1391 1392 free(nm); 1393 return UB_NOERROR; 1394} 1395 1396const char* ub_version(void) 1397{ 1398 return PACKAGE_VERSION; 1399} 1400 1401int 1402ub_ctx_set_event(struct ub_ctx* ctx, struct event_base* base) { 1403 struct ub_event_base* new_base; 1404 1405 if (!ctx || !ctx->event_base || !base) { 1406 return UB_INITFAIL; 1407 } 1408 if (ub_libevent_get_event_base(ctx->event_base) == base) { 1409 /* already set */ 1410 return UB_NOERROR; 1411 } 1412 1413 lock_basic_lock(&ctx->cfglock); 1414 /* destroy the current worker - safe to pass in NULL */ 1415 libworker_delete_event(ctx->event_worker); 1416 ctx->event_worker = NULL; 1417 new_base = ub_libevent_event_base(base); 1418 if (new_base) 1419 ctx->event_base = new_base; 1420 ctx->created_bg = 0; 1421 ctx->dothread = 1; 1422 lock_basic_unlock(&ctx->cfglock); 1423 return new_base ? UB_NOERROR : UB_INITFAIL; 1424} 1425