contrib/bind-9.3/bin/named/lwresd.c

   1 /*
   2  * Copyright (C) 2004  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 2000-2003  Internet Software Consortium.
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  10  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  11  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  12  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  13  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  14  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  15  * PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 /* $Id: lwresd.c,v 1.37.2.2.2.5 2004/03/08 04:04:19 marka Exp $ */
  19
  20 /*
  21  * Main program for the Lightweight Resolver Daemon.
  22  *
  23  * To paraphrase the old saying about X11, "It's not a lightweight deamon
  24  * for resolvers, it's a deamon for lightweight resolvers".
  25  */
  26
  27 #include <config.h>
  28
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 #include <isc/list.h>
  33 #include <isc/magic.h>
  34 #include <isc/mem.h>
  35 #include <isc/once.h>
  36 #include <isc/print.h>
  37 #include <isc/socket.h>
  38 #include <isc/task.h>
  39 #include <isc/util.h>
  40
  41 #include <isccfg/namedconf.h>
  42
  43 #include <dns/log.h>
  44 #include <dns/result.h>
  45 #include <dns/view.h>
  46
  47 #include <named/config.h>
  48 #include <named/globals.h>
  49 #include <named/log.h>
  50 #include <named/lwaddr.h>
  51 #include <named/lwresd.h>
  52 #include <named/lwdclient.h>
  53 #include <named/lwsearch.h>
  54 #include <named/server.h>
  55
  56 #define LWRESD_MAGIC            ISC_MAGIC('L', 'W', 'R', 'D')
  57 #define VALID_LWRESD(l)         ISC_MAGIC_VALID(l, LWRESD_MAGIC)
  58
  59 #define LWRESLISTENER_MAGIC     ISC_MAGIC('L', 'W', 'R', 'L')
  60 #define VALID_LWRESLISTENER(l)  ISC_MAGIC_VALID(l, LWRESLISTENER_MAGIC)
  61
  62 /*
  63  * The total number of clients we can handle will be NTASKS * NRECVS.
  64  */
  65 #define NTASKS          2       /* tasks to create to handle lwres queries */
  66 #define NRECVS          2       /* max clients per task */
  67
  68 typedef ISC_LIST(ns_lwreslistener_t) ns_lwreslistenerlist_t;
  69
  70 static ns_lwreslistenerlist_t listeners;
  71 static isc_mutex_t listeners_lock;
  72 static isc_once_t once = ISC_ONCE_INIT;
  73
  74
  75 static void
  76 initialize_mutex(void) {
  77         RUNTIME_CHECK(isc_mutex_init(&listeners_lock) == ISC_R_SUCCESS);
  78 }
  79
  80
  81 /*
  82  * Wrappers around our memory management stuff, for the lwres functions.
  83  */
  84 void *
  85 ns__lwresd_memalloc(void *arg, size_t size) {
  86         return (isc_mem_get(arg, size));
  87 }
  88
  89 void
  90 ns__lwresd_memfree(void *arg, void *mem, size_t size) {
  91         isc_mem_put(arg, mem, size);
  92 }
  93
  94
  95 #define CHECK(op)                                               \
  96         do { result = (op);                                     \
  97                 if (result != ISC_R_SUCCESS) goto cleanup;      \
  98         } while (0)
  99
 100 static isc_result_t
 101 buffer_putstr(isc_buffer_t *b, const char *s) {
 102         unsigned int len = strlen(s);
 103         if (isc_buffer_availablelength(b) <= len)
 104                 return (ISC_R_NOSPACE);
 105         isc_buffer_putmem(b, (const unsigned char *)s, len);
 106         return (ISC_R_SUCCESS);
 107 }
 108
 109 /*
 110  * Convert a resolv.conf file into a config structure.
 111  */
 112 isc_result_t
 113 ns_lwresd_parseeresolvconf(isc_mem_t *mctx, cfg_parser_t *pctx,
 114                            cfg_obj_t **configp)
 115 {
 116         char text[4096];
 117         char str[16];
 118         isc_buffer_t b;
 119         lwres_context_t *lwctx = NULL;
 120         lwres_conf_t *lwc = NULL;
 121         isc_sockaddr_t sa;
 122         isc_netaddr_t na;
 123         int i;
 124         isc_result_t result;
 125         lwres_result_t lwresult;
 126
 127         lwctx = NULL;
 128         lwresult = lwres_context_create(&lwctx, mctx, ns__lwresd_memalloc,
 129                                         ns__lwresd_memfree,
 130                                         LWRES_CONTEXT_SERVERMODE);
 131         if (lwresult != LWRES_R_SUCCESS) {
 132                 result = ISC_R_NOMEMORY;
 133                 goto cleanup;
 134         }
 135
 136         lwresult = lwres_conf_parse(lwctx, lwresd_g_resolvconffile);
 137         if (lwresult != LWRES_R_SUCCESS) {
 138                 result = DNS_R_SYNTAX;
 139                 goto cleanup;
 140         }
 141
 142         lwc = lwres_conf_get(lwctx);
 143         INSIST(lwc != NULL);
 144
 145         isc_buffer_init(&b, text, sizeof(text));
 146
 147         CHECK(buffer_putstr(&b, "options {\n"));
 148
 149         /*
 150          * Build the list of forwarders.
 151          */
 152         if (lwc->nsnext > 0) {
 153                 CHECK(buffer_putstr(&b, "\tforwarders {\n"));
 154
 155                 for (i = 0; i < lwc->nsnext; i++) {
 156                         CHECK(lwaddr_sockaddr_fromlwresaddr(
 157                                                         &sa,
 158                                                         &lwc->nameservers[i],
 159                                                         ns_g_port));
 160                         isc_netaddr_fromsockaddr(&na, &sa);
 161                         CHECK(buffer_putstr(&b, "\t\t"));
 162                         CHECK(isc_netaddr_totext(&na, &b));
 163                         CHECK(buffer_putstr(&b, ";\n"));
 164                 }
 165                 CHECK(buffer_putstr(&b, "\t};\n"));
 166         }
 167
 168         /*
 169          * Build the sortlist
 170          */
 171         if (lwc->sortlistnxt > 0) {
 172                 CHECK(buffer_putstr(&b, "\tsortlist {\n"));
 173                 CHECK(buffer_putstr(&b, "\t\t{\n"));
 174                 CHECK(buffer_putstr(&b, "\t\t\tany;\n"));
 175                 CHECK(buffer_putstr(&b, "\t\t\t{\n"));
 176                 for (i = 0; i < lwc->sortlistnxt; i++) {
 177                         lwres_addr_t *lwaddr = &lwc->sortlist[i].addr;
 178                         lwres_addr_t *lwmask = &lwc->sortlist[i].mask;
 179                         unsigned int mask;
 180
 181                         CHECK(lwaddr_sockaddr_fromlwresaddr(&sa, lwmask, 0));
 182                         isc_netaddr_fromsockaddr(&na, &sa);
 183                         result = isc_netaddr_masktoprefixlen(&na, &mask);
 184                         if (result != ISC_R_SUCCESS) {
 185                                 char addrtext[ISC_NETADDR_FORMATSIZE];
 186                                 isc_netaddr_format(&na, addrtext,
 187                                                    sizeof(addrtext));
 188                                 isc_log_write(ns_g_lctx,
 189                                               NS_LOGCATEGORY_GENERAL,
 190                                               NS_LOGMODULE_LWRESD,
 191                                               ISC_LOG_ERROR,
 192                                               "processing sortlist: '%s' is "
 193                                               "not a valid netmask",
 194                                               addrtext);
 195                                 goto cleanup;
 196                         }
 197
 198                         CHECK(lwaddr_sockaddr_fromlwresaddr(&sa, lwaddr, 0));
 199                         isc_netaddr_fromsockaddr(&na, &sa);
 200
 201                         CHECK(buffer_putstr(&b, "\t\t\t\t"));
 202                         CHECK(isc_netaddr_totext(&na, &b));
 203                         snprintf(str, sizeof(str), "%u", mask);
 204                         CHECK(buffer_putstr(&b, "/"));
 205                         CHECK(buffer_putstr(&b, str));
 206                         CHECK(buffer_putstr(&b, ";\n"));
 207                 }
 208                 CHECK(buffer_putstr(&b, "\t\t\t};\n"));
 209                 CHECK(buffer_putstr(&b, "\t\t};\n"));
 210                 CHECK(buffer_putstr(&b, "\t};\n"));
 211         }
 212
 213         CHECK(buffer_putstr(&b, "};\n\n"));
 214
 215         CHECK(buffer_putstr(&b, "lwres {\n"));
 216
 217         /*
 218          * Build the search path
 219          */
 220         if (lwc->searchnxt > 0) {
 221                 if (lwc->searchnxt > 0) {
 222                         CHECK(buffer_putstr(&b, "\tsearch {\n"));
 223                         for (i = 0; i < lwc->searchnxt; i++) {
 224                                 CHECK(buffer_putstr(&b, "\t\t\""));
 225                                 CHECK(buffer_putstr(&b, lwc->search[i]));
 226                                 CHECK(buffer_putstr(&b, "\";\n"));
 227                         }
 228                         CHECK(buffer_putstr(&b, "\t};\n"));
 229                 }
 230         }
 231
 232         /*
 233          * Build the ndots line
 234          */
 235         if (lwc->ndots != 1) {
 236                 CHECK(buffer_putstr(&b, "\tndots "));
 237                 snprintf(str, sizeof(str), "%u", lwc->ndots);
 238                 CHECK(buffer_putstr(&b, str));
 239                 CHECK(buffer_putstr(&b, ";\n"));
 240         }
 241
 242         /*
 243          * Build the listen-on line
 244          */
 245         if (lwc->lwnext > 0) {
 246                 CHECK(buffer_putstr(&b, "\tlisten-on {\n"));
 247
 248                 for (i = 0; i < lwc->lwnext; i++) {
 249                         CHECK(lwaddr_sockaddr_fromlwresaddr(&sa,
 250                                                             &lwc->lwservers[i],
 251                                                             0));
 252                         isc_netaddr_fromsockaddr(&na, &sa);
 253                         CHECK(buffer_putstr(&b, "\t\t"));
 254                         CHECK(isc_netaddr_totext(&na, &b));
 255                         CHECK(buffer_putstr(&b, ";\n"));
 256                 }
 257                 CHECK(buffer_putstr(&b, "\t};\n"));
 258         }
 259
 260         CHECK(buffer_putstr(&b, "};\n"));
 261
 262 #if 0
 263         printf("%.*s\n",
 264                (int)isc_buffer_usedlength(&b),
 265                (char *)isc_buffer_base(&b));
 266 #endif
 267
 268         lwres_conf_clear(lwctx);
 269         lwres_context_destroy(&lwctx);
 270
 271         return (cfg_parse_buffer(pctx, &b, &cfg_type_namedconf, configp));
 272
 273  cleanup:
 274
 275         if (lwctx != NULL) {
 276                 lwres_conf_clear(lwctx);
 277                 lwres_context_destroy(&lwctx);
 278         }
 279
 280         return (result);
 281 }
 282
 283
 284 /*
 285  * Handle lwresd manager objects
 286  */
 287 isc_result_t
 288 ns_lwdmanager_create(isc_mem_t *mctx, cfg_obj_t *lwres,
 289                      ns_lwresd_t **lwresdp)
 290 {
 291         ns_lwresd_t *lwresd;
 292         const char *vname;
 293         dns_rdataclass_t vclass;
 294         cfg_obj_t *obj, *viewobj, *searchobj;
 295         cfg_listelt_t *element;
 296         isc_result_t result;
 297
 298         INSIST(lwresdp != NULL && *lwresdp == NULL);
 299
 300         lwresd = isc_mem_get(mctx, sizeof(ns_lwresd_t));
 301         if (lwresd == NULL)
 302                 return (ISC_R_NOMEMORY);
 303
 304         lwresd->mctx = NULL;
 305         isc_mem_attach(mctx, &lwresd->mctx);
 306         lwresd->view = NULL;
 307         lwresd->search = NULL;
 308         lwresd->refs = 1;
 309
 310         obj = NULL;
 311         (void)cfg_map_get(lwres, "ndots", &obj);
 312         if (obj != NULL)
 313                 lwresd->ndots = cfg_obj_asuint32(obj);
 314         else
 315                 lwresd->ndots = 1;
 316
 317         RUNTIME_CHECK(isc_mutex_init(&lwresd->lock) == ISC_R_SUCCESS);
 318
 319         lwresd->shutting_down = ISC_FALSE;
 320
 321         viewobj = NULL;
 322         (void)cfg_map_get(lwres, "view", &viewobj);
 323         if (viewobj != NULL) {
 324                 vname = cfg_obj_asstring(cfg_tuple_get(viewobj, "name"));
 325                 obj = cfg_tuple_get(viewobj, "class");
 326                 result = ns_config_getclass(obj, dns_rdataclass_in, &vclass);
 327                 if (result != ISC_R_SUCCESS)
 328                         goto fail;
 329         } else {
 330                 vname = "_default";
 331                 vclass = dns_rdataclass_in;
 332         }
 333
 334         result = dns_viewlist_find(&ns_g_server->viewlist, vname, vclass,
 335                                    &lwresd->view);
 336         if (result != ISC_R_SUCCESS) {
 337                 isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
 338                               NS_LOGMODULE_LWRESD, ISC_LOG_WARNING,
 339                               "couldn't find view %s", vname);
 340                 goto fail;
 341         }
 342
 343         searchobj = NULL;
 344         (void)cfg_map_get(lwres, "search", &searchobj);
 345         if (searchobj != NULL) {
 346                 lwresd->search = NULL;
 347                 result = ns_lwsearchlist_create(lwresd->mctx,
 348                                                 &lwresd->search);
 349                 if (result != ISC_R_SUCCESS) {
 350                         isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
 351                                       NS_LOGMODULE_LWRESD, ISC_LOG_WARNING,
 352                                       "couldn't create searchlist");
 353                         goto fail;
 354                 }
 355                 for (element = cfg_list_first(searchobj);
 356                      element != NULL;
 357                      element = cfg_list_next(element))
 358                 {
 359                         cfg_obj_t *search;
 360                         char *searchstr;
 361                         isc_buffer_t namebuf;
 362                         dns_fixedname_t fname;
 363                         dns_name_t *name;
 364
 365                         search = cfg_listelt_value(element);
 366                         searchstr = cfg_obj_asstring(search);
 367
 368                         dns_fixedname_init(&fname);
 369                         name = dns_fixedname_name(&fname);
 370                         isc_buffer_init(&namebuf, searchstr,
 371                                         strlen(searchstr));
 372                         isc_buffer_add(&namebuf, strlen(searchstr));
 373                         result = dns_name_fromtext(name, &namebuf,
 374                                                    dns_rootname, ISC_FALSE,
 375                                                    NULL);
 376                         if (result != ISC_R_SUCCESS) {
 377                                 isc_log_write(ns_g_lctx,
 378                                               NS_LOGCATEGORY_GENERAL,
 379                                               NS_LOGMODULE_LWRESD,
 380                                               ISC_LOG_WARNING,
 381                                               "invalid name %s in searchlist",
 382                                               searchstr);
 383                                 continue;
 384                         }
 385
 386                         result = ns_lwsearchlist_append(lwresd->search, name);
 387                         if (result != ISC_R_SUCCESS) {
 388                                 isc_log_write(ns_g_lctx,
 389                                               NS_LOGCATEGORY_GENERAL,
 390                                               NS_LOGMODULE_LWRESD,
 391                                               ISC_LOG_WARNING,
 392                                               "couldn't update searchlist");
 393                                 goto fail;
 394                         }
 395                 }
 396         }
 397
 398         lwresd->magic = LWRESD_MAGIC;
 399
 400         *lwresdp = lwresd;
 401         return (ISC_R_SUCCESS);
 402
 403  fail:
 404         if (lwresd->view != NULL)
 405                 dns_view_detach(&lwresd->view);
 406         if (lwresd->search != NULL)
 407                 ns_lwsearchlist_detach(&lwresd->search);
 408         if (lwresd->mctx != NULL)
 409                 isc_mem_detach(&lwresd->mctx);
 410         return (result);
 411 }
 412
 413 void
 414 ns_lwdmanager_attach(ns_lwresd_t *source, ns_lwresd_t **targetp) {
 415         INSIST(VALID_LWRESD(source));
 416         INSIST(targetp != NULL && *targetp == NULL);
 417
 418         LOCK(&source->lock);
 419         source->refs++;
 420         UNLOCK(&source->lock);
 421
 422         *targetp = source;
 423 }
 424
 425 void
 426 ns_lwdmanager_detach(ns_lwresd_t **lwresdp) {
 427         ns_lwresd_t *lwresd;
 428         isc_mem_t *mctx;
 429         isc_boolean_t done = ISC_FALSE;
 430
 431         INSIST(lwresdp != NULL && *lwresdp != NULL);
 432         INSIST(VALID_LWRESD(*lwresdp));
 433
 434         lwresd = *lwresdp;
 435         *lwresdp = NULL;
 436
 437         LOCK(&lwresd->lock);
 438         INSIST(lwresd->refs > 0);
 439         lwresd->refs--;
 440         if (lwresd->refs == 0)
 441                 done = ISC_TRUE;
 442         UNLOCK(&lwresd->lock);
 443
 444         if (!done)
 445                 return;
 446
 447         dns_view_detach(&lwresd->view);
 448         if (lwresd->search != NULL)
 449                 ns_lwsearchlist_detach(&lwresd->search);
 450         mctx = lwresd->mctx;
 451         lwresd->magic = 0;
 452         isc_mem_put(mctx, lwresd, sizeof(*lwresd));
 453         isc_mem_detach(&mctx);
 454 }
 455
 456
 457 /*
 458  * Handle listener objects
 459  */
 460 void
 461 ns_lwreslistener_attach(ns_lwreslistener_t *source,
 462                         ns_lwreslistener_t **targetp)
 463 {
 464         INSIST(VALID_LWRESLISTENER(source));
 465         INSIST(targetp != NULL && *targetp == NULL);
 466
 467         LOCK(&source->lock);
 468         source->refs++;
 469         UNLOCK(&source->lock);
 470
 471         *targetp = source;
 472 }
 473
 474 void
 475 ns_lwreslistener_detach(ns_lwreslistener_t **listenerp) {
 476         ns_lwreslistener_t *listener;
 477         isc_mem_t *mctx;
 478         isc_boolean_t done = ISC_FALSE;
 479
 480         INSIST(listenerp != NULL && *listenerp != NULL);
 481         INSIST(VALID_LWRESLISTENER(*listenerp));
 482
 483         listener = *listenerp;
 484
 485         LOCK(&listener->lock);
 486         INSIST(listener->refs > 0);
 487         listener->refs--;
 488         if (listener->refs == 0)
 489                 done = ISC_TRUE;
 490         UNLOCK(&listener->lock);
 491
 492         if (!done)
 493                 return;
 494
 495         if (listener->manager != NULL)
 496                 ns_lwdmanager_detach(&listener->manager);
 497
 498         if (listener->sock != NULL)
 499                 isc_socket_detach(&listener->sock);
 500
 501         listener->magic = 0;
 502         mctx = listener->mctx;
 503         isc_mem_put(mctx, listener, sizeof(*listener));
 504         isc_mem_detach(&mctx);
 505         listenerp = NULL;
 506 }
 507
 508 static isc_result_t
 509 listener_create(isc_mem_t *mctx, ns_lwresd_t *lwresd,
 510                 ns_lwreslistener_t **listenerp)
 511 {
 512         ns_lwreslistener_t *listener;
 513
 514         REQUIRE(listenerp != NULL && *listenerp == NULL);
 515
 516         listener = isc_mem_get(mctx, sizeof(ns_lwreslistener_t));
 517         if (listener == NULL)
 518                 return (ISC_R_NOMEMORY);
 519         RUNTIME_CHECK(isc_mutex_init(&listener->lock) == ISC_R_SUCCESS);
 520
 521         listener->magic = LWRESLISTENER_MAGIC;
 522         listener->refs = 1;
 523
 524         listener->sock = NULL;
 525
 526         listener->manager = NULL;
 527         ns_lwdmanager_attach(lwresd, &listener->manager);
 528
 529         listener->mctx = NULL;
 530         isc_mem_attach(mctx, &listener->mctx);
 531
 532         ISC_LINK_INIT(listener, link);
 533         ISC_LIST_INIT(listener->cmgrs);
 534
 535         *listenerp = listener;
 536         return (ISC_R_SUCCESS);
 537 }
 538
 539 static isc_result_t
 540 listener_bind(ns_lwreslistener_t *listener, isc_sockaddr_t *address) {
 541         isc_socket_t *sock = NULL;
 542         isc_result_t result = ISC_R_SUCCESS;
 543         int pf;
 544
 545         pf = isc_sockaddr_pf(address);
 546         if ((pf == AF_INET && isc_net_probeipv4() != ISC_R_SUCCESS) ||
 547             (pf == AF_INET6 && isc_net_probeipv6() != ISC_R_SUCCESS))
 548                 return (ISC_R_FAMILYNOSUPPORT);
 549
 550         listener->address = *address;
 551
 552         if (isc_sockaddr_getport(&listener->address) == 0) {
 553                 in_port_t port;
 554                 port = lwresd_g_listenport;
 555                 if (port == 0)
 556                         port = LWRES_UDP_PORT;
 557                 isc_sockaddr_setport(&listener->address, port);
 558         }
 559
 560         sock = NULL;
 561         result = isc_socket_create(ns_g_socketmgr, pf,
 562                                    isc_sockettype_udp, &sock);
 563         if (result != ISC_R_SUCCESS) {
 564                 isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
 565                               NS_LOGMODULE_LWRESD, ISC_LOG_WARNING,
 566                               "failed to create lwres socket: %s",
 567                               isc_result_totext(result));
 568                 return (result);
 569         }
 570
 571         result = isc_socket_bind(sock, &listener->address);
 572         if (result != ISC_R_SUCCESS) {
 573                 char socktext[ISC_SOCKADDR_FORMATSIZE];
 574                 isc_sockaddr_format(&listener->address, socktext,
 575                                     sizeof(socktext));
 576                 isc_socket_detach(&sock);
 577                 isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
 578                               NS_LOGMODULE_LWRESD, ISC_LOG_WARNING,
 579                               "failed to add lwres socket: %s: %s",
 580                               socktext, isc_result_totext(result));
 581                 return (result);
 582         }
 583         listener->sock = sock;
 584         return (ISC_R_SUCCESS);
 585 }
 586
 587 static void
 588 listener_copysock(ns_lwreslistener_t *oldlistener,
 589                   ns_lwreslistener_t *newlistener)
 590 {
 591         newlistener->address = oldlistener->address;
 592         isc_socket_attach(oldlistener->sock, &newlistener->sock);
 593 }
 594
 595 static isc_result_t
 596 listener_startclients(ns_lwreslistener_t *listener) {
 597         ns_lwdclientmgr_t *cm;
 598         unsigned int i;
 599         isc_result_t result;
 600
 601         /*
 602          * Create the client managers.
 603          */
 604         result = ISC_R_SUCCESS;
 605         for (i = 0; i < NTASKS && result == ISC_R_SUCCESS; i++)
 606                 result = ns_lwdclientmgr_create(listener, NRECVS,
 607                                                 ns_g_taskmgr);
 608
 609         /*
 610          * Ensure that we have created at least one.
 611          */
 612         if (ISC_LIST_EMPTY(listener->cmgrs))
 613                 return (result);
 614
 615         /*
 616          * Walk the list of clients and start each one up.
 617          */
 618         LOCK(&listener->lock);
 619         cm = ISC_LIST_HEAD(listener->cmgrs);
 620         while (cm != NULL) {
 621                 result = ns_lwdclient_startrecv(cm);
 622                 if (result != ISC_R_SUCCESS)
 623                         isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
 624                                       NS_LOGMODULE_LWRESD, ISC_LOG_ERROR,
 625                                       "could not start lwres "
 626                                       "client handler: %s",
 627                                       isc_result_totext(result));
 628                 cm = ISC_LIST_NEXT(cm, link);
 629         }
 630         UNLOCK(&listener->lock);
 631
 632         return (ISC_R_SUCCESS);
 633 }
 634
 635 static void
 636 listener_shutdown(ns_lwreslistener_t *listener) {
 637         ns_lwdclientmgr_t *cm;
 638
 639         cm = ISC_LIST_HEAD(listener->cmgrs);
 640         while (cm != NULL) {
 641                 isc_task_shutdown(cm->task);
 642                 cm = ISC_LIST_NEXT(cm, link);
 643         }
 644 }
 645
 646 static isc_result_t
 647 find_listener(isc_sockaddr_t *address, ns_lwreslistener_t **listenerp) {
 648         ns_lwreslistener_t *listener;
 649
 650         INSIST(listenerp != NULL && *listenerp == NULL);
 651
 652         for (listener = ISC_LIST_HEAD(listeners);
 653              listener != NULL;
 654              listener = ISC_LIST_NEXT(listener, link))
 655         {
 656                 if (!isc_sockaddr_equal(address, &listener->address))
 657                         continue;
 658                 *listenerp = listener;
 659                 return (ISC_R_SUCCESS);
 660         }
 661         return (ISC_R_NOTFOUND);
 662 }
 663
 664 void
 665 ns_lwreslistener_unlinkcm(ns_lwreslistener_t *listener, ns_lwdclientmgr_t *cm)
 666 {
 667         REQUIRE(VALID_LWRESLISTENER(listener));
 668
 669         LOCK(&listener->lock);
 670         ISC_LIST_UNLINK(listener->cmgrs, cm, link);
 671         UNLOCK(&listener->lock);
 672 }
 673
 674 void
 675 ns_lwreslistener_linkcm(ns_lwreslistener_t *listener, ns_lwdclientmgr_t *cm) {
 676         REQUIRE(VALID_LWRESLISTENER(listener));
 677
 678         /*
 679          * This does no locking, since it's called early enough that locking
 680          * isn't needed.
 681          */
 682         ISC_LIST_APPEND(listener->cmgrs, cm, link);
 683 }
 684
 685 static isc_result_t
 686 configure_listener(isc_sockaddr_t *address, ns_lwresd_t *lwresd,
 687                    isc_mem_t *mctx, ns_lwreslistenerlist_t *newlisteners)
 688 {
 689         ns_lwreslistener_t *listener, *oldlistener = NULL;
 690         char socktext[ISC_SOCKADDR_FORMATSIZE];
 691         isc_result_t result;
 692
 693         (void)find_listener(address, &oldlistener);
 694         listener = NULL;
 695         result = listener_create(mctx, lwresd, &listener);
 696         if (result != ISC_R_SUCCESS) {
 697                 isc_sockaddr_format(address, socktext, sizeof(socktext));
 698                 isc_log_write(ns_g_lctx, ISC_LOGCATEGORY_GENERAL,
 699                               NS_LOGMODULE_LWRESD, ISC_LOG_WARNING,
 700                               "lwres failed to configure %s: %s",
 701                               socktext, isc_result_totext(result));
 702                 return (result);
 703         }
 704
 705         /*
 706          * If there's already a listener, don't rebind the socket.
 707          */
 708         if (oldlistener == NULL) {
 709                 result = listener_bind(listener, address);
 710                 if (result != ISC_R_SUCCESS) {
 711                         ns_lwreslistener_detach(&listener);
 712                         return (ISC_R_SUCCESS);
 713                 }
 714         } else
 715                 listener_copysock(oldlistener, listener);
 716
 717         result = listener_startclients(listener);
 718         if (result != ISC_R_SUCCESS) {
 719                 isc_sockaddr_format(address, socktext, sizeof(socktext));
 720                 isc_log_write(ns_g_lctx, ISC_LOGCATEGORY_GENERAL,
 721                               NS_LOGMODULE_LWRESD, ISC_LOG_WARNING,
 722                               "lwres: failed to start %s: %s", socktext,
 723                               isc_result_totext(result));
 724                 ns_lwreslistener_detach(&listener);
 725                 return (ISC_R_SUCCESS);
 726         }
 727
 728         if (oldlistener != NULL) {
 729                 /*
 730                  * Remove the old listener from the old list and shut it down.
 731                  */
 732                 ISC_LIST_UNLINK(listeners, oldlistener, link);
 733                 listener_shutdown(oldlistener);
 734                 ns_lwreslistener_detach(&oldlistener);
 735         } else {
 736                 isc_sockaddr_format(address, socktext, sizeof(socktext));
 737                 isc_log_write(ns_g_lctx, ISC_LOGCATEGORY_GENERAL,
 738                               NS_LOGMODULE_LWRESD, ISC_LOG_NOTICE,
 739                               "lwres listening on %s", socktext);
 740         }
 741
 742         ISC_LIST_APPEND(*newlisteners, listener, link);
 743         return (result);
 744 }
 745
 746 isc_result_t
 747 ns_lwresd_configure(isc_mem_t *mctx, cfg_obj_t *config) {
 748         cfg_obj_t *lwreslist = NULL;
 749         cfg_obj_t *lwres = NULL;
 750         cfg_obj_t *listenerslist = NULL;
 751         cfg_listelt_t *element = NULL;
 752         ns_lwreslistener_t *listener;
 753         ns_lwreslistenerlist_t newlisteners;
 754         isc_result_t result;
 755         char socktext[ISC_SOCKADDR_FORMATSIZE];
 756         isc_sockaddr_t *addrs = NULL;
 757         ns_lwresd_t *lwresd = NULL;
 758         isc_uint32_t count = 0;
 759
 760         REQUIRE(mctx != NULL);
 761         REQUIRE(config != NULL);
 762
 763         RUNTIME_CHECK(isc_once_do(&once, initialize_mutex) == ISC_R_SUCCESS);
 764
 765         ISC_LIST_INIT(newlisteners);
 766
 767         result = cfg_map_get(config, "lwres", &lwreslist);
 768         if (result != ISC_R_SUCCESS)
 769                 return (ISC_R_SUCCESS);
 770
 771         LOCK(&listeners_lock);
 772         /*
 773          * Run through the new lwres address list, noting sockets that
 774          * are already being listened on and moving them to the new list.
 775          *
 776          * Identifying duplicates addr/port combinations is left to either
 777          * the underlying config code, or to the bind attempt getting an
 778          * address-in-use error.
 779          */
 780         for (element = cfg_list_first(lwreslist);
 781              element != NULL;
 782              element = cfg_list_next(element))
 783         {
 784                 in_port_t port;
 785
 786                 lwres = cfg_listelt_value(element);
 787                 CHECK(ns_lwdmanager_create(mctx, lwres, &lwresd));
 788
 789                 port = lwresd_g_listenport;
 790                 if (port == 0)
 791                         port = LWRES_UDP_PORT;
 792
 793                 listenerslist = NULL;
 794                 (void)cfg_map_get(lwres, "listen-on", &listenerslist);
 795                 if (listenerslist == NULL) {
 796                         struct in_addr localhost;
 797                         isc_sockaddr_t address;
 798
 799                         localhost.s_addr = htonl(INADDR_LOOPBACK);
 800                         isc_sockaddr_fromin(&address, &localhost, port);
 801                         CHECK(configure_listener(&address, lwresd, mctx,
 802                                                  &newlisteners));
 803                 } else {
 804                         isc_uint32_t i;
 805
 806                         CHECK(ns_config_getiplist(config, listenerslist,
 807                                                   port, mctx, &addrs, &count));
 808                         for (i = 0; i < count; i++)
 809                                 CHECK(configure_listener(&addrs[i], lwresd,
 810                                                          mctx, &newlisteners));
 811                         ns_config_putiplist(mctx, &addrs, count);
 812                 }
 813                 ns_lwdmanager_detach(&lwresd);
 814         }
 815
 816         /*
 817          * Shutdown everything on the listeners list, and remove them from
 818          * the list.  Then put all of the new listeners on it.
 819          */
 820
 821         while (!ISC_LIST_EMPTY(listeners)) {
 822                 listener = ISC_LIST_HEAD(listeners);
 823                 ISC_LIST_UNLINK(listeners, listener, link);
 824
 825                 isc_sockaddr_format(&listener->address,
 826                                     socktext, sizeof(socktext));
 827
 828                 listener_shutdown(listener);
 829                 ns_lwreslistener_detach(&listener);
 830
 831                 isc_log_write(ns_g_lctx, ISC_LOGCATEGORY_GENERAL,
 832                               NS_LOGMODULE_LWRESD, ISC_LOG_NOTICE,
 833                               "lwres no longer listening on %s", socktext);
 834         }
 835
 836  cleanup:
 837         ISC_LIST_APPENDLIST(listeners, newlisteners, link);
 838
 839         if (addrs != NULL)
 840                 ns_config_putiplist(mctx, &addrs, count);
 841
 842         if (lwresd != NULL)
 843                 ns_lwdmanager_detach(&lwresd);
 844
 845         UNLOCK(&listeners_lock);
 846
 847         return (result);
 848 }
 849
 850 void
 851 ns_lwresd_shutdown(void) {
 852         ns_lwreslistener_t *listener;
 853
 854         RUNTIME_CHECK(isc_once_do(&once, initialize_mutex) == ISC_R_SUCCESS);
 855
 856         while (!ISC_LIST_EMPTY(listeners)) {
 857                 listener = ISC_LIST_HEAD(listeners);
 858                 ISC_LIST_UNLINK(listeners, listener, link);
 859                 ns_lwreslistener_detach(&listener);
 860         }
 861 }