contrib/bind-9.2.4rc7/bin/named/controlconf.c

   1 /*
   2  * Copyright (C) 2004  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 2001, 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: controlconf.c,v 1.28.2.10 2004/03/09 06:09:18 marka Exp $ */
  19
  20 #include <config.h>
  21
  22 #include <isc/base64.h>
  23 #include <isc/buffer.h>
  24 #include <isc/event.h>
  25 #include <isc/file.h>
  26 #include <isc/fsaccess.h>
  27 #include <isc/mem.h>
  28 #include <isc/net.h>
  29 #include <isc/netaddr.h>
  30 #include <isc/print.h>
  31 #include <isc/random.h>
  32 #include <isc/result.h>
  33 #include <isc/stdio.h>
  34 #include <isc/stdtime.h>
  35 #include <isc/string.h>
  36 #include <isc/timer.h>
  37 #include <isc/util.h>
  38
  39 #include <isccfg/cfg.h>
  40 #include <isccfg/check.h>
  41
  42 #include <isccc/alist.h>
  43 #include <isccc/cc.h>
  44 #include <isccc/ccmsg.h>
  45 #include <isccc/events.h>
  46 #include <isccc/result.h>
  47 #include <isccc/sexpr.h>
  48 #include <isccc/symtab.h>
  49 #include <isccc/util.h>
  50
  51 #include <dns/keyvalues.h>
  52 #include <dns/result.h>
  53
  54 #include <dst/dst.h>
  55
  56 #include <named/config.h>
  57 #include <named/control.h>
  58 #include <named/log.h>
  59 #include <named/server.h>
  60
  61 /*
  62  * Note: Listeners and connections are not locked.  All event handlers are
  63  * executed by the server task, and all callers of exported routines must
  64  * be running under the server task.
  65  */
  66
  67 typedef struct controlkey controlkey_t;
  68 typedef ISC_LIST(controlkey_t) controlkeylist_t;
  69
  70 typedef struct controlconnection controlconnection_t;
  71 typedef ISC_LIST(controlconnection_t) controlconnectionlist_t;
  72
  73 typedef struct controllistener controllistener_t;
  74 typedef ISC_LIST(controllistener_t) controllistenerlist_t;
  75
  76 struct controlkey {
  77         char *                          keyname;
  78         isc_region_t                    secret;
  79         ISC_LINK(controlkey_t)          link;
  80 };
  81
  82 struct controlconnection {
  83         isc_socket_t *                  sock;
  84         isccc_ccmsg_t                   ccmsg;
  85         isc_boolean_t                   ccmsg_valid;
  86         isc_boolean_t                   sending;
  87         isc_timer_t *                   timer;
  88         unsigned char                   buffer[2048];
  89         controllistener_t *             listener;
  90         isc_uint32_t                    nonce;
  91         ISC_LINK(controlconnection_t)   link;
  92 };
  93
  94 struct controllistener {
  95         ns_controls_t *                 controls;
  96         isc_mem_t *                     mctx;
  97         isc_task_t *                    task;
  98         isc_sockaddr_t                  address;
  99         isc_socket_t *                  sock;
 100         dns_acl_t *                     acl;
 101         isc_boolean_t                   listening;
 102         isc_boolean_t                   exiting;
 103         controlkeylist_t                keys;
 104         controlconnectionlist_t         connections;
 105         ISC_LINK(controllistener_t)     link;
 106 };
 107
 108 struct ns_controls {
 109         ns_server_t                     *server;
 110         controllistenerlist_t           listeners;
 111         isc_boolean_t                   shuttingdown;
 112         isccc_symtab_t                  *symtab;
 113 };
 114
 115 static void control_newconn(isc_task_t *task, isc_event_t *event);
 116 static void control_recvmessage(isc_task_t *task, isc_event_t *event);
 117
 118 #define CLOCKSKEW 300
 119
 120 static void
 121 free_controlkey(controlkey_t *key, isc_mem_t *mctx) {
 122         if (key->keyname != NULL)
 123                 isc_mem_free(mctx, key->keyname);
 124         if (key->secret.base != NULL)
 125                 isc_mem_put(mctx, key->secret.base, key->secret.length);
 126         isc_mem_put(mctx, key, sizeof(*key));
 127 }
 128
 129 static void
 130 free_controlkeylist(controlkeylist_t *keylist, isc_mem_t *mctx) {
 131         while (!ISC_LIST_EMPTY(*keylist)) {
 132                 controlkey_t *key = ISC_LIST_HEAD(*keylist);
 133                 ISC_LIST_UNLINK(*keylist, key, link);
 134                 free_controlkey(key, mctx);
 135         }
 136 }
 137
 138 static void
 139 free_listener(controllistener_t *listener) {
 140         INSIST(listener->exiting);
 141         INSIST(!listener->listening);
 142         INSIST(ISC_LIST_EMPTY(listener->connections));
 143
 144         if (listener->sock != NULL)
 145                 isc_socket_detach(&listener->sock);
 146
 147         free_controlkeylist(&listener->keys, listener->mctx);
 148
 149         if (listener->acl != NULL)
 150                 dns_acl_detach(&listener->acl);
 151
 152         isc_mem_put(listener->mctx, listener, sizeof(*listener));
 153 }
 154
 155 static void
 156 maybe_free_listener(controllistener_t *listener) {
 157         if (listener->exiting &&
 158             !listener->listening &&
 159             ISC_LIST_EMPTY(listener->connections))
 160                 free_listener(listener);
 161 }
 162
 163 static void
 164 maybe_free_connection(controlconnection_t *conn) {
 165         controllistener_t *listener = conn->listener;
 166
 167         if (conn->timer != NULL)
 168                 isc_timer_detach(&conn->timer);
 169
 170         if (conn->ccmsg_valid) {
 171                 isccc_ccmsg_cancelread(&conn->ccmsg);
 172                 return;
 173         }
 174
 175         if (conn->sending) {
 176                 isc_socket_cancel(conn->sock, listener->task,
 177                                   ISC_SOCKCANCEL_SEND);
 178                 return;
 179         }
 180
 181         ISC_LIST_UNLINK(listener->connections, conn, link);
 182         isc_mem_put(listener->mctx, conn, sizeof(*conn));
 183 }
 184
 185 static void
 186 shutdown_listener(controllistener_t *listener) {
 187         controlconnection_t *conn;
 188         controlconnection_t *next;
 189
 190         if (!listener->exiting) {
 191                 char socktext[ISC_SOCKADDR_FORMATSIZE];
 192
 193                 ISC_LIST_UNLINK(listener->controls->listeners, listener, link);
 194
 195                 isc_sockaddr_format(&listener->address, socktext,
 196                                     sizeof(socktext));
 197                 isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
 198                               NS_LOGMODULE_CONTROL, ISC_LOG_NOTICE,
 199                               "stopping command channel on %s", socktext);
 200                 listener->exiting = ISC_TRUE;
 201         }
 202
 203         for (conn = ISC_LIST_HEAD(listener->connections);
 204              conn != NULL;
 205              conn = next)
 206         {
 207                 next = ISC_LIST_NEXT(conn, link);
 208                 maybe_free_connection(conn);
 209         }
 210
 211         if (listener->listening)
 212                 isc_socket_cancel(listener->sock, listener->task,
 213                                   ISC_SOCKCANCEL_ACCEPT);
 214
 215         maybe_free_listener(listener);
 216 }
 217
 218 static isc_boolean_t
 219 address_ok(isc_sockaddr_t *sockaddr, dns_acl_t *acl) {
 220         isc_netaddr_t netaddr;
 221         isc_result_t result;
 222         int match;
 223
 224         isc_netaddr_fromsockaddr(&netaddr, sockaddr);
 225
 226         result = dns_acl_match(&netaddr, NULL, acl,
 227                                &ns_g_server->aclenv, &match, NULL);
 228
 229         if (result != ISC_R_SUCCESS || match <= 0)
 230                 return (ISC_FALSE);
 231         else
 232                 return (ISC_TRUE);
 233 }
 234
 235 static isc_result_t
 236 control_accept(controllistener_t *listener) {
 237         isc_result_t result;
 238         result = isc_socket_accept(listener->sock,
 239                                    listener->task,
 240                                    control_newconn, listener);
 241         if (result != ISC_R_SUCCESS)
 242                 UNEXPECTED_ERROR(__FILE__, __LINE__,
 243                                  "isc_socket_accept() failed: %s",
 244                                  isc_result_totext(result));
 245         else
 246                 listener->listening = ISC_TRUE;
 247         return (result);
 248 }
 249
 250 static isc_result_t
 251 control_listen(controllistener_t *listener) {
 252         isc_result_t result;
 253
 254         result = isc_socket_listen(listener->sock, 0);
 255         if (result != ISC_R_SUCCESS)
 256                 UNEXPECTED_ERROR(__FILE__, __LINE__,
 257                                  "isc_socket_listen() failed: %s",
 258                                  isc_result_totext(result));
 259         return (result);
 260 }
 261
 262 static void
 263 control_next(controllistener_t *listener) {
 264         (void)control_accept(listener);
 265 }
 266
 267 static void
 268 control_senddone(isc_task_t *task, isc_event_t *event) {
 269         isc_socketevent_t *sevent = (isc_socketevent_t *) event;
 270         controlconnection_t *conn = event->ev_arg;
 271         controllistener_t *listener = conn->listener;
 272         isc_socket_t *sock = (isc_socket_t *)sevent->ev_sender;
 273         isc_result_t result;
 274
 275         REQUIRE(conn->sending);
 276
 277         UNUSED(task);
 278
 279         conn->sending = ISC_FALSE;
 280
 281         if (sevent->result != ISC_R_SUCCESS &&
 282             sevent->result != ISC_R_CANCELED)
 283         {
 284                 char socktext[ISC_SOCKADDR_FORMATSIZE];
 285                 isc_sockaddr_t peeraddr;
 286
 287                 (void)isc_socket_getpeername(sock, &peeraddr);
 288                 isc_sockaddr_format(&peeraddr, socktext, sizeof(socktext));
 289                 isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
 290                               NS_LOGMODULE_CONTROL, ISC_LOG_WARNING,
 291                               "error sending command response to %s: %s",
 292                               socktext, isc_result_totext(sevent->result));
 293         }
 294         isc_event_free(&event);
 295
 296         result = isccc_ccmsg_readmessage(&conn->ccmsg, listener->task,
 297                                          control_recvmessage, conn);
 298         if (result != ISC_R_SUCCESS) {
 299                 isc_socket_detach(&conn->sock);
 300                 maybe_free_connection(conn);
 301                 maybe_free_listener(listener);
 302         }
 303 }
 304
 305 static inline void
 306 log_invalid(isccc_ccmsg_t *ccmsg, isc_result_t result) {
 307         char socktext[ISC_SOCKADDR_FORMATSIZE];
 308         isc_sockaddr_t peeraddr;
 309
 310         (void)isc_socket_getpeername(ccmsg->sock, &peeraddr);
 311         isc_sockaddr_format(&peeraddr, socktext, sizeof(socktext));
 312         isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
 313                       NS_LOGMODULE_CONTROL, ISC_LOG_ERROR,
 314                       "invalid command from %s: %s",
 315                       socktext, isc_result_totext(result));
 316 }
 317
 318 static void
 319 control_recvmessage(isc_task_t *task, isc_event_t *event) {
 320         controlconnection_t *conn;
 321         controllistener_t *listener;
 322         controlkey_t *key;
 323         isccc_sexpr_t *request = NULL;
 324         isccc_sexpr_t *response = NULL;
 325         isccc_region_t ccregion;
 326         isccc_region_t secret;
 327         isc_stdtime_t now;
 328         isc_buffer_t b;
 329         isc_region_t r;
 330         isc_uint32_t len;
 331         isc_buffer_t text;
 332         char textarray[1024];
 333         isc_result_t result;
 334         isc_result_t eresult;
 335         isccc_sexpr_t *_ctrl;
 336         isccc_time_t sent;
 337         isccc_time_t exp;
 338         isc_uint32_t nonce;
 339
 340         REQUIRE(event->ev_type == ISCCC_EVENT_CCMSG);
 341
 342         conn = event->ev_arg;
 343         listener = conn->listener;
 344         secret.rstart = NULL;
 345
 346         /* Is the server shutting down? */
 347         if (listener->controls->shuttingdown)
 348                 goto cleanup;
 349
 350         if (conn->ccmsg.result != ISC_R_SUCCESS) {
 351                 if (conn->ccmsg.result != ISC_R_CANCELED &&
 352                     conn->ccmsg.result != ISC_R_EOF)
 353                         log_invalid(&conn->ccmsg, conn->ccmsg.result);
 354                 goto cleanup;
 355         }
 356
 357         request = NULL;
 358
 359         for (key = ISC_LIST_HEAD(listener->keys);
 360              key != NULL;
 361              key = ISC_LIST_NEXT(key, link))
 362         {
 363                 ccregion.rstart = isc_buffer_base(&conn->ccmsg.buffer);
 364                 ccregion.rend = isc_buffer_used(&conn->ccmsg.buffer);
 365                 secret.rstart = isc_mem_get(listener->mctx, key->secret.length);
 366                 if (secret.rstart == NULL)
 367                         goto cleanup;
 368                 memcpy(secret.rstart, key->secret.base, key->secret.length);
 369                 secret.rend = secret.rstart + key->secret.length;
 370                 result = isccc_cc_fromwire(&ccregion, &request, &secret);
 371                 if (result == ISC_R_SUCCESS)
 372                         break;
 373                 else if (result == ISCCC_R_BADAUTH) {
 374                         /*
 375                          * For some reason, request is non-NULL when
 376                          * isccc_cc_fromwire returns ISCCC_R_BADAUTH.
 377                          */
 378                         if (request != NULL)
 379                                 isccc_sexpr_free(&request);
 380                         isc_mem_put(listener->mctx, secret.rstart,
 381                                     REGION_SIZE(secret));
 382                 } else {
 383                         log_invalid(&conn->ccmsg, result);
 384                         goto cleanup;
 385                 }
 386         }
 387
 388         if (key == NULL) {
 389                 log_invalid(&conn->ccmsg, ISCCC_R_BADAUTH);
 390                 goto cleanup;
 391         }
 392
 393         /* We shouldn't be getting a reply. */
 394         if (isccc_cc_isreply(request)) {
 395                 log_invalid(&conn->ccmsg, ISC_R_FAILURE);
 396                 goto cleanup;
 397         }
 398
 399         isc_stdtime_get(&now);
 400
 401         /*
 402          * Limit exposure to replay attacks.
 403          */
 404         _ctrl = isccc_alist_lookup(request, "_ctrl");
 405         if (_ctrl == NULL) {
 406                 log_invalid(&conn->ccmsg, ISC_R_FAILURE);
 407                 goto cleanup;
 408         }
 409
 410         if (isccc_cc_lookupuint32(_ctrl, "_tim", &sent) == ISC_R_SUCCESS) {
 411                 if ((sent + CLOCKSKEW) < now || (sent - CLOCKSKEW) > now) {
 412                         log_invalid(&conn->ccmsg, ISCCC_R_CLOCKSKEW);
 413                         goto cleanup;
 414                 }
 415         } else {
 416                 log_invalid(&conn->ccmsg, ISC_R_FAILURE);
 417                 goto cleanup;
 418         }
 419
 420         /*
 421          * Expire messages that are too old.
 422          */
 423         if (isccc_cc_lookupuint32(_ctrl, "_exp", &exp) == ISC_R_SUCCESS &&
 424             now > exp) {
 425                 log_invalid(&conn->ccmsg, ISCCC_R_EXPIRED);
 426                 goto cleanup;
 427         }
 428
 429         /*
 430          * Duplicate suppression (required for UDP).
 431          */
 432         isccc_cc_cleansymtab(listener->controls->symtab, now);
 433         result = isccc_cc_checkdup(listener->controls->symtab, request, now);
 434         if (result != ISC_R_SUCCESS) {
 435                 if (result == ISC_R_EXISTS)
 436                         result = ISCCC_R_DUPLICATE;
 437                 log_invalid(&conn->ccmsg, result);
 438                 goto cleanup;
 439         }
 440
 441         if (conn->nonce != 0 &&
 442             (isccc_cc_lookupuint32(_ctrl, "_nonce", &nonce) != ISC_R_SUCCESS ||
 443              conn->nonce != nonce)) {
 444                 log_invalid(&conn->ccmsg, ISCCC_R_BADAUTH);
 445                 goto cleanup;
 446         }
 447
 448         /*
 449          * Establish nonce.
 450          */
 451         while (conn->nonce == 0)
 452                 isc_random_get(&conn->nonce);
 453
 454         isc_buffer_init(&text, textarray, sizeof(textarray));
 455         eresult = ns_control_docommand(request, &text);
 456
 457         result = isccc_cc_createresponse(request, now, now + 60, &response);
 458         if (result != ISC_R_SUCCESS)
 459                 goto cleanup;
 460         if (eresult != ISC_R_SUCCESS) {
 461                 isccc_sexpr_t *data;
 462
 463                 data = isccc_alist_lookup(response, "_data");
 464                 if (data != NULL) {
 465                         const char *estr = isc_result_totext(eresult);
 466                         if (isccc_cc_definestring(data, "err", estr) == NULL)
 467                                 goto cleanup;
 468                 }
 469         }
 470
 471         if (isc_buffer_usedlength(&text) > 0) {
 472                 isccc_sexpr_t *data;
 473
 474                 data = isccc_alist_lookup(response, "_data");
 475                 if (data != NULL) {
 476                         char *str = (char *)isc_buffer_base(&text);
 477                         if (isccc_cc_definestring(data, "text", str) == NULL)
 478                                 goto cleanup;
 479                 }
 480         }
 481
 482         _ctrl = isccc_alist_lookup(response, "_ctrl");
 483         if (_ctrl == NULL ||
 484             isccc_cc_defineuint32(_ctrl, "_nonce", conn->nonce) == NULL)
 485                 goto cleanup;
 486
 487         ccregion.rstart = conn->buffer + 4;
 488         ccregion.rend = conn->buffer + sizeof(conn->buffer);
 489         result = isccc_cc_towire(response, &ccregion, &secret);
 490         if (result != ISC_R_SUCCESS)
 491                 goto cleanup;
 492         isc_buffer_init(&b, conn->buffer, 4);
 493         len = sizeof(conn->buffer) - REGION_SIZE(ccregion);
 494         isc_buffer_putuint32(&b, len - 4);
 495         r.base = conn->buffer;
 496         r.length = len;
 497
 498         result = isc_socket_send(conn->sock, &r, task, control_senddone, conn);
 499         if (result != ISC_R_SUCCESS)
 500                 goto cleanup;
 501         conn->sending = ISC_TRUE;
 502
 503         if (secret.rstart != NULL)
 504                 isc_mem_put(listener->mctx, secret.rstart,
 505                             REGION_SIZE(secret));
 506         if (request != NULL)
 507                 isccc_sexpr_free(&request);
 508         if (response != NULL)
 509                 isccc_sexpr_free(&response);
 510         return;
 511
 512  cleanup:
 513         if (secret.rstart != NULL)
 514                 isc_mem_put(listener->mctx, secret.rstart,
 515                             REGION_SIZE(secret));
 516         isc_socket_detach(&conn->sock);
 517         isccc_ccmsg_invalidate(&conn->ccmsg);
 518         conn->ccmsg_valid = ISC_FALSE;
 519         maybe_free_connection(conn);
 520         maybe_free_listener(listener);
 521         if (request != NULL)
 522                 isccc_sexpr_free(&request);
 523         if (response != NULL)
 524                 isccc_sexpr_free(&response);
 525 }
 526
 527 static void
 528 control_timeout(isc_task_t *task, isc_event_t *event) {
 529         controlconnection_t *conn = event->ev_arg;
 530
 531         UNUSED(task);
 532
 533         isc_timer_detach(&conn->timer);
 534         maybe_free_connection(conn);
 535
 536         isc_event_free(&event);
 537 }
 538
 539 static isc_result_t
 540 newconnection(controllistener_t *listener, isc_socket_t *sock) {
 541         controlconnection_t *conn;
 542         isc_interval_t interval;
 543         isc_result_t result;
 544
 545         conn = isc_mem_get(listener->mctx, sizeof(*conn));
 546         if (conn == NULL)
 547                 return (ISC_R_NOMEMORY);
 548
 549         conn->sock = sock;
 550         isccc_ccmsg_init(listener->mctx, sock, &conn->ccmsg);
 551         conn->ccmsg_valid = ISC_TRUE;
 552         conn->sending = ISC_FALSE;
 553         conn->timer = NULL;
 554         isc_interval_set(&interval, 60, 0);
 555         result = isc_timer_create(ns_g_timermgr, isc_timertype_once,
 556                                   NULL, &interval, listener->task,
 557                                   control_timeout, conn, &conn->timer);
 558         if (result != ISC_R_SUCCESS)
 559                 goto cleanup;
 560
 561         conn->listener = listener;
 562         conn->nonce = 0;
 563         ISC_LINK_INIT(conn, link);
 564
 565         result = isccc_ccmsg_readmessage(&conn->ccmsg, listener->task,
 566                                          control_recvmessage, conn);
 567         if (result != ISC_R_SUCCESS)
 568                 goto cleanup;
 569         isccc_ccmsg_setmaxsize(&conn->ccmsg, 2048);
 570
 571         ISC_LIST_APPEND(listener->connections, conn, link);
 572         return (ISC_R_SUCCESS);
 573
 574  cleanup:
 575         isccc_ccmsg_invalidate(&conn->ccmsg);
 576         if (conn->timer != NULL)
 577                 isc_timer_detach(&conn->timer);
 578         isc_mem_put(listener->mctx, conn, sizeof(*conn));
 579         return (result);
 580 }
 581
 582 static void
 583 control_newconn(isc_task_t *task, isc_event_t *event) {
 584         isc_socket_newconnev_t *nevent = (isc_socket_newconnev_t *)event;
 585         controllistener_t *listener = event->ev_arg;
 586         isc_socket_t *sock;
 587         isc_sockaddr_t peeraddr;
 588         isc_result_t result;
 589
 590         UNUSED(task);
 591
 592         listener->listening = ISC_FALSE;
 593
 594         if (nevent->result != ISC_R_SUCCESS) {
 595                 if (nevent->result == ISC_R_CANCELED) {
 596                         shutdown_listener(listener);
 597                         goto cleanup;
 598                 }
 599                 goto restart;
 600         }
 601
 602         sock = nevent->newsocket;
 603         (void)isc_socket_getpeername(sock, &peeraddr);
 604         if (!address_ok(&peeraddr, listener->acl)) {
 605                 char socktext[ISC_SOCKADDR_FORMATSIZE];
 606                 isc_sockaddr_format(&peeraddr, socktext, sizeof(socktext));
 607                 isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
 608                               NS_LOGMODULE_CONTROL, ISC_LOG_WARNING,
 609                               "rejected command channel message from %s",
 610                               socktext);
 611                 isc_socket_detach(&sock);
 612                 goto restart;
 613         }
 614
 615         result = newconnection(listener, sock);
 616         if (result != ISC_R_SUCCESS) {
 617                 char socktext[ISC_SOCKADDR_FORMATSIZE];
 618                 isc_sockaddr_format(&peeraddr, socktext, sizeof(socktext));
 619                 isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
 620                               NS_LOGMODULE_CONTROL, ISC_LOG_WARNING,
 621                               "dropped command channel from %s: %s",
 622                               socktext, isc_result_totext(result));
 623                 isc_socket_detach(&sock);
 624                 goto restart;
 625         }
 626
 627  restart:
 628         control_next(listener);
 629  cleanup:
 630         isc_event_free(&event);
 631 }
 632
 633 static void
 634 controls_shutdown(ns_controls_t *controls) {
 635         controllistener_t *listener;
 636         controllistener_t *next;
 637
 638         for (listener = ISC_LIST_HEAD(controls->listeners);
 639              listener != NULL;
 640              listener = next)
 641         {
 642                 /*
 643                  * This is asynchronous.  As listeners shut down, they will
 644                  * call their callbacks.
 645                  */
 646                 next = ISC_LIST_NEXT(listener, link);
 647                 shutdown_listener(listener);
 648         }
 649 }
 650
 651 void
 652 ns_controls_shutdown(ns_controls_t *controls) {
 653         controls_shutdown(controls);
 654         controls->shuttingdown = ISC_TRUE;
 655 }
 656
 657 static isc_result_t
 658 cfgkeylist_find(cfg_obj_t *keylist, const char *keyname, cfg_obj_t **objp) {
 659         cfg_listelt_t *element;
 660         const char *str;
 661         cfg_obj_t *obj;
 662
 663         for (element = cfg_list_first(keylist);
 664              element != NULL;
 665              element = cfg_list_next(element))
 666         {
 667                 obj = cfg_listelt_value(element);
 668                 str = cfg_obj_asstring(cfg_map_getname(obj));
 669                 if (strcasecmp(str, keyname) == 0)
 670                         break;
 671         }
 672         if (element == NULL)
 673                 return (ISC_R_NOTFOUND);
 674         obj = cfg_listelt_value(element);
 675         *objp = obj;
 676         return (ISC_R_SUCCESS);
 677 }
 678
 679 static isc_result_t
 680 controlkeylist_fromcfg(cfg_obj_t *keylist, isc_mem_t *mctx,
 681                        controlkeylist_t *keyids)
 682 {
 683         cfg_listelt_t *element;
 684         char *newstr = NULL;
 685         const char *str;
 686         cfg_obj_t *obj;
 687         controlkey_t *key = NULL;
 688
 689         for (element = cfg_list_first(keylist);
 690              element != NULL;
 691              element = cfg_list_next(element))
 692         {
 693                 obj = cfg_listelt_value(element);
 694                 str = cfg_obj_asstring(obj);
 695                 newstr = isc_mem_strdup(mctx, str);
 696                 if (newstr == NULL)
 697                         goto cleanup;
 698                 key = isc_mem_get(mctx, sizeof(*key));
 699                 if (key == NULL)
 700                         goto cleanup;
 701                 key->keyname = newstr;
 702                 key->secret.base = NULL;
 703                 key->secret.length = 0;
 704                 ISC_LINK_INIT(key, link);
 705                 ISC_LIST_APPEND(*keyids, key, link);
 706                 key = NULL;
 707                 newstr = NULL;
 708         }
 709         return (ISC_R_SUCCESS);
 710
 711  cleanup:
 712         if (newstr != NULL)
 713                 isc_mem_free(mctx, newstr);
 714         if (key != NULL)
 715                 isc_mem_put(mctx, key, sizeof(*key));
 716         free_controlkeylist(keyids, mctx);
 717         return (ISC_R_NOMEMORY);
 718 }
 719
 720 static void
 721 register_keys(cfg_obj_t *control, cfg_obj_t *keylist,
 722               controlkeylist_t *keyids, isc_mem_t *mctx, const char *socktext)
 723 {
 724         controlkey_t *keyid, *next;
 725         cfg_obj_t *keydef;
 726         char secret[1024];
 727         isc_buffer_t b;
 728         isc_result_t result;
 729
 730         /*
 731          * Find the keys corresponding to the keyids used by this listener.
 732          */
 733         for (keyid = ISC_LIST_HEAD(*keyids); keyid != NULL; keyid = next) {
 734                 next = ISC_LIST_NEXT(keyid, link);
 735
 736                 result = cfgkeylist_find(keylist, keyid->keyname, &keydef);
 737                 if (result != ISC_R_SUCCESS) {
 738                         cfg_obj_log(control, ns_g_lctx, ISC_LOG_WARNING,
 739                                     "couldn't find key '%s' for use with "
 740                                     "command channel %s",
 741                                     keyid->keyname, socktext);
 742                         ISC_LIST_UNLINK(*keyids, keyid, link);
 743                         free_controlkey(keyid, mctx);
 744                 } else {
 745                         cfg_obj_t *algobj = NULL;
 746                         cfg_obj_t *secretobj = NULL;
 747                         char *algstr = NULL;
 748                         char *secretstr = NULL;
 749
 750                         (void)cfg_map_get(keydef, "algorithm", &algobj);
 751                         (void)cfg_map_get(keydef, "secret", &secretobj);
 752                         INSIST(algobj != NULL && secretobj != NULL);
 753
 754                         algstr = cfg_obj_asstring(algobj);
 755                         secretstr = cfg_obj_asstring(secretobj);
 756
 757                         if (ns_config_getkeyalgorithm(algstr, NULL) !=
 758                             ISC_R_SUCCESS)
 759                         {
 760                                 cfg_obj_log(control, ns_g_lctx,
 761                                             ISC_LOG_WARNING,
 762                                             "unsupported algorithm '%s' in "
 763                                             "key '%s' for use with command "
 764                                             "channel %s",
 765                                             algstr, keyid->keyname, socktext);
 766                                 ISC_LIST_UNLINK(*keyids, keyid, link);
 767                                 free_controlkey(keyid, mctx);
 768                                 continue;
 769                         }
 770
 771                         isc_buffer_init(&b, secret, sizeof(secret));
 772                         result = isc_base64_decodestring(secretstr, &b);
 773
 774                         if (result != ISC_R_SUCCESS) {
 775                                 cfg_obj_log(keydef, ns_g_lctx, ISC_LOG_WARNING,
 776                                             "secret for key '%s' on "
 777                                             "command channel %s: %s",
 778                                             keyid->keyname, socktext,
 779                                             isc_result_totext(result));
 780                                 ISC_LIST_UNLINK(*keyids, keyid, link);
 781                                 free_controlkey(keyid, mctx);
 782                                 continue;
 783                         }
 784
 785                         keyid->secret.length = isc_buffer_usedlength(&b);
 786                         keyid->secret.base = isc_mem_get(mctx,
 787                                                          keyid->secret.length);
 788                         if (keyid->secret.base == NULL) {
 789                                 cfg_obj_log(keydef, ns_g_lctx, ISC_LOG_WARNING,
 790                                            "couldn't register key '%s': "
 791                                            "out of memory", keyid->keyname);
 792                                 ISC_LIST_UNLINK(*keyids, keyid, link);
 793                                 free_controlkey(keyid, mctx);
 794                                 break;
 795                         }
 796                         memcpy(keyid->secret.base, isc_buffer_base(&b),
 797                                keyid->secret.length);
 798                 }
 799         }
 800 }
 801
 802 #define CHECK(x) \
 803         do { \
 804                  result = (x); \
 805                  if (result != ISC_R_SUCCESS) \
 806                         goto cleanup; \
 807         } while (0)
 808
 809 static isc_result_t
 810 get_rndckey(isc_mem_t *mctx, controlkeylist_t *keyids) {
 811         isc_result_t result;
 812         cfg_parser_t *pctx = NULL;
 813         cfg_obj_t *config = NULL;
 814         cfg_obj_t *key = NULL;
 815         cfg_obj_t *algobj = NULL;
 816         cfg_obj_t *secretobj = NULL;
 817         char *algstr = NULL;
 818         char *secretstr = NULL;
 819         controlkey_t *keyid = NULL;
 820         char secret[1024];
 821         isc_buffer_t b;
 822
 823         CHECK(cfg_parser_create(mctx, ns_g_lctx, &pctx));
 824         CHECK(cfg_parse_file(pctx, ns_g_keyfile, &cfg_type_rndckey, &config));
 825         CHECK(cfg_map_get(config, "key", &key));
 826
 827         keyid = isc_mem_get(mctx, sizeof(*keyid));
 828         if (keyid == NULL)
 829                 CHECK(ISC_R_NOMEMORY);
 830         keyid->keyname = isc_mem_strdup(mctx,
 831                                         cfg_obj_asstring(cfg_map_getname(key)));
 832         keyid->secret.base = NULL;
 833         keyid->secret.length = 0;
 834         ISC_LINK_INIT(keyid, link);
 835         if (keyid->keyname == NULL)
 836                 CHECK(ISC_R_NOMEMORY);
 837
 838         CHECK(cfg_check_key(key, ns_g_lctx));
 839
 840         (void)cfg_map_get(key, "algorithm", &algobj);
 841         (void)cfg_map_get(key, "secret", &secretobj);
 842         INSIST(algobj != NULL && secretobj != NULL);
 843
 844         algstr = cfg_obj_asstring(algobj);
 845         secretstr = cfg_obj_asstring(secretobj);
 846
 847         if (ns_config_getkeyalgorithm(algstr, NULL) != ISC_R_SUCCESS) {
 848                 cfg_obj_log(key, ns_g_lctx,
 849                             ISC_LOG_WARNING,
 850                             "unsupported algorithm '%s' in "
 851                             "key '%s' for use with command "
 852                             "channel",
 853                             algstr, keyid->keyname);
 854                 goto cleanup;
 855         }
 856
 857         isc_buffer_init(&b, secret, sizeof(secret));
 858         result = isc_base64_decodestring(secretstr, &b);
 859
 860         if (result != ISC_R_SUCCESS) {
 861                 cfg_obj_log(key, ns_g_lctx, ISC_LOG_WARNING,
 862                             "secret for key '%s' on command channel: %s",
 863                             keyid->keyname, isc_result_totext(result));
 864                 CHECK(result);
 865         }
 866
 867         keyid->secret.length = isc_buffer_usedlength(&b);
 868         keyid->secret.base = isc_mem_get(mctx,
 869                                          keyid->secret.length);
 870         if (keyid->secret.base == NULL) {
 871                 cfg_obj_log(key, ns_g_lctx, ISC_LOG_WARNING,
 872                            "couldn't register key '%s': "
 873                            "out of memory", keyid->keyname);
 874                 CHECK(ISC_R_NOMEMORY);
 875         }
 876         memcpy(keyid->secret.base, isc_buffer_base(&b),
 877                keyid->secret.length);
 878         ISC_LIST_APPEND(*keyids, keyid, link);
 879         keyid = NULL;
 880         result = ISC_R_SUCCESS;
 881
 882   cleanup:
 883         if (keyid != NULL)
 884                 free_controlkey(keyid, mctx);
 885         if (config != NULL)
 886                 cfg_obj_destroy(pctx, &config);
 887         if (pctx != NULL)
 888                 cfg_parser_destroy(&pctx);
 889         return (result);
 890 }
 891
 892 /*
 893  * Ensures that both '*global_keylistp' and '*control_keylistp' are
 894  * valid or both are NULL.
 895  */
 896 static void
 897 get_key_info(cfg_obj_t *config, cfg_obj_t *control,
 898              cfg_obj_t **global_keylistp, cfg_obj_t **control_keylistp)
 899 {
 900         isc_result_t result;
 901         cfg_obj_t *control_keylist = NULL;
 902         cfg_obj_t *global_keylist = NULL;
 903
 904         REQUIRE(global_keylistp != NULL && *global_keylistp == NULL);
 905         REQUIRE(control_keylistp != NULL && *control_keylistp == NULL);
 906
 907         control_keylist = cfg_tuple_get(control, "keys");
 908
 909         if (!cfg_obj_isvoid(control_keylist) &&
 910             cfg_list_first(control_keylist) != NULL) {
 911                 result = cfg_map_get(config, "key", &global_keylist);
 912
 913                 if (result == ISC_R_SUCCESS) {
 914                         *global_keylistp = global_keylist;
 915                         *control_keylistp = control_keylist;
 916                 }
 917         }
 918 }
 919
 920 static void
 921 update_listener(ns_controls_t *cp,
 922                 controllistener_t **listenerp, cfg_obj_t *control,
 923                 cfg_obj_t *config, isc_sockaddr_t *addr,
 924                 ns_aclconfctx_t *aclconfctx, const char *socktext)
 925 {
 926         controllistener_t *listener;
 927         cfg_obj_t *allow;
 928         cfg_obj_t *global_keylist = NULL;
 929         cfg_obj_t *control_keylist = NULL;
 930         dns_acl_t *new_acl = NULL;
 931         controlkeylist_t keys;
 932         isc_result_t result = ISC_R_SUCCESS;
 933
 934         for (listener = ISC_LIST_HEAD(cp->listeners);
 935              listener != NULL;
 936              listener = ISC_LIST_NEXT(listener, link))
 937                 if (isc_sockaddr_equal(addr, &listener->address))
 938                         break;
 939
 940         if (listener == NULL) {
 941                 *listenerp = NULL;
 942                 return;
 943         }
 944
 945         /*
 946          * There is already a listener for this sockaddr.
 947          * Update the access list and key information.
 948          *
 949          * First try to deal with the key situation.  There are a few
 950          * possibilities:
 951          *  (a) It had an explicit keylist and still has an explicit keylist.
 952          *  (b) It had an automagic key and now has an explicit keylist.
 953          *  (c) It had an explicit keylist and now needs an automagic key.
 954          *  (d) It has an automagic key and still needs the automagic key.
 955          *
 956          * (c) and (d) are the annoying ones.  The caller needs to know
 957          * that it should use the automagic configuration for key information
 958          * in place of the named.conf configuration.
 959          *
 960          * XXXDCL There is one other hazard that has not been dealt with,
 961          * the problem that if a key change is being caused by a control
 962          * channel reload, then the response will be with the new key
 963          * and not able to be decrypted by the client.
 964          */
 965         if (control != NULL)
 966                 get_key_info(config, control, &global_keylist,
 967                              &control_keylist);
 968
 969         if (control_keylist != NULL) {
 970                 INSIST(global_keylist != NULL);
 971
 972                 ISC_LIST_INIT(keys);
 973                 result = controlkeylist_fromcfg(control_keylist,
 974                                                 listener->mctx, &keys);
 975                 if (result == ISC_R_SUCCESS) {
 976                         free_controlkeylist(&listener->keys, listener->mctx);
 977                         listener->keys = keys;
 978                         register_keys(control, global_keylist, &listener->keys,
 979                                       listener->mctx, socktext);
 980                 }
 981         } else {
 982                 free_controlkeylist(&listener->keys, listener->mctx);
 983                 result = get_rndckey(listener->mctx, &listener->keys);
 984         }
 985
 986         if (result != ISC_R_SUCCESS && global_keylist != NULL)
 987                 /*
 988                  * This message might be a little misleading since the
 989                  * "new keys" might in fact be identical to the old ones,
 990                  * but tracking whether they are identical just for the
 991                  * sake of avoiding this message would be too much trouble.
 992                  */
 993                 cfg_obj_log(control, ns_g_lctx, ISC_LOG_WARNING,
 994                             "couldn't install new keys for "
 995                             "command channel %s: %s",
 996                             socktext, isc_result_totext(result));
 997
 998
 999         /*
1000          * Now, keep the old access list unless a new one can be made.
1001          */
1002         if (control != NULL) {
1003                 allow = cfg_tuple_get(control, "allow");
1004                 result = ns_acl_fromconfig(allow, config, aclconfctx,
1005                                            listener->mctx, &new_acl);
1006         } else {
1007                 result = dns_acl_any(listener->mctx, &new_acl);
1008         }
1009
1010         if (result == ISC_R_SUCCESS) {
1011                 dns_acl_detach(&listener->acl);
1012                 dns_acl_attach(new_acl, &listener->acl);
1013                 dns_acl_detach(&new_acl);
1014         } else
1015                 /* XXXDCL say the old acl is still used? */
1016                 cfg_obj_log(control, ns_g_lctx, ISC_LOG_WARNING,
1017                             "couldn't install new acl for "
1018                             "command channel %s: %s",
1019                             socktext, isc_result_totext(result));
1020
1021         *listenerp = listener;
1022 }
1023
1024 static void
1025 add_listener(ns_controls_t *cp, controllistener_t **listenerp,
1026              cfg_obj_t *control, cfg_obj_t *config, isc_sockaddr_t *addr,
1027              ns_aclconfctx_t *aclconfctx, const char *socktext)
1028 {
1029         isc_mem_t *mctx = cp->server->mctx;
1030         controllistener_t *listener;
1031         cfg_obj_t *allow;
1032         cfg_obj_t *global_keylist = NULL;
1033         cfg_obj_t *control_keylist = NULL;
1034         dns_acl_t *new_acl = NULL;
1035         isc_result_t result = ISC_R_SUCCESS;
1036
1037         listener = isc_mem_get(mctx, sizeof(*listener));
1038         if (listener == NULL)
1039                 result = ISC_R_NOMEMORY;
1040
1041         if (result == ISC_R_SUCCESS) {
1042                 listener->controls = cp;
1043                 listener->mctx = mctx;
1044                 listener->task = cp->server->task;
1045                 listener->address = *addr;
1046                 listener->sock = NULL;
1047                 listener->listening = ISC_FALSE;
1048                 listener->exiting = ISC_FALSE;
1049                 listener->acl = NULL;
1050                 ISC_LINK_INIT(listener, link);
1051                 ISC_LIST_INIT(listener->keys);
1052                 ISC_LIST_INIT(listener->connections);
1053
1054                 /*
1055                  * Make the acl.
1056                  */
1057                 if (control != NULL) {
1058                         allow = cfg_tuple_get(control, "allow");
1059                         result = ns_acl_fromconfig(allow, config, aclconfctx,
1060                                                    mctx, &new_acl);
1061                 } else {
1062                         result = dns_acl_any(mctx, &new_acl);
1063                 }
1064         }
1065
1066         if (result == ISC_R_SUCCESS) {
1067                 dns_acl_attach(new_acl, &listener->acl);
1068                 dns_acl_detach(&new_acl);
1069
1070                 if (config != NULL)
1071                         get_key_info(config, control, &global_keylist,
1072                                      &control_keylist);
1073
1074                 if (control_keylist != NULL) {
1075                         result = controlkeylist_fromcfg(control_keylist,
1076                                                         listener->mctx,
1077                                                         &listener->keys);
1078                         if (result == ISC_R_SUCCESS)
1079                                 register_keys(control, global_keylist,
1080                                               &listener->keys,
1081                                               listener->mctx, socktext);
1082                 } else
1083                         result = get_rndckey(mctx, &listener->keys);
1084
1085                 if (result != ISC_R_SUCCESS && control != NULL)
1086                         cfg_obj_log(control, ns_g_lctx, ISC_LOG_WARNING,
1087                                     "couldn't install keys for "
1088                                     "command channel %s: %s",
1089                                     socktext, isc_result_totext(result));
1090         }
1091
1092         if (result == ISC_R_SUCCESS) {
1093                 int pf = isc_sockaddr_pf(&listener->address);
1094                 if ((pf == AF_INET && isc_net_probeipv4() != ISC_R_SUCCESS) ||
1095                     (pf == AF_INET6 && isc_net_probeipv6() != ISC_R_SUCCESS))
1096                         result = ISC_R_FAMILYNOSUPPORT;
1097         }
1098
1099         if (result == ISC_R_SUCCESS)
1100                 result = isc_socket_create(ns_g_socketmgr,
1101                                            isc_sockaddr_pf(&listener->address),
1102                                            isc_sockettype_tcp,
1103                                            &listener->sock);
1104
1105         if (result == ISC_R_SUCCESS)
1106                 result = isc_socket_bind(listener->sock,
1107                                          &listener->address);
1108
1109         if (result == ISC_R_SUCCESS)
1110                 result = control_listen(listener);
1111
1112         if (result == ISC_R_SUCCESS)
1113                 result = control_accept(listener);
1114
1115         if (result == ISC_R_SUCCESS) {
1116                 isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
1117                               NS_LOGMODULE_CONTROL, ISC_LOG_NOTICE,
1118                               "command channel listening on %s", socktext);
1119                 *listenerp = listener;
1120
1121         } else {
1122                 if (listener != NULL) {
1123                         listener->exiting = ISC_TRUE;
1124                         free_listener(listener);
1125                 }
1126
1127                 if (control != NULL)
1128                         cfg_obj_log(control, ns_g_lctx, ISC_LOG_WARNING,
1129                                     "couldn't add command channel %s: %s",
1130                                     socktext, isc_result_totext(result));
1131                 else
1132                         isc_log_write(ns_g_lctx, NS_LOGCATEGORY_GENERAL,
1133                                       NS_LOGMODULE_CONTROL, ISC_LOG_NOTICE,
1134                                       "couldn't add command channel %s: %s",
1135                                       socktext, isc_result_totext(result));
1136
1137                 *listenerp = NULL;
1138         }
1139
1140         /* XXXDCL return error results? fail hard? */
1141 }
1142
1143 isc_result_t
1144 ns_controls_configure(ns_controls_t *cp, cfg_obj_t *config,
1145                       ns_aclconfctx_t *aclconfctx)
1146 {
1147         controllistener_t *listener;
1148         controllistenerlist_t new_listeners;
1149         cfg_obj_t *controlslist = NULL;
1150         cfg_listelt_t *element, *element2;
1151         char socktext[ISC_SOCKADDR_FORMATSIZE];
1152
1153         ISC_LIST_INIT(new_listeners);
1154
1155         /*
1156          * Get the list of named.conf 'controls' statements.
1157          */
1158         (void)cfg_map_get(config, "controls", &controlslist);
1159
1160         /*
1161          * Run through the new control channel list, noting sockets that
1162          * are already being listened on and moving them to the new list.
1163          *
1164          * Identifying duplicate addr/port combinations is left to either
1165          * the underlying config code, or to the bind attempt getting an
1166          * address-in-use error.
1167          */
1168         if (controlslist != NULL) {
1169                 for (element = cfg_list_first(controlslist);
1170                      element != NULL;
1171                      element = cfg_list_next(element)) {
1172                         cfg_obj_t *controls;
1173                         cfg_obj_t *inetcontrols = NULL;
1174
1175                         controls = cfg_listelt_value(element);
1176                         (void)cfg_map_get(controls, "inet", &inetcontrols);
1177                         if (inetcontrols == NULL)
1178                                 continue;
1179
1180                         for (element2 = cfg_list_first(inetcontrols);
1181                              element2 != NULL;
1182                              element2 = cfg_list_next(element2)) {
1183                                 cfg_obj_t *control;
1184                                 cfg_obj_t *obj;
1185                                 isc_sockaddr_t *addr;
1186
1187                                 /*
1188                                  * The parser handles BIND 8 configuration file
1189                                  * syntax, so it allows unix phrases as well
1190                                  * inet phrases with no keys{} clause.
1191                                  *
1192                                  * "unix" phrases have been reported as
1193                                  * unsupported by the parser.
1194                                  */
1195                                 control = cfg_listelt_value(element2);
1196
1197                                 obj = cfg_tuple_get(control, "address");
1198                                 addr = cfg_obj_assockaddr(obj);
1199                                 if (isc_sockaddr_getport(addr) == 0)
1200                                         isc_sockaddr_setport(addr,
1201                                                              NS_CONTROL_PORT);
1202
1203                                 isc_sockaddr_format(addr, socktext,
1204                                                     sizeof(socktext));
1205
1206                                 isc_log_write(ns_g_lctx,
1207                                               NS_LOGCATEGORY_GENERAL,
1208                                               NS_LOGMODULE_CONTROL,
1209                                               ISC_LOG_DEBUG(9),
1210                                               "processing control channel %s",
1211                                               socktext);
1212
1213                                 update_listener(cp, &listener, control, config,
1214                                                 addr, aclconfctx, socktext);
1215
1216                                 if (listener != NULL)
1217                                         /*
1218                                          * Remove the listener from the old
1219                                          * list, so it won't be shut down.
1220                                          */
1221                                         ISC_LIST_UNLINK(cp->listeners,
1222                                                         listener, link);
1223                                 else
1224                                         /*
1225                                          * This is a new listener.
1226                                          */
1227                                         add_listener(cp, &listener, control,
1228                                                      config, addr, aclconfctx,
1229                                                      socktext);
1230
1231                                 if (listener != NULL)
1232                                         ISC_LIST_APPEND(new_listeners,
1233                                                         listener, link);
1234                         }
1235                 }
1236         } else {
1237                 int i;
1238
1239                 for (i = 0; i < 2; i++) {
1240                         isc_sockaddr_t addr;
1241
1242                         if (i == 0) {
1243                                 struct in_addr localhost;
1244
1245                                 if (isc_net_probeipv4() != ISC_R_SUCCESS)
1246                                         continue;
1247                                 localhost.s_addr = htonl(INADDR_LOOPBACK);
1248                                 isc_sockaddr_fromin(&addr, &localhost, 0);
1249                         } else {
1250                                 if (isc_net_probeipv6() != ISC_R_SUCCESS)
1251                                         continue;
1252                                 isc_sockaddr_fromin6(&addr,
1253                                                      &in6addr_loopback, 0);
1254                         }
1255                         isc_sockaddr_setport(&addr, NS_CONTROL_PORT);
1256
1257                         isc_sockaddr_format(&addr, socktext, sizeof(socktext));
1258
1259                         update_listener(cp, &listener, NULL, NULL,
1260                                         &addr, NULL, socktext);
1261
1262                         if (listener != NULL)
1263                                 /*
1264                                  * Remove the listener from the old
1265                                  * list, so it won't be shut down.
1266                                  */
1267                                 ISC_LIST_UNLINK(cp->listeners,
1268                                                 listener, link);
1269                         else
1270                                 /*
1271                                  * This is a new listener.
1272                                  */
1273                                 add_listener(cp, &listener, NULL, NULL,
1274                                              &addr, NULL, socktext);
1275
1276                         if (listener != NULL)
1277                                 ISC_LIST_APPEND(new_listeners,
1278                                                 listener, link);
1279                 }
1280         }
1281
1282         /*
1283          * ns_control_shutdown() will stop whatever is on the global
1284          * listeners list, which currently only has whatever sockaddrs
1285          * were in the previous configuration (if any) that do not
1286          * remain in the current configuration.
1287          */
1288         controls_shutdown(cp);
1289
1290         /*
1291          * Put all of the valid listeners on the listeners list.
1292          * Anything already on listeners in the process of shutting
1293          * down will be taken care of by listen_done().
1294          */
1295         ISC_LIST_APPENDLIST(cp->listeners, new_listeners, link);
1296         return (ISC_R_SUCCESS);
1297 }
1298
1299 isc_result_t
1300 ns_controls_create(ns_server_t *server, ns_controls_t **ctrlsp) {
1301         isc_mem_t *mctx = server->mctx;
1302         isc_result_t result;
1303         ns_controls_t *controls = isc_mem_get(mctx, sizeof(*controls));
1304
1305         if (controls == NULL)
1306                 return (ISC_R_NOMEMORY);
1307         controls->server = server;
1308         ISC_LIST_INIT(controls->listeners);
1309         controls->shuttingdown = ISC_FALSE;
1310         controls->symtab = NULL;
1311         result = isccc_cc_createsymtab(&controls->symtab);
1312         if (result != ISC_R_SUCCESS) {
1313                 isc_mem_put(server->mctx, controls, sizeof(*controls));
1314                 return (result);
1315         }
1316         *ctrlsp = controls;
1317         return (ISC_R_SUCCESS);
1318 }
1319
1320 void
1321 ns_controls_destroy(ns_controls_t **ctrlsp) {
1322         ns_controls_t *controls = *ctrlsp;
1323
1324         REQUIRE(ISC_LIST_EMPTY(controls->listeners));
1325
1326         isccc_symtab_destroy(&controls->symtab);
1327         isc_mem_put(controls->server->mctx, controls, sizeof(*controls));
1328         *ctrlsp = NULL;
1329 }