"Fossies" - the Fresh Open Source Software Archive

Member "nsd-4.3.6/remote.c" (6 Apr 2021, 75061 Bytes) of package /linux/misc/dns/nsd-4.3.6.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "remote.c" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 4.3.5_vs_4.3.6.

    1 /*
    2  * remote.c - remote control for the NSD daemon.
    3  *
    4  * Copyright (c) 2008, 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 the remote control functionality for the daemon.
   40  * The remote control can be performed using either the commandline
   41  * nsd-control tool, or a TLS capable web browser. 
   42  * The channel is secured using TLSv1, and certificates.
   43  * Both the server and the client(control tool) have their own keys.
   44  */
   45 #include "config.h"
   46 #ifdef HAVE_SSL
   47 
   48 #ifdef HAVE_OPENSSL_SSL_H
   49 #include "openssl/ssl.h"
   50 #endif
   51 #ifdef HAVE_OPENSSL_ERR_H
   52 #include <openssl/err.h>
   53 #endif
   54 #ifdef HAVE_OPENSSL_RAND_H
   55 #include <openssl/rand.h>
   56 #endif
   57 #include <ctype.h>
   58 #include <unistd.h>
   59 #include <assert.h>
   60 #include <fcntl.h>
   61 #ifndef USE_MINI_EVENT
   62 #  ifdef HAVE_EVENT_H
   63 #    include <event.h>
   64 #  else
   65 #    include <event2/event.h>
   66 #    include "event2/event_struct.h"
   67 #    include "event2/event_compat.h"
   68 #  endif
   69 #else
   70 #  include "mini_event.h"
   71 #endif
   72 #include "remote.h"
   73 #include "util.h"
   74 #include "xfrd.h"
   75 #include "xfrd-notify.h"
   76 #include "xfrd-tcp.h"
   77 #include "nsd.h"
   78 #include "options.h"
   79 #include "difffile.h"
   80 #include "ipc.h"
   81 
   82 #ifdef HAVE_SYS_TYPES_H
   83 #  include <sys/types.h>
   84 #endif
   85 #ifdef HAVE_SYS_STAT_H
   86 #  include <sys/stat.h>
   87 #endif
   88 #ifdef HAVE_NETDB_H
   89 #  include <netdb.h>
   90 #endif
   91 #ifdef HAVE_SYS_UN_H
   92 #  include <sys/un.h>
   93 #endif
   94 #ifndef AF_LOCAL
   95 #define AF_LOCAL AF_UNIX
   96 #endif
   97 
   98 /** number of seconds timeout on incoming remote control handshake */
   99 #define REMOTE_CONTROL_TCP_TIMEOUT 120
  100 
  101 /** repattern to master or slave */
  102 #define REPAT_SLAVE  1
  103 #define REPAT_MASTER 2
  104 
  105 /** if you want zero to be inhibited in stats output.
  106  * it omits zeroes for types that have no acronym and unused-rcodes */
  107 const int inhibit_zero = 1;
  108 
  109 /**
  110  * a busy control command connection, SSL state
  111  * Defined here to keep the definition private, and keep SSL out of the .h
  112  */
  113 struct rc_state {
  114     /** the next item in list */
  115     struct rc_state* next, *prev;
  116     /* if the event was added to the event_base */
  117     int event_added;
  118     /** the commpoint */
  119     struct event c;
  120     /** timeout for this state */
  121     struct timeval tval;
  122     /** in the handshake part */
  123     enum { rc_none, rc_hs_read, rc_hs_write } shake_state;
  124     /** the ssl state */
  125     SSL* ssl;
  126     /** file descriptor */
  127     int fd;
  128     /** the rc this is part of */
  129     struct daemon_remote* rc;
  130     /** stats list next item */
  131     struct rc_state* stats_next;
  132     /** stats list indicator (0 is not part of stats list, 1 is stats,
  133      * 2 is stats_noreset. */
  134     int in_stats_list;
  135 };
  136 
  137 /**
  138  * list of events for accepting connections
  139  */
  140 struct acceptlist {
  141     struct acceptlist* next;
  142     int event_added;
  143     struct event c;
  144     char* ident;
  145     struct daemon_remote* rc;
  146 };
  147 
  148 /**
  149  * The remote control state.
  150  */
  151 struct daemon_remote {
  152     /** the master process for this remote control */
  153     struct xfrd_state* xfrd;
  154     /** commpoints for accepting remote control connections */
  155     struct acceptlist* accept_list;
  156     /* if certificates are used */
  157     int use_cert;
  158     /** number of active commpoints that are handling remote control */
  159     int active;
  160     /** max active commpoints */
  161     int max_active;
  162     /** current commpoints busy; double linked, malloced */
  163     struct rc_state* busy_list;
  164     /** commpoints waiting for stats to complete (also in busy_list) */
  165     struct rc_state* stats_list;
  166     /** last time stats was reported */
  167     struct timeval stats_time, boot_time;
  168     /** the SSL context for creating new SSL streams */
  169     SSL_CTX* ctx;
  170 };
  171 
  172 /**
  173  * Connection to print to, either SSL or plain over fd
  174  */
  175 struct remote_stream {
  176     /** SSL structure, nonNULL if using SSL */
  177     SSL* ssl;
  178     /** file descriptor for plain transfer */
  179     int fd;
  180 };
  181 typedef struct remote_stream RES;
  182 
  183 /** 
  184  * Print fixed line of text over ssl connection in blocking mode
  185  * @param res: print to
  186  * @param text: the text.
  187  * @return false on connection failure.
  188  */
  189 static int ssl_print_text(RES* res, const char* text);
  190 
  191 /** 
  192  * printf style printing to the ssl connection
  193  * @param res: the RES connection to print to. Blocking.
  194  * @param format: printf style format string.
  195  * @return success or false on a network failure.
  196  */
  197 static int ssl_printf(RES* res, const char* format, ...)
  198         ATTR_FORMAT(printf, 2, 3);
  199 
  200 /**
  201  * Read until \n is encountered
  202  * If stream signals EOF, the string up to then is returned (without \n).
  203  * @param res: the RES connection to read from. blocking.
  204  * @param buf: buffer to read to.
  205  * @param max: size of buffer.
  206  * @return false on connection failure.
  207  */
  208 static int ssl_read_line(RES* res, char* buf, size_t max);
  209 
  210 /** perform the accept of a new remote control connection */
  211 static void
  212 remote_accept_callback(int fd, short event, void* arg);
  213 
  214 /** perform remote control */
  215 static void
  216 remote_control_callback(int fd, short event, void* arg);
  217 
  218 
  219 /** ---- end of private defines ---- **/
  220 
  221 
  222 /** log ssl crypto err */
  223 static void
  224 log_crypto_err(const char* str)
  225 {
  226     /* error:[error code]:[library name]:[function name]:[reason string] */
  227     char buf[128];
  228     unsigned long e;
  229     ERR_error_string_n(ERR_get_error(), buf, sizeof(buf));
  230     log_msg(LOG_ERR, "%s crypto %s", str, buf);
  231     while( (e=ERR_get_error()) ) {
  232         ERR_error_string_n(e, buf, sizeof(buf));
  233         log_msg(LOG_ERR, "and additionally crypto %s", buf);
  234     }
  235 }
  236 
  237 #ifdef BIND8_STATS
  238 /** subtract timers and the values do not overflow or become negative */
  239 static void
  240 timeval_subtract(struct timeval* d, const struct timeval* end, 
  241     const struct timeval* start)
  242 {
  243 #ifndef S_SPLINT_S
  244     time_t end_usec = end->tv_usec;
  245     d->tv_sec = end->tv_sec - start->tv_sec;
  246     if(end_usec < start->tv_usec) {
  247         end_usec += 1000000;
  248         d->tv_sec--;
  249     }
  250     d->tv_usec = end_usec - start->tv_usec;
  251 #endif
  252 }
  253 #endif /* BIND8_STATS */
  254 
  255 static int
  256 remote_setup_ctx(struct daemon_remote* rc, struct nsd_options* cfg)
  257 {
  258     char* s_cert = cfg->server_cert_file;
  259     char* s_key = cfg->server_key_file;
  260     rc->ctx = server_tls_ctx_setup(s_key, s_cert, s_cert);
  261     if(!rc->ctx) {
  262         log_msg(LOG_ERR, "could not setup remote control TLS context");
  263         return 0;
  264     }
  265     return 1;
  266 }
  267 
  268 struct daemon_remote*
  269 daemon_remote_create(struct nsd_options* cfg)
  270 {
  271     struct daemon_remote* rc = (struct daemon_remote*)xalloc_zero(
  272         sizeof(*rc));
  273     rc->max_active = 10;
  274     assert(cfg->control_enable);
  275 
  276     if(options_remote_is_address(cfg)) {
  277         if(!remote_setup_ctx(rc, cfg)) {
  278             daemon_remote_delete(rc);
  279             return NULL;
  280         }
  281         rc->use_cert = 1;
  282     } else {
  283         struct ip_address_option* o;
  284         rc->ctx = NULL;
  285         rc->use_cert = 0;
  286         for(o = cfg->control_interface; o; o = o->next) {
  287             if(o->address && o->address[0] != '/')
  288                 log_msg(LOG_WARNING, "control-interface %s is not using TLS, but plain transfer, because first control-interface in config file is a local socket (starts with a /).", o->address);
  289         }
  290     }
  291 
  292     /* and try to open the ports */
  293     if(!daemon_remote_open_ports(rc, cfg)) {
  294         log_msg(LOG_ERR, "could not open remote control port");
  295         daemon_remote_delete(rc);
  296         return NULL;
  297     }
  298 
  299     if(gettimeofday(&rc->boot_time, NULL) == -1)
  300         log_msg(LOG_ERR, "gettimeofday: %s", strerror(errno));
  301     rc->stats_time = rc->boot_time;
  302 
  303     return rc;
  304 }
  305 
  306 void daemon_remote_close(struct daemon_remote* rc)
  307 {
  308     struct rc_state* p, *np;
  309     struct acceptlist* h, *nh;
  310     if(!rc) return;
  311 
  312     /* close listen sockets */
  313     h = rc->accept_list;
  314     while(h) {
  315         nh = h->next;
  316         if(h->event_added)
  317             event_del(&h->c);
  318         close(h->c.ev_fd);
  319         free(h->ident);
  320         free(h);
  321         h = nh;
  322     }
  323     rc->accept_list = NULL;
  324 
  325     /* close busy connection sockets */
  326     p = rc->busy_list;
  327     while(p) {
  328         np = p->next;
  329         if(p->event_added)
  330             event_del(&p->c);
  331         if(p->ssl)
  332             SSL_free(p->ssl);
  333         close(p->c.ev_fd);
  334         free(p);
  335         p = np;
  336     }
  337     rc->busy_list = NULL;
  338     rc->active = 0;
  339 }
  340 
  341 void daemon_remote_delete(struct daemon_remote* rc)
  342 {
  343     if(!rc) return;
  344     daemon_remote_close(rc);
  345     if(rc->ctx) {
  346         SSL_CTX_free(rc->ctx);
  347     }
  348     free(rc);
  349 }
  350 
  351 static int
  352 create_tcp_accept_sock(struct addrinfo* addr, int* noproto)
  353 {
  354 #if defined(SO_REUSEADDR) || (defined(INET6) && (defined(IPV6_V6ONLY) || defined(IPV6_USE_MIN_MTU) || defined(IPV6_MTU)))
  355     int on = 1;
  356 #endif
  357     int s;
  358     *noproto = 0;
  359     if ((s = socket(addr->ai_family, addr->ai_socktype, 0)) == -1) {
  360 #if defined(INET6)
  361         if (addr->ai_family == AF_INET6 &&
  362             errno == EAFNOSUPPORT) {
  363             *noproto = 1;
  364             log_msg(LOG_WARNING, "fallback to TCP4, no IPv6: not supported");
  365             return -1;
  366         }
  367 #endif /* INET6 */
  368         log_msg(LOG_ERR, "can't create a socket: %s", strerror(errno));
  369         return -1;
  370     }
  371 #ifdef  SO_REUSEADDR
  372     if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {
  373         log_msg(LOG_ERR, "setsockopt(..., SO_REUSEADDR, ...) failed: %s", strerror(errno));
  374     }
  375 #endif /* SO_REUSEADDR */
  376 #if defined(INET6) && defined(IPV6_V6ONLY)
  377     if (addr->ai_family == AF_INET6 &&
  378         setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on)) < 0)
  379     {
  380         log_msg(LOG_ERR, "setsockopt(..., IPV6_V6ONLY, ...) failed: %s", strerror(errno));
  381         close(s);
  382         return -1;
  383     }
  384 #endif
  385     /* set it nonblocking */
  386     /* (StevensUNP p463), if tcp listening socket is blocking, then
  387        it may block in accept, even if select() says readable. */
  388     if (fcntl(s, F_SETFL, O_NONBLOCK) == -1) {
  389         log_msg(LOG_ERR, "cannot fcntl tcp: %s", strerror(errno));
  390     }
  391     /* Bind it... */
  392     if (bind(s, (struct sockaddr *)addr->ai_addr, addr->ai_addrlen) != 0) {
  393         log_msg(LOG_ERR, "can't bind tcp socket: %s", strerror(errno));
  394         close(s);
  395         return -1;
  396     }
  397     /* Listen to it... */
  398     if (listen(s, TCP_BACKLOG_REMOTE) == -1) {
  399         log_msg(LOG_ERR, "can't listen: %s", strerror(errno));
  400         close(s);
  401         return -1;
  402     }
  403     return s;
  404 }
  405 
  406 /**
  407  * Add and open a new control port
  408  * @param rc: rc with result list.
  409  * @param ip: ip str
  410  * @param nr: port nr
  411  * @param noproto_is_err: if lack of protocol support is an error.
  412  * @return false on failure.
  413  */
  414 static int
  415 add_open(struct daemon_remote* rc, struct nsd_options* cfg, const char* ip,
  416     int nr, int noproto_is_err)
  417 {
  418     struct addrinfo hints;
  419     struct addrinfo* res;
  420     struct acceptlist* hl;
  421     int noproto = 0;
  422     int fd, r;
  423     char port[15];
  424     snprintf(port, sizeof(port), "%d", nr);
  425     port[sizeof(port)-1]=0;
  426     memset(&hints, 0, sizeof(hints));
  427     assert(ip);
  428 
  429     if(ip[0] == '/') {
  430         /* This looks like a local socket */
  431         fd = create_local_accept_sock(ip, &noproto);
  432         /*
  433          * Change socket ownership and permissions so users other
  434          * than root can access it provided they are in the same
  435          * group as the user we run as.
  436          */
  437         if(fd != -1) {
  438 #ifdef HAVE_CHOWN
  439             if (cfg->username && cfg->username[0] &&
  440                 nsd.uid != (uid_t)-1) {
  441                 if(chown(ip, nsd.uid, nsd.gid) == -1)
  442                     VERBOSITY(2, (LOG_INFO, "cannot chown %u.%u %s: %s",
  443                       (unsigned)nsd.uid, (unsigned)nsd.gid,
  444                       ip, strerror(errno)));
  445             }
  446             if(chmod(ip, (mode_t)(S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP)) == -1) {
  447                 VERBOSITY(3, (LOG_INFO, "cannot chmod control socket %s: %s", ip, strerror(errno)));
  448             }
  449 #else
  450             (void)cfg;
  451 #endif
  452         }
  453     } else {
  454         hints.ai_socktype = SOCK_STREAM;
  455         hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
  456         /* if we had no interface ip name, "default" is what we
  457          * would do getaddrinfo for. */
  458         if((r = getaddrinfo(ip, port, &hints, &res)) != 0 || !res) {
  459             log_msg(LOG_ERR, "control interface %s:%s getaddrinfo: %s %s",
  460                 ip, port, gai_strerror(r),
  461 #ifdef EAI_SYSTEM
  462                 r==EAI_SYSTEM?(char*)strerror(errno):""
  463 #else
  464                 ""
  465 #endif
  466                 );
  467             return 0;
  468         }
  469 
  470         /* open fd */
  471         fd = create_tcp_accept_sock(res, &noproto);
  472         freeaddrinfo(res);
  473     }
  474 
  475     if(fd == -1 && noproto) {
  476         if(!noproto_is_err)
  477             return 1; /* return success, but do nothing */
  478         log_msg(LOG_ERR, "cannot open control interface %s %d : "
  479             "protocol not supported", ip, nr);
  480         return 0;
  481     }
  482     if(fd == -1) {
  483         log_msg(LOG_ERR, "cannot open control interface %s %d", ip, nr);
  484         return 0;
  485     }
  486 
  487     /* alloc */
  488     hl = (struct acceptlist*)xalloc_zero(sizeof(*hl));
  489     hl->rc = rc;
  490     hl->ident = strdup(ip);
  491     if(!hl->ident) {
  492         log_msg(LOG_ERR, "malloc failure");
  493         close(fd);
  494         free(hl);
  495         return 0;
  496     }
  497     hl->next = rc->accept_list;
  498     rc->accept_list = hl;
  499 
  500     hl->c.ev_fd = fd;
  501     hl->event_added = 0;
  502     return 1;
  503 }
  504 
  505 int
  506 daemon_remote_open_ports(struct daemon_remote* rc, struct nsd_options* cfg)
  507 {
  508     assert(cfg->control_enable && cfg->control_port);
  509     if(cfg->control_interface) {
  510         ip_address_option_type* p;
  511         for(p = cfg->control_interface; p; p = p->next) {
  512             if(!add_open(rc, cfg, p->address, cfg->control_port, 1)) {
  513                 return 0;
  514             }
  515         }
  516     } else {
  517         /* defaults */
  518         if(cfg->do_ip6 && !add_open(rc, cfg, "::1", cfg->control_port, 0)) {
  519             return 0;
  520         }
  521         if(cfg->do_ip4 &&
  522             !add_open(rc, cfg, "127.0.0.1", cfg->control_port, 1)) {
  523             return 0;
  524         }
  525     }
  526     return 1;
  527 }
  528 
  529 void
  530 daemon_remote_attach(struct daemon_remote* rc, struct xfrd_state* xfrd)
  531 {
  532     int fd;
  533     struct acceptlist* p;
  534     if(!rc) return;
  535     rc->xfrd = xfrd;
  536     for(p = rc->accept_list; p; p = p->next) {
  537         /* add event */
  538         fd = p->c.ev_fd;
  539         memset(&p->c, 0, sizeof(p->c));
  540         event_set(&p->c, fd, EV_PERSIST|EV_READ, remote_accept_callback,
  541             p);
  542         if(event_base_set(xfrd->event_base, &p->c) != 0)
  543             log_msg(LOG_ERR, "remote: cannot set event_base");
  544         if(event_add(&p->c, NULL) != 0)
  545             log_msg(LOG_ERR, "remote: cannot add event");
  546         p->event_added = 1;
  547     }
  548 }
  549 
  550 static void
  551 remote_accept_callback(int fd, short event, void* arg)
  552 {
  553     struct acceptlist *hl = (struct acceptlist*)arg;
  554     struct daemon_remote *rc = hl->rc;
  555 #ifdef INET6
  556     struct sockaddr_storage addr;
  557 #else
  558     struct sockaddr_in addr;
  559 #endif
  560     socklen_t addrlen;
  561     int newfd;
  562     struct rc_state* n;
  563 
  564     if (!(event & EV_READ)) {
  565         return;
  566     }
  567 
  568     /* perform the accept */
  569     addrlen = sizeof(addr);
  570 #ifndef HAVE_ACCEPT4
  571     newfd = accept(fd, (struct sockaddr*)&addr, &addrlen);
  572 #else
  573     newfd = accept4(fd, (struct sockaddr*)&addr, &addrlen, SOCK_NONBLOCK);
  574 #endif
  575     if(newfd == -1) {
  576         if (    errno != EINTR
  577             && errno != EWOULDBLOCK
  578 #ifdef ECONNABORTED
  579             && errno != ECONNABORTED
  580 #endif /* ECONNABORTED */
  581 #ifdef EPROTO
  582             && errno != EPROTO
  583 #endif /* EPROTO */
  584             ) {
  585             log_msg(LOG_ERR, "accept failed: %s", strerror(errno));
  586         }
  587         return;
  588     }
  589 
  590     /* create new commpoint unless we are servicing already */
  591     if(rc->active >= rc->max_active) {
  592         log_msg(LOG_WARNING, "drop incoming remote control: "
  593             "too many connections");
  594     close_exit:
  595         close(newfd);
  596         return;
  597     }
  598 
  599 #ifndef HAVE_ACCEPT4
  600     if (fcntl(newfd, F_SETFL, O_NONBLOCK) == -1) {
  601         log_msg(LOG_ERR, "fcntl failed: %s", strerror(errno));
  602         goto close_exit;
  603     }
  604 #endif
  605 
  606     /* setup state to service the remote control command */
  607     n = (struct rc_state*)calloc(1, sizeof(*n));
  608     if(!n) {
  609         log_msg(LOG_ERR, "out of memory");
  610         goto close_exit;
  611     }
  612 
  613     n->tval.tv_sec = REMOTE_CONTROL_TCP_TIMEOUT; 
  614     n->tval.tv_usec = 0L;
  615     n->fd = newfd;
  616 
  617     memset(&n->c, 0, sizeof(n->c));
  618     event_set(&n->c, newfd, EV_PERSIST|EV_TIMEOUT|EV_READ,
  619         remote_control_callback, n);
  620     if(event_base_set(xfrd->event_base, &n->c) != 0) {
  621         log_msg(LOG_ERR, "remote_accept: cannot set event_base");
  622         free(n);
  623         goto close_exit;
  624     }
  625     if(event_add(&n->c, &n->tval) != 0) {
  626         log_msg(LOG_ERR, "remote_accept: cannot add event");
  627         free(n);
  628         goto close_exit;
  629     }
  630     n->event_added = 1;
  631 
  632     if(2 <= verbosity) {
  633         if(hl->ident && hl->ident[0] == '/') {
  634             VERBOSITY(2, (LOG_INFO, "new control connection from %s", hl->ident));
  635         } else {
  636             char s[128];
  637             addr2str(&addr, s, sizeof(s));
  638             VERBOSITY(2, (LOG_INFO, "new control connection from %s", s));
  639         }
  640     }
  641 
  642     if(rc->ctx) {
  643         n->shake_state = rc_hs_read;
  644         n->ssl = SSL_new(rc->ctx);
  645         if(!n->ssl) {
  646             log_crypto_err("could not SSL_new");
  647             event_del(&n->c);
  648             free(n);
  649             goto close_exit;
  650         }
  651         SSL_set_accept_state(n->ssl);
  652         (void)SSL_set_mode(n->ssl, SSL_MODE_AUTO_RETRY);
  653         if(!SSL_set_fd(n->ssl, newfd)) {
  654             log_crypto_err("could not SSL_set_fd");
  655             event_del(&n->c);
  656             SSL_free(n->ssl);
  657             free(n);
  658             goto close_exit;
  659         }
  660     } else {
  661         n->ssl = NULL;
  662     }
  663 
  664     n->rc = rc;
  665     n->stats_next = NULL;
  666     n->in_stats_list = 0;
  667     n->prev = NULL;
  668     n->next = rc->busy_list;
  669     if(n->next) n->next->prev = n;
  670     rc->busy_list = n;
  671     rc->active ++;
  672 
  673     /* perform the first nonblocking read already, for windows, 
  674      * so it can return wouldblock. could be faster too. */
  675     remote_control_callback(newfd, EV_READ, n);
  676 }
  677 
  678 /** delete from list */
  679 static void
  680 state_list_remove_elem(struct rc_state** list, struct rc_state* todel)
  681 {
  682     if(todel->prev) todel->prev->next = todel->next;
  683     else    *list = todel->next;
  684     if(todel->next) todel->next->prev = todel->prev;
  685 }
  686 
  687 /** delete from stats list */
  688 static void
  689 stats_list_remove_elem(struct rc_state** list, struct rc_state* todel)
  690 {
  691     struct rc_state* prev = NULL;
  692     struct rc_state* n = *list;
  693     while(n) {
  694         /* delete this one? */
  695         if(n == todel) {
  696             if(prev) prev->next = n->next;
  697             else    (*list) = n->next;
  698             /* go on and delete further elements */
  699             /* prev = prev; */
  700             n = n->next;
  701             continue;
  702         }
  703 
  704         /* go to the next element */
  705         prev = n;
  706         n = n->next;
  707     }
  708 }
  709 
  710 /** decrease active count and remove commpoint from busy list */
  711 static void
  712 clean_point(struct daemon_remote* rc, struct rc_state* s)
  713 {
  714     if(s->in_stats_list)
  715         stats_list_remove_elem(&rc->stats_list, s);
  716     state_list_remove_elem(&rc->busy_list, s);
  717     rc->active --;
  718     if(s->event_added)
  719         event_del(&s->c);
  720     if(s->ssl) {
  721         SSL_shutdown(s->ssl);
  722         SSL_free(s->ssl);
  723     }
  724     close(s->c.ev_fd);
  725     free(s);
  726 }
  727 
  728 static int
  729 ssl_print_text(RES* res, const char* text)
  730 {
  731     int r;
  732     if(!res) 
  733         return 0;
  734     if(res->ssl) {
  735         ERR_clear_error();
  736         if((r=SSL_write(res->ssl, text, (int)strlen(text))) <= 0) {
  737             if(SSL_get_error(res->ssl, r) == SSL_ERROR_ZERO_RETURN) {
  738                 VERBOSITY(2, (LOG_WARNING, "in SSL_write, peer "
  739                     "closed connection"));
  740                 return 0;
  741             }
  742             log_crypto_err("could not SSL_write");
  743             return 0;
  744         }
  745     } else {
  746         if(write_socket(res->fd, text, strlen(text)) <= 0) {
  747             log_msg(LOG_ERR, "could not write: %s",
  748                 strerror(errno));
  749             return 0;
  750         }
  751     }
  752     return 1;
  753 }
  754 
  755 /** print text over the ssl connection */
  756 static int
  757 ssl_print_vmsg(RES* ssl, const char* format, va_list args)
  758 {
  759     char msg[1024];
  760     vsnprintf(msg, sizeof(msg), format, args);
  761     return ssl_print_text(ssl, msg);
  762 }
  763 
  764 /** printf style printing to the ssl connection */
  765 static int
  766 ssl_printf(RES* ssl, const char* format, ...)
  767 {
  768     va_list args;
  769     int ret;
  770     va_start(args, format);
  771     ret = ssl_print_vmsg(ssl, format, args);
  772     va_end(args);
  773     return ret;
  774 }
  775 
  776 static int
  777 ssl_read_line(RES* res, char* buf, size_t max)
  778 {
  779     int r;
  780     size_t len = 0;
  781     if(!res)
  782         return 0;
  783     while(len < max) {
  784         buf[len] = 0; /* terminate for safety and please checkers */
  785         /* this byte is written if we read a byte from the input */
  786         if(res->ssl) {
  787             ERR_clear_error();
  788             if((r=SSL_read(res->ssl, buf+len, 1)) <= 0) {
  789                 if(SSL_get_error(res->ssl, r) == SSL_ERROR_ZERO_RETURN) {
  790                     buf[len] = 0;
  791                     return 1;
  792                 }
  793                 log_crypto_err("could not SSL_read");
  794                 return 0;
  795             }
  796         } else {
  797             while(1) {
  798                 ssize_t rr = read(res->fd, buf+len, 1);
  799                 if(rr <= 0) {
  800                     if(rr == 0) {
  801                         buf[len] = 0;
  802                         return 1;
  803                     }
  804                     if(errno == EINTR || errno == EAGAIN)
  805                         continue;
  806                     log_msg(LOG_ERR, "could not read: %s",
  807                         strerror(errno));
  808                     return 0;
  809                 }
  810                 break;
  811             }
  812         }
  813         if(buf[len] == '\n') {
  814             /* return string without \n */
  815             buf[len] = 0;
  816             return 1;
  817         }
  818         len++;
  819     }
  820     buf[max-1] = 0;
  821     log_msg(LOG_ERR, "control line too long (%d): %s", (int)max, buf);
  822     return 0;
  823 }
  824 
  825 /** skip whitespace, return new pointer into string */
  826 static char*
  827 skipwhite(char* str)
  828 {
  829     /* EOS \0 is not a space */
  830     while( isspace((unsigned char)*str) ) 
  831         str++;
  832     return str;
  833 }
  834 
  835 /** send the OK to the control client */
  836 static void
  837 send_ok(RES* ssl)
  838 {
  839     (void)ssl_printf(ssl, "ok\n");
  840 }
  841 
  842 /** get zone argument (if any) or NULL, false on error */
  843 static int
  844 get_zone_arg(RES* ssl, xfrd_state_type* xfrd, char* arg,
  845     struct zone_options** zo)
  846 {
  847     const dname_type* dname;
  848     if(!arg[0]) {
  849         /* no argument present, return NULL */
  850         *zo = NULL;
  851         return 1;
  852     }
  853     dname = dname_parse(xfrd->region, arg);
  854     if(!dname) {
  855         (void)ssl_printf(ssl, "error cannot parse zone name '%s'\n", arg);
  856         *zo = NULL;
  857         return 0;
  858     }
  859     *zo = zone_options_find(xfrd->nsd->options, dname);
  860     region_recycle(xfrd->region, (void*)dname, dname_total_size(dname));
  861     if(!*zo) {
  862         (void)ssl_printf(ssl, "error zone %s not configured\n", arg);
  863         return 0;
  864     }
  865     return 1;
  866 }
  867 
  868 /** do the stop command */
  869 static void
  870 do_stop(RES* ssl, xfrd_state_type* xfrd)
  871 {
  872     xfrd->need_to_send_shutdown = 1;
  873 
  874     if(!(xfrd->ipc_handler_flags&EV_WRITE)) {
  875         ipc_xfrd_set_listening(xfrd, EV_PERSIST|EV_READ|EV_WRITE);
  876     }
  877 
  878     send_ok(ssl);
  879 }
  880 
  881 /** do the log_reopen command, it only needs reload_now */
  882 static void
  883 do_log_reopen(RES* ssl, xfrd_state_type* xfrd)
  884 {
  885     xfrd_set_reload_now(xfrd);
  886     send_ok(ssl);
  887 }
  888 
  889 /** do the reload command */
  890 static void
  891 do_reload(RES* ssl, xfrd_state_type* xfrd, char* arg)
  892 {
  893     struct zone_options* zo;
  894     if(!get_zone_arg(ssl, xfrd, arg, &zo))
  895         return;
  896     task_new_check_zonefiles(xfrd->nsd->task[xfrd->nsd->mytask],
  897         xfrd->last_task, zo?(const dname_type*)zo->node.key:NULL);
  898     xfrd_set_reload_now(xfrd);
  899     send_ok(ssl);
  900 }
  901 
  902 /** do the write command */
  903 static void
  904 do_write(RES* ssl, xfrd_state_type* xfrd, char* arg)
  905 {
  906     struct zone_options* zo;
  907     if(!get_zone_arg(ssl, xfrd, arg, &zo))
  908         return;
  909     task_new_write_zonefiles(xfrd->nsd->task[xfrd->nsd->mytask],
  910         xfrd->last_task, zo?(const dname_type*)zo->node.key:NULL);
  911     xfrd_set_reload_now(xfrd);
  912     send_ok(ssl);
  913 }
  914 
  915 /** do the notify command */
  916 static void
  917 do_notify(RES* ssl, xfrd_state_type* xfrd, char* arg)
  918 {
  919     struct zone_options* zo;
  920     if(!get_zone_arg(ssl, xfrd, arg, &zo))
  921         return;
  922     if(zo) {
  923         struct notify_zone* n = (struct notify_zone*)rbtree_search(
  924             xfrd->notify_zones, (const dname_type*)zo->node.key);
  925         if(n) {
  926             xfrd_notify_start(n, xfrd);
  927             send_ok(ssl);
  928         } else {
  929             (void)ssl_printf(ssl, "error zone does not have notify\n");
  930         }
  931     } else {
  932         struct notify_zone* n;
  933         RBTREE_FOR(n, struct notify_zone*, xfrd->notify_zones) {
  934             xfrd_notify_start(n, xfrd);
  935         }
  936         send_ok(ssl);
  937     }
  938 }
  939 
  940 /** do the transfer command */
  941 static void
  942 do_transfer(RES* ssl, xfrd_state_type* xfrd, char* arg)
  943 {
  944     struct zone_options* zo;
  945     xfrd_zone_type* zone;
  946     if(!get_zone_arg(ssl, xfrd, arg, &zo))
  947         return;
  948     if(zo) {
  949         zone = (xfrd_zone_type*)rbtree_search(xfrd->zones, (const
  950             dname_type*)zo->node.key);
  951         if(zone) {
  952             xfrd_handle_notify_and_start_xfr(zone, NULL);
  953             send_ok(ssl);
  954         } else {
  955             (void)ssl_printf(ssl, "error zone not slave\n");
  956         }
  957     } else {
  958         RBTREE_FOR(zone, xfrd_zone_type*, xfrd->zones) {
  959             xfrd_handle_notify_and_start_xfr(zone, NULL);
  960         }
  961         (void)ssl_printf(ssl, "ok, %lu zones\n", (unsigned long)xfrd->zones->count);
  962     }
  963 }
  964 
  965 /** force transfer a zone */
  966 static void
  967 force_transfer_zone(xfrd_zone_type* zone)
  968 {
  969     /* if in TCP transaction, stop it immediately. */
  970     if(zone->tcp_conn != -1)
  971         xfrd_tcp_release(xfrd->tcp_set, zone);
  972     else if(zone->zone_handler.ev_fd != -1)
  973         xfrd_udp_release(zone);
  974     /* pretend we not longer have it and force any
  975      * zone to be downloaded (even same serial, w AXFR) */
  976     zone->soa_disk_acquired = 0;
  977     zone->soa_nsd_acquired = 0;
  978     xfrd_handle_notify_and_start_xfr(zone, NULL);
  979 }
  980 
  981 /** do the force transfer command */
  982 static void
  983 do_force_transfer(RES* ssl, xfrd_state_type* xfrd, char* arg)
  984 {
  985     struct zone_options* zo;
  986     xfrd_zone_type* zone;
  987     if(!get_zone_arg(ssl, xfrd, arg, &zo))
  988         return;
  989     if(zo) {
  990         zone = (xfrd_zone_type*)rbtree_search(xfrd->zones, (const
  991             dname_type*)zo->node.key);
  992         if(zone) {
  993             force_transfer_zone(zone);
  994             send_ok(ssl);
  995         } else {
  996             (void)ssl_printf(ssl, "error zone not slave\n");
  997         }
  998     } else {
  999         RBTREE_FOR(zone, xfrd_zone_type*, xfrd->zones) {
 1000             force_transfer_zone(zone);
 1001         }
 1002         (void)ssl_printf(ssl, "ok, %lu zones\n", (unsigned long)xfrd->zones->count);
 1003     }
 1004 }
 1005 
 1006 static int
 1007 print_soa_status(RES* ssl, const char* str, xfrd_soa_type* soa, time_t acq)
 1008 {
 1009     if(acq) {
 1010         if(!ssl_printf(ssl, "   %s: \"%u since %s\"\n", str,
 1011             (unsigned)ntohl(soa->serial), xfrd_pretty_time(acq)))
 1012             return 0;
 1013     } else {
 1014         if(!ssl_printf(ssl, "   %s: none\n", str))
 1015             return 0;
 1016     }
 1017     return 1;
 1018 }
 1019 
 1020 /** print zonestatus for one domain */
 1021 static int
 1022 print_zonestatus(RES* ssl, xfrd_state_type* xfrd, struct zone_options* zo)
 1023 {
 1024     xfrd_zone_type* xz = (xfrd_zone_type*)rbtree_search(xfrd->zones,
 1025         (const dname_type*)zo->node.key);
 1026     struct notify_zone* nz = (struct notify_zone*)rbtree_search(
 1027         xfrd->notify_zones, (const dname_type*)zo->node.key);
 1028     if(!ssl_printf(ssl, "zone:  %s\n", zo->name))
 1029         return 0;
 1030     if(!zo->part_of_config) {
 1031         if(!ssl_printf(ssl, "   pattern: %s\n", zo->pattern->pname))
 1032             return 0;
 1033     }
 1034     if(nz) {
 1035         if(nz->is_waiting) {
 1036             if(!ssl_printf(ssl, "   notify: \"waiting-for-fd\"\n"))
 1037                 return 0;
 1038         } else if(nz->notify_send_enable || nz->notify_send6_enable) {
 1039             int i;
 1040             if(!ssl_printf(ssl, "   notify: \"send"))
 1041                 return 0;
 1042             for(i=0; i<NOTIFY_CONCURRENT_MAX; i++) {
 1043                 if(!nz->pkts[i].dest) continue;
 1044                 if(!ssl_printf(ssl, " %s",
 1045                     nz->pkts[i].dest->ip_address_spec))
 1046                     return 0;
 1047             }
 1048             if(!ssl_printf(ssl, " with serial %u\"\n",
 1049                 (unsigned)ntohl(nz->current_soa->serial)))
 1050                 return 0;
 1051         }
 1052     }
 1053     if(!xz) {
 1054         if(!ssl_printf(ssl, "   state: master\n"))
 1055             return 0;
 1056         return 1;
 1057     }
 1058     if(!ssl_printf(ssl, "   state: %s\n",
 1059         (xz->state == xfrd_zone_ok)?"ok":(
 1060         (xz->state == xfrd_zone_expired)?"expired":"refreshing")))
 1061         return 0;
 1062     if(!print_soa_status(ssl, "served-serial", &xz->soa_nsd,
 1063         xz->soa_nsd_acquired))
 1064         return 0;
 1065     if(!print_soa_status(ssl, "commit-serial", &xz->soa_disk,
 1066         xz->soa_disk_acquired))
 1067         return 0;
 1068     if(xz->round_num != -1) {
 1069         if(!print_soa_status(ssl, "notified-serial", &xz->soa_notified,
 1070             xz->soa_notified_acquired))
 1071             return 0;
 1072     } else if(xz->event_added) {
 1073         if(!ssl_printf(ssl, "\twait: \"%lu sec between attempts\"\n",
 1074             (unsigned long)xz->timeout.tv_sec))
 1075             return 0;
 1076     }
 1077 
 1078     /* UDP */
 1079     if(xz->udp_waiting) {
 1080         if(!ssl_printf(ssl, "   transfer: \"waiting-for-UDP-fd\"\n"))
 1081             return 0;
 1082     } else if(xz->zone_handler.ev_fd != -1 && xz->tcp_conn == -1) {
 1083         if(!ssl_printf(ssl, "   transfer: \"sent UDP to %s\"\n",
 1084             xz->master->ip_address_spec))
 1085             return 0;
 1086     }
 1087 
 1088     /* TCP */
 1089     if(xz->tcp_waiting) {
 1090         if(!ssl_printf(ssl, "   transfer: \"waiting-for-TCP-fd\"\n"))
 1091             return 0;
 1092     } else if(xz->tcp_conn != -1) {
 1093         if(!ssl_printf(ssl, "   transfer: \"TCP connected to %s\"\n",
 1094             xz->master->ip_address_spec))
 1095             return 0;
 1096     }
 1097 
 1098     return 1;
 1099 }
 1100 
 1101 /** do the zonestatus command */
 1102 static void
 1103 do_zonestatus(RES* ssl, xfrd_state_type* xfrd, char* arg)
 1104 {
 1105     struct zone_options* zo;
 1106     if(!get_zone_arg(ssl, xfrd, arg, &zo))
 1107         return;
 1108     if(zo) (void)print_zonestatus(ssl, xfrd, zo);
 1109     else {
 1110         RBTREE_FOR(zo, struct zone_options*,
 1111             xfrd->nsd->options->zone_options) {
 1112             if(!print_zonestatus(ssl, xfrd, zo))
 1113                 return;
 1114         }
 1115     }
 1116 }
 1117 
 1118 /** do the verbosity command */
 1119 static void
 1120 do_verbosity(RES* ssl, char* str)
 1121 {
 1122     int val = atoi(str);
 1123     if(strcmp(str, "") == 0) {
 1124         (void)ssl_printf(ssl, "verbosity %d\n", verbosity);
 1125         return;
 1126     }
 1127     if(val == 0 && strcmp(str, "0") != 0) {
 1128         (void)ssl_printf(ssl, "error in verbosity number syntax: %s\n", str);
 1129         return;
 1130     }
 1131     verbosity = val;
 1132     task_new_set_verbosity(xfrd->nsd->task[xfrd->nsd->mytask],
 1133         xfrd->last_task, val);
 1134     xfrd_set_reload_now(xfrd);
 1135     send_ok(ssl);
 1136 }
 1137 
 1138 /** find second argument, modifies string */
 1139 static int
 1140 find_arg2(RES* ssl, char* arg, char** arg2)
 1141 {
 1142     char* as = strrchr(arg, ' ');
 1143     if(as) {
 1144         as[0]=0;
 1145         *arg2 = as+1;
 1146         while(isspace((unsigned char)*as) && as > arg)
 1147             as--;
 1148         as[0]=0;
 1149         return 1;
 1150     }
 1151     *arg2 = NULL;
 1152     (void)ssl_printf(ssl, "error could not find next argument "
 1153         "after %s\n", arg);
 1154     return 0;
 1155 }
 1156 
 1157 /** find second and third arguments, modifies string,
 1158  * does not print error for missing arg3 so that if it does not find an
 1159  * arg3, the caller can use two arguments. */
 1160 static int
 1161 find_arg3(RES* ssl, char* arg, char** arg2, char** arg3)
 1162 {
 1163     if(find_arg2(ssl, arg, arg2)) {
 1164         char* as;
 1165         *arg3 = *arg2;
 1166         as = strrchr(arg, ' ');
 1167         if(as) {
 1168             as[0]=0;
 1169             *arg2 = as+1;
 1170             while(isspace((unsigned char)*as) && as > arg)
 1171                 as--;
 1172             as[0]=0;
 1173             return 1;
 1174         }
 1175     }
 1176     *arg3 = NULL;
 1177     return 0;
 1178 }
 1179 
 1180 /** do the status command */
 1181 static void
 1182 do_status(RES* ssl, xfrd_state_type* xfrd)
 1183 {
 1184     if(!ssl_printf(ssl, "version: %s\n", PACKAGE_VERSION))
 1185         return;
 1186     if(!ssl_printf(ssl, "verbosity: %d\n", verbosity))
 1187         return;
 1188 #ifdef RATELIMIT
 1189     if(!ssl_printf(ssl, "ratelimit: %d\n",
 1190         (int)xfrd->nsd->options->rrl_ratelimit))
 1191         return;
 1192 #else
 1193     (void)xfrd;
 1194 #endif
 1195 }
 1196 
 1197 /** do the stats command */
 1198 static void
 1199 do_stats(struct daemon_remote* rc, int peek, struct rc_state* rs)
 1200 {
 1201 #ifdef BIND8_STATS
 1202     /* queue up to get stats after a reload is done (to gather statistics
 1203      * from the servers) */
 1204     assert(!rs->in_stats_list);
 1205     if(peek) rs->in_stats_list = 2;
 1206     else    rs->in_stats_list = 1;
 1207     rs->stats_next = rc->stats_list;
 1208     rc->stats_list = rs;
 1209     /* block the tcp waiting for the reload */
 1210     event_del(&rs->c);
 1211     rs->event_added = 0;
 1212     /* force a reload */
 1213     xfrd_set_reload_now(xfrd);
 1214 #else
 1215     (void)rc; (void)peek;
 1216     (void)ssl_printf(rs->ssl, "error no stats enabled at compile time\n");
 1217 #endif /* BIND8_STATS */
 1218 }
 1219 
 1220 /** see if we have more zonestatistics entries and it has to be incremented */
 1221 static void
 1222 zonestat_inc_ifneeded(xfrd_state_type* xfrd)
 1223 {
 1224 #ifdef USE_ZONE_STATS
 1225     if(xfrd->nsd->options->zonestatnames->count != xfrd->zonestat_safe)
 1226         task_new_zonestat_inc(xfrd->nsd->task[xfrd->nsd->mytask],
 1227             xfrd->last_task, 
 1228             xfrd->nsd->options->zonestatnames->count);
 1229 #else
 1230     (void)xfrd;
 1231 #endif /* USE_ZONE_STATS */
 1232 }
 1233 
 1234 /** perform the changezone command for one zone */
 1235 static int
 1236 perform_changezone(RES* ssl, xfrd_state_type* xfrd, char* arg)
 1237 {
 1238     const dname_type* dname;
 1239     struct zone_options* zopt;
 1240     char* arg2 = NULL;
 1241     if(!find_arg2(ssl, arg, &arg2))
 1242         return 0;
 1243 
 1244     /* if we add it to the xfrd now, then xfrd could download AXFR and
 1245      * store it and the NSD-reload would see it in the difffile before
 1246      * it sees the add-config task.
 1247      */
 1248     /* thus: AXFRs and IXFRs must store the pattern name in the
 1249      * difffile, so that it can be added when the AXFR or IXFR is seen.
 1250      */
 1251 
 1252     /* check that the pattern exists */
 1253     if(!rbtree_search(xfrd->nsd->options->patterns, arg2)) {
 1254         (void)ssl_printf(ssl, "error pattern %s does not exist\n",
 1255             arg2);
 1256         return 0;
 1257     }
 1258 
 1259     dname = dname_parse(xfrd->region, arg);
 1260     if(!dname) {
 1261         (void)ssl_printf(ssl, "error cannot parse zone name\n");
 1262         return 0;
 1263     }
 1264 
 1265     /* see if zone is a duplicate */
 1266     if( (zopt=zone_options_find(xfrd->nsd->options, dname)) ) {
 1267         if(zopt->part_of_config) {
 1268             (void)ssl_printf(ssl, "error zone defined in nsd.conf, "
 1269               "cannot delete it in this manner: remove it from "
 1270               "nsd.conf yourself and repattern\n");
 1271             region_recycle(xfrd->region, (void*)dname, dname_total_size(dname));
 1272             dname = NULL;
 1273             return 0;
 1274         }
 1275         /* found the zone, now delete it */
 1276         /* create deletion task */
 1277         /* this deletion task is processed before the addition task,
 1278          * that is created below, in the same reload process, causing
 1279          * a seamless change from one to the other, with no downtime
 1280          * for the zone. */
 1281         task_new_del_zone(xfrd->nsd->task[xfrd->nsd->mytask],
 1282             xfrd->last_task, dname);
 1283         xfrd_set_reload_now(xfrd);
 1284         /* delete it in xfrd */
 1285         if(zone_is_slave(zopt)) {
 1286             xfrd_del_slave_zone(xfrd, dname);
 1287         }
 1288         xfrd_del_notify(xfrd, dname);
 1289         /* delete from config */
 1290         zone_list_del(xfrd->nsd->options, zopt);
 1291     } else {
 1292         (void)ssl_printf(ssl, "zone %s did not exist, creating", arg);
 1293     }
 1294     region_recycle(xfrd->region, (void*)dname, dname_total_size(dname));
 1295     dname = NULL;
 1296 
 1297     /* add to zonelist and adds to config in memory */
 1298     zopt = zone_list_add(xfrd->nsd->options, arg, arg2);
 1299     if(!zopt) {
 1300         /* also dname parse error here */
 1301         (void)ssl_printf(ssl, "error could not add zonelist entry\n");
 1302         return 0;
 1303     }
 1304     /* make addzone task and schedule reload */
 1305     task_new_add_zone(xfrd->nsd->task[xfrd->nsd->mytask],
 1306         xfrd->last_task, arg, arg2,
 1307         getzonestatid(xfrd->nsd->options, zopt));
 1308     zonestat_inc_ifneeded(xfrd);
 1309     xfrd_set_reload_now(xfrd);
 1310     /* add to xfrd - notify (for master and slaves) */
 1311     init_notify_send(xfrd->notify_zones, xfrd->region, zopt);
 1312     /* add to xfrd - slave */
 1313     if(zone_is_slave(zopt)) {
 1314         xfrd_init_slave_zone(xfrd, zopt);
 1315     }
 1316     return 1;
 1317 }
 1318 
 1319 /** perform the addzone command for one zone */
 1320 static int
 1321 perform_addzone(RES* ssl, xfrd_state_type* xfrd, char* arg)
 1322 {
 1323     const dname_type* dname;
 1324     struct zone_options* zopt;
 1325     char* arg2 = NULL;
 1326     if(!find_arg2(ssl, arg, &arg2))
 1327         return 0;
 1328 
 1329     /* if we add it to the xfrd now, then xfrd could download AXFR and
 1330      * store it and the NSD-reload would see it in the difffile before
 1331      * it sees the add-config task.
 1332      */
 1333     /* thus: AXFRs and IXFRs must store the pattern name in the
 1334      * difffile, so that it can be added when the AXFR or IXFR is seen.
 1335      */
 1336 
 1337     /* check that the pattern exists */
 1338     if(!rbtree_search(xfrd->nsd->options->patterns, arg2)) {
 1339         (void)ssl_printf(ssl, "error pattern %s does not exist\n",
 1340             arg2);
 1341         return 0;
 1342     }
 1343 
 1344     dname = dname_parse(xfrd->region, arg);
 1345     if(!dname) {
 1346         (void)ssl_printf(ssl, "error cannot parse zone name\n");
 1347         return 0;
 1348     }
 1349 
 1350     /* see if zone is a duplicate */
 1351     if( zone_options_find(xfrd->nsd->options, dname) ) {
 1352         region_recycle(xfrd->region, (void*)dname,
 1353             dname_total_size(dname));
 1354         (void)ssl_printf(ssl, "zone %s already exists\n", arg);
 1355         return 1;
 1356     }
 1357     region_recycle(xfrd->region, (void*)dname, dname_total_size(dname));
 1358     dname = NULL;
 1359 
 1360     /* add to zonelist and adds to config in memory */
 1361     zopt = zone_list_add(xfrd->nsd->options, arg, arg2);
 1362     if(!zopt) {
 1363         /* also dname parse error here */
 1364         (void)ssl_printf(ssl, "error could not add zonelist entry\n");
 1365         return 0;
 1366     }
 1367     /* make addzone task and schedule reload */
 1368     task_new_add_zone(xfrd->nsd->task[xfrd->nsd->mytask],
 1369         xfrd->last_task, arg, arg2,
 1370         getzonestatid(xfrd->nsd->options, zopt));
 1371     zonestat_inc_ifneeded(xfrd);
 1372     xfrd_set_reload_now(xfrd);
 1373     /* add to xfrd - notify (for master and slaves) */
 1374     init_notify_send(xfrd->notify_zones, xfrd->region, zopt);
 1375     /* add to xfrd - slave */
 1376     if(zone_is_slave(zopt)) {
 1377         xfrd_init_slave_zone(xfrd, zopt);
 1378     }
 1379     return 1;
 1380 }
 1381 
 1382 /** perform the delzone command for one zone */
 1383 static int
 1384 perform_delzone(RES* ssl, xfrd_state_type* xfrd, char* arg)
 1385 {
 1386     const dname_type* dname;
 1387     struct zone_options* zopt;
 1388 
 1389     dname = dname_parse(xfrd->region, arg);
 1390     if(!dname) {
 1391         (void)ssl_printf(ssl, "error cannot parse zone name\n");
 1392         return 0;
 1393     }
 1394 
 1395     /* see if we have the zone in question */
 1396     zopt = zone_options_find(xfrd->nsd->options, dname);
 1397     if(!zopt) {
 1398         region_recycle(xfrd->region, (void*)dname,
 1399             dname_total_size(dname));
 1400         /* nothing to do */
 1401         (void)ssl_printf(ssl, "warning zone %s not present\n", arg);
 1402         return 0;
 1403     }
 1404 
 1405     /* see if it can be deleted */
 1406     if(zopt->part_of_config) {
 1407         region_recycle(xfrd->region, (void*)dname,
 1408             dname_total_size(dname));
 1409         (void)ssl_printf(ssl, "error zone defined in nsd.conf, "
 1410             "cannot delete it in this manner: remove it from "
 1411             "nsd.conf yourself and repattern\n");
 1412         return 0;
 1413     }
 1414 
 1415     /* create deletion task */
 1416     task_new_del_zone(xfrd->nsd->task[xfrd->nsd->mytask],
 1417         xfrd->last_task, dname);
 1418     xfrd_set_reload_now(xfrd);
 1419     /* delete it in xfrd */
 1420     if(zone_is_slave(zopt)) {
 1421         xfrd_del_slave_zone(xfrd, dname);
 1422     }
 1423     xfrd_del_notify(xfrd, dname);
 1424     /* delete from config */
 1425     zone_list_del(xfrd->nsd->options, zopt);
 1426 
 1427     region_recycle(xfrd->region, (void*)dname, dname_total_size(dname));
 1428     return 1;
 1429 }
 1430 
 1431 /** do the addzone command */
 1432 static void
 1433 do_addzone(RES* ssl, xfrd_state_type* xfrd, char* arg)
 1434 {
 1435     if(!perform_addzone(ssl, xfrd, arg))
 1436         return;
 1437     send_ok(ssl);
 1438 }
 1439 
 1440 /** do the delzone command */
 1441 static void
 1442 do_delzone(RES* ssl, xfrd_state_type* xfrd, char* arg)
 1443 {
 1444     if(!perform_delzone(ssl, xfrd, arg))
 1445         return;
 1446     send_ok(ssl);
 1447 }
 1448 
 1449 /** do the changezone command */
 1450 static void
 1451 do_changezone(RES* ssl, xfrd_state_type* xfrd, char* arg)
 1452 {
 1453     if(!perform_changezone(ssl, xfrd, arg))
 1454         return;
 1455     send_ok(ssl);
 1456 }
 1457 
 1458 /** do the addzones command */
 1459 static void
 1460 do_addzones(RES* ssl, xfrd_state_type* xfrd)
 1461 {
 1462     char buf[2048];
 1463     int num = 0;
 1464     while(ssl_read_line(ssl, buf, sizeof(buf))) {
 1465         if(buf[0] == 0x04 && buf[1] == 0)
 1466             break; /* end of transmission */
 1467         if(!perform_addzone(ssl, xfrd, buf)) {
 1468             if(!ssl_printf(ssl, "error for input line '%s'\n", 
 1469                 buf))
 1470                 return;
 1471         } else {
 1472             if(!ssl_printf(ssl, "added: %s\n", buf))
 1473                 return;
 1474             num++;
 1475         }
 1476     }
 1477     (void)ssl_printf(ssl, "added %d zones\n", num);
 1478 }
 1479 
 1480 /** do the delzones command */
 1481 static void
 1482 do_delzones(RES* ssl, xfrd_state_type* xfrd)
 1483 {
 1484     char buf[2048];
 1485     int num = 0;
 1486     while(ssl_read_line(ssl, buf, sizeof(buf))) {
 1487         if(buf[0] == 0x04 && buf[1] == 0)
 1488             break; /* end of transmission */
 1489         if(!perform_delzone(ssl, xfrd, buf)) {
 1490             if(!ssl_printf(ssl, "error for input line '%s'\n", 
 1491                 buf))
 1492                 return;
 1493         } else {
 1494             if(!ssl_printf(ssl, "removed: %s\n", buf))
 1495                 return;
 1496             num++;
 1497         }
 1498     }
 1499     (void)ssl_printf(ssl, "deleted %d zones\n", num);
 1500 }
 1501 
 1502 
 1503 /** remove TSIG key from config and add task so that reload does too */
 1504 static void remove_key(xfrd_state_type* xfrd, const char* kname)
 1505 {
 1506     /* add task before deletion because the name string could be deleted */
 1507     task_new_del_key(xfrd->nsd->task[xfrd->nsd->mytask], xfrd->last_task,
 1508         kname);
 1509     key_options_remove(xfrd->nsd->options, kname);
 1510     xfrd_set_reload_now(xfrd); /* this is executed when the current control
 1511         command ends, thus the entire config changes are bunched up */
 1512 }
 1513 
 1514 /** add TSIG key to config and add task so that reload does too */
 1515 static void add_key(xfrd_state_type* xfrd, struct key_options* k)
 1516 {
 1517     key_options_add_modify(xfrd->nsd->options, k);
 1518     task_new_add_key(xfrd->nsd->task[xfrd->nsd->mytask], xfrd->last_task,
 1519         k);
 1520     xfrd_set_reload_now(xfrd);
 1521 }
 1522 
 1523 /** check if keys have changed */
 1524 static void repat_keys(xfrd_state_type* xfrd, struct nsd_options* newopt)
 1525 {
 1526     struct nsd_options* oldopt = xfrd->nsd->options;
 1527     struct key_options* k;
 1528     /* find deleted keys */
 1529     k = (struct key_options*)rbtree_first(oldopt->keys);
 1530     while((rbnode_type*)k != RBTREE_NULL) {
 1531         struct key_options* next = (struct key_options*)rbtree_next(
 1532             (rbnode_type*)k);
 1533         if(!key_options_find(newopt, k->name))
 1534             remove_key(xfrd, k->name);
 1535         k = next;
 1536     }
 1537     /* find added or changed keys */
 1538     RBTREE_FOR(k, struct key_options*, newopt->keys) {
 1539         struct key_options* origk = key_options_find(oldopt, k->name);
 1540         if(!origk)
 1541             add_key(xfrd, k);
 1542         else if(!key_options_equal(k, origk))
 1543             add_key(xfrd, k);
 1544     }
 1545 }
 1546 
 1547 /** find zone given the implicit pattern */
 1548 static const dname_type*
 1549 parse_implicit_name(xfrd_state_type* xfrd,const char* pname)
 1550 {
 1551     if(strncmp(pname, PATTERN_IMPLICIT_MARKER,
 1552         strlen(PATTERN_IMPLICIT_MARKER)) != 0)
 1553         return NULL;
 1554     return dname_parse(xfrd->region, pname +
 1555         strlen(PATTERN_IMPLICIT_MARKER));
 1556 }
 1557 
 1558 /** remove cfgzone and add task so that reload does too */
 1559 static void
 1560 remove_cfgzone(xfrd_state_type* xfrd, const char* pname)
 1561 {
 1562     /* dname and find the zone for the implicit pattern */
 1563     struct zone_options* zopt = NULL;
 1564     const dname_type* dname = parse_implicit_name(xfrd, pname);
 1565     if(!dname) {
 1566         /* should have a parseable name, but it did not */
 1567         return;
 1568     }
 1569 
 1570     /* find the zone entry for the implicit pattern */
 1571     zopt = zone_options_find(xfrd->nsd->options, dname);
 1572     if(!zopt) {
 1573         /* this should not happen; implicit pattern has zone entry */
 1574         region_recycle(xfrd->region, (void*)dname,
 1575             dname_total_size(dname));
 1576         return;
 1577     }
 1578 
 1579     /* create deletion task */
 1580     task_new_del_zone(xfrd->nsd->task[xfrd->nsd->mytask],
 1581         xfrd->last_task, dname);
 1582     xfrd_set_reload_now(xfrd);
 1583     /* delete it in xfrd */
 1584     if(zone_is_slave(zopt)) {
 1585         xfrd_del_slave_zone(xfrd, dname);
 1586     }
 1587     xfrd_del_notify(xfrd, dname);
 1588 
 1589     /* delete from zoneoptions */
 1590     zone_options_delete(xfrd->nsd->options, zopt);
 1591 
 1592     /* recycle parsed dname */
 1593     region_recycle(xfrd->region, (void*)dname, dname_total_size(dname));
 1594 }
 1595 
 1596 /** add cfgzone and add task so that reload does too */
 1597 static void
 1598 add_cfgzone(xfrd_state_type* xfrd, const char* pname)
 1599 {
 1600     /* add to our zonelist */
 1601     struct zone_options* zopt = zone_options_create(
 1602         xfrd->nsd->options->region);
 1603     if(!zopt)
 1604         return;
 1605     zopt->part_of_config = 1;
 1606     zopt->name = region_strdup(xfrd->nsd->options->region, 
 1607         pname + strlen(PATTERN_IMPLICIT_MARKER));
 1608     zopt->pattern = pattern_options_find(xfrd->nsd->options, pname);
 1609     if(!zopt->name || !zopt->pattern)
 1610         return;
 1611     if(!nsd_options_insert_zone(xfrd->nsd->options, zopt)) {
 1612         log_msg(LOG_ERR, "bad domain name or duplicate zone '%s' "
 1613             "pattern %s", zopt->name, pname);
 1614     }
 1615 
 1616     /* make addzone task and schedule reload */
 1617     task_new_add_zone(xfrd->nsd->task[xfrd->nsd->mytask],
 1618         xfrd->last_task, zopt->name, pname,
 1619         getzonestatid(xfrd->nsd->options, zopt));
 1620     /* zonestat_inc is done after the entire config file has been done */
 1621     xfrd_set_reload_now(xfrd);
 1622     /* add to xfrd - notify (for master and slaves) */
 1623     init_notify_send(xfrd->notify_zones, xfrd->region, zopt);
 1624     /* add to xfrd - slave */
 1625     if(zone_is_slave(zopt)) {
 1626         xfrd_init_slave_zone(xfrd, zopt);
 1627     }
 1628 }
 1629 
 1630 /** remove pattern and add task so that reload does too */
 1631 static void
 1632 remove_pat(xfrd_state_type* xfrd, const char* name)
 1633 {
 1634     /* add task before deletion, because name-string could be deleted */
 1635     task_new_del_pattern(xfrd->nsd->task[xfrd->nsd->mytask],
 1636         xfrd->last_task, name);
 1637     pattern_options_remove(xfrd->nsd->options, name);
 1638     xfrd_set_reload_now(xfrd);
 1639 }
 1640 
 1641 /** add pattern and add task so that reload does too */
 1642 static void
 1643 add_pat(xfrd_state_type* xfrd, struct pattern_options* p)
 1644 {
 1645     pattern_options_add_modify(xfrd->nsd->options, p);
 1646     task_new_add_pattern(xfrd->nsd->task[xfrd->nsd->mytask],
 1647         xfrd->last_task, p);
 1648     xfrd_set_reload_now(xfrd);
 1649 }
 1650 
 1651 /** interrupt zones that are using changed or removed patterns */
 1652 static void
 1653 repat_interrupt_zones(xfrd_state_type* xfrd, struct nsd_options* newopt)
 1654 {
 1655     /* if masterlist changed:
 1656      *   interrupt slave zone (UDP or TCP) transfers.
 1657      *   slave zones reset master to start of list.
 1658      */
 1659     xfrd_zone_type* xz;
 1660     struct notify_zone* nz;
 1661     RBTREE_FOR(xz, xfrd_zone_type*, xfrd->zones) {
 1662         struct pattern_options* oldp = xz->zone_options->pattern;
 1663         struct pattern_options* newp = pattern_options_find(newopt,
 1664             oldp->pname);
 1665         if(!newp || !acl_list_equal(oldp->request_xfr,
 1666             newp->request_xfr)) {
 1667             /* interrupt transfer */
 1668             if(xz->tcp_conn != -1) {
 1669                 xfrd_tcp_release(xfrd->tcp_set, xz);
 1670                 xfrd_set_refresh_now(xz);
 1671             } else if(xz->zone_handler.ev_fd != -1) {
 1672                 xfrd_udp_release(xz);
 1673                 xfrd_set_refresh_now(xz);
 1674             }
 1675             xz->master = 0;
 1676             xz->master_num = 0;
 1677             xz->next_master = -1;
 1678             xz->round_num = -1; /* fresh set of retries */
 1679         }
 1680     }
 1681     /* if notify list changed:
 1682      *   interrupt notify that is busy.
 1683      *   reset notify to start of list.  (clear all other reset_notify)
 1684      */
 1685     RBTREE_FOR(nz, struct notify_zone*, xfrd->notify_zones) {
 1686         struct pattern_options* oldp = nz->options->pattern;
 1687         struct pattern_options* newp = pattern_options_find(newopt,
 1688             oldp->pname);
 1689         if(!newp || !acl_list_equal(oldp->notify, newp->notify)) {
 1690             /* interrupt notify */
 1691             if(nz->notify_send_enable) {
 1692                 notify_disable(nz);
 1693                 /* set to restart the notify after the
 1694                  * pattern has been changed. */
 1695                 nz->notify_restart = 2;
 1696             } else {
 1697                 nz->notify_restart = 1;
 1698             }
 1699         } else {
 1700             nz->notify_restart = 0;
 1701         }
 1702     }
 1703 }
 1704 
 1705 /** for notify, after the pattern changes, restart the affected notifies */
 1706 static void
 1707 repat_interrupt_notify_start(xfrd_state_type* xfrd)
 1708 {
 1709     struct notify_zone* nz;
 1710     RBTREE_FOR(nz, struct notify_zone*, xfrd->notify_zones) {
 1711         if(nz->notify_restart) {
 1712             if(nz->notify_current)
 1713                 nz->notify_current = nz->options->pattern->notify;
 1714             if(nz->notify_restart == 2) {
 1715                 if(nz->notify_restart)
 1716                     xfrd_notify_start(nz, xfrd);
 1717             }
 1718         }
 1719     }
 1720 }
 1721 
 1722 /** check if patterns have changed */
 1723 static void
 1724 repat_patterns(xfrd_state_type* xfrd, struct nsd_options* newopt)
 1725 {
 1726     /* zones that use changed patterns must have:
 1727      * - their AXFR/IXFR interrupted: try again, acl may have changed.
 1728      *   if the old master/key still exists, OK, fix master-numptrs and
 1729      *   keep going.  Otherwise, stop xfer and reset TSIG.
 1730      * - send NOTIFY reset to start of NOTIFY list (and TSIG reset).
 1731      */
 1732     struct nsd_options* oldopt = xfrd->nsd->options;
 1733     struct pattern_options* p;
 1734     int search_zones = 0;
 1735 
 1736     repat_interrupt_zones(xfrd, newopt);
 1737     /* find deleted patterns */
 1738     p = (struct pattern_options*)rbtree_first(oldopt->patterns);
 1739     while((rbnode_type*)p != RBTREE_NULL) {
 1740         struct pattern_options* next = (struct pattern_options*)
 1741             rbtree_next((rbnode_type*)p);
 1742         if(!pattern_options_find(newopt, p->pname)) {
 1743             if(p->implicit) {
 1744                 /* first remove its zone */
 1745                 VERBOSITY(1, (LOG_INFO, "zone removed from config: %s", p->pname + strlen(PATTERN_IMPLICIT_MARKER)));
 1746                 remove_cfgzone(xfrd, p->pname);
 1747             }
 1748             remove_pat(xfrd, p->pname);
 1749         }
 1750         p = next;
 1751     }
 1752     /* find added or changed patterns */
 1753     RBTREE_FOR(p, struct pattern_options*, newopt->patterns) {
 1754         struct pattern_options* origp = pattern_options_find(oldopt,
 1755             p->pname);
 1756         if(!origp) {
 1757             /* no zones can use it, no zone_interrupt needed */
 1758             add_pat(xfrd, p);
 1759             if(p->implicit) {
 1760                 VERBOSITY(1, (LOG_INFO, "zone added to config: %s", p->pname + strlen(PATTERN_IMPLICIT_MARKER)));
 1761                 add_cfgzone(xfrd, p->pname);
 1762             }
 1763         } else if(!pattern_options_equal(p, origp)) {
 1764             uint8_t newstate = 0;
 1765             if (p->request_xfr && !origp->request_xfr) {
 1766                 newstate = REPAT_SLAVE;
 1767             } else if (!p->request_xfr && origp->request_xfr) {
 1768                 newstate = REPAT_MASTER;
 1769             }
 1770             add_pat(xfrd, p);
 1771             if (p->implicit && newstate) {
 1772                 const dname_type* dname =
 1773                     parse_implicit_name(xfrd, p->pname);
 1774                 if (dname) {
 1775                     if (newstate == REPAT_SLAVE) {
 1776                         struct zone_options* zopt =
 1777                             zone_options_find(
 1778                             oldopt, dname);
 1779                         if (zopt) {
 1780                             xfrd_init_slave_zone(
 1781                                 xfrd, zopt);
 1782                         }
 1783                     } else if (newstate == REPAT_MASTER) {
 1784                         xfrd_del_slave_zone(xfrd,
 1785                             dname);
 1786                     }
 1787                     region_recycle(xfrd->region,
 1788                         (void*)dname,
 1789                         dname_total_size(dname));
 1790                 }
 1791             } else if(!p->implicit && newstate) {
 1792                 /* search all zones with this pattern */
 1793                 search_zones = 1;
 1794                 origp->xfrd_flags = newstate;
 1795             }
 1796         }
 1797     }
 1798     if (search_zones) {
 1799         struct zone_options* zone_opt;
 1800         /* search in oldopt because 1) it contains zonelist zones,
 1801          * and 2) you need oldopt(existing) to call xfrd_init */
 1802         RBTREE_FOR(zone_opt, struct zone_options*, oldopt->zone_options) {
 1803             struct pattern_options* oldp = zone_opt->pattern;
 1804             if (!oldp->implicit) {
 1805                 if (oldp->xfrd_flags == REPAT_SLAVE) {
 1806                     /* xfrd needs stable reference so get
 1807                      * it from the oldopt(modified) tree */
 1808                     xfrd_init_slave_zone(xfrd, zone_opt);
 1809                 } else if (oldp->xfrd_flags == REPAT_MASTER) {
 1810                     xfrd_del_slave_zone(xfrd,
 1811                         (const dname_type*)
 1812                         zone_opt->node.key);
 1813                 }
 1814                 oldp->xfrd_flags = 0;
 1815             }
 1816         }
 1817     }
 1818     repat_interrupt_notify_start(xfrd);
 1819 }
 1820 
 1821 /** true if options are different that can be set via repat. */
 1822 static int
 1823 repat_options_changed(xfrd_state_type* xfrd, struct nsd_options* newopt)
 1824 {
 1825 #ifdef RATELIMIT
 1826     if(xfrd->nsd->options->rrl_ratelimit != newopt->rrl_ratelimit)
 1827         return 1;
 1828     if(xfrd->nsd->options->rrl_whitelist_ratelimit != newopt->rrl_whitelist_ratelimit)
 1829         return 1;
 1830     if(xfrd->nsd->options->rrl_slip != newopt->rrl_slip)
 1831         return 1;
 1832 #else
 1833     (void)xfrd; (void)newopt;
 1834 #endif
 1835     return 0;
 1836 }
 1837 
 1838 /** check if global options have changed */
 1839 static void
 1840 repat_options(xfrd_state_type* xfrd, struct nsd_options* newopt)
 1841 {
 1842     if(repat_options_changed(xfrd, newopt)) {
 1843         /* update our options */
 1844 #ifdef RATELIMIT
 1845         xfrd->nsd->options->rrl_ratelimit = newopt->rrl_ratelimit;
 1846         xfrd->nsd->options->rrl_whitelist_ratelimit = newopt->rrl_whitelist_ratelimit;
 1847         xfrd->nsd->options->rrl_slip = newopt->rrl_slip;
 1848 #endif
 1849         task_new_opt_change(xfrd->nsd->task[xfrd->nsd->mytask],
 1850             xfrd->last_task, newopt);
 1851         xfrd_set_reload_now(xfrd);
 1852     }
 1853 }
 1854 
 1855 /** print errors over ssl, gets pointer-to-pointer to ssl, so it can set
 1856  * the pointer to NULL on failure and stop printing */
 1857 static void
 1858 print_ssl_cfg_err(void* arg, const char* str)
 1859 {
 1860     RES** ssl = (RES**)arg;
 1861     if(!*ssl) return;
 1862     if(!ssl_printf(*ssl, "%s", str))
 1863         *ssl = NULL; /* failed, stop printing */
 1864 }
 1865 
 1866 /** do the repattern command: reread config file and apply keys, patterns */
 1867 static void
 1868 do_repattern(RES* ssl, xfrd_state_type* xfrd)
 1869 {
 1870     region_type* region = region_create(xalloc, free);
 1871     struct nsd_options* opt;
 1872     const char* cfgfile = xfrd->nsd->options->configfile;
 1873 
 1874     /* check chroot and configfile, if possible to reread */
 1875     if(xfrd->nsd->chrootdir) {
 1876         size_t l = strlen(xfrd->nsd->chrootdir);
 1877         while(l>0 && xfrd->nsd->chrootdir[l-1] == '/')
 1878             --l;
 1879         if(strncmp(xfrd->nsd->chrootdir, cfgfile, l) != 0) {
 1880             (void)ssl_printf(ssl, "error %s is not relative to %s: "
 1881                 "chroot prevents reread of config\n",
 1882                 cfgfile, xfrd->nsd->chrootdir);
 1883             region_destroy(region);
 1884             return;
 1885         }
 1886         cfgfile += l;
 1887     }
 1888 
 1889     (void)ssl_printf(ssl, "reconfig start, read %s\n", cfgfile);
 1890     opt = nsd_options_create(region);
 1891     if(!parse_options_file(opt, cfgfile, &print_ssl_cfg_err, &ssl)) {
 1892         /* error already printed */
 1893         region_destroy(region);
 1894         return;
 1895     }
 1896     /* check for differences in TSIG keys and patterns, and apply,
 1897      * first the keys, so that pattern->keyptr can be set right. */
 1898     repat_keys(xfrd, opt);
 1899     repat_patterns(xfrd, opt);
 1900     repat_options(xfrd, opt);
 1901     zonestat_inc_ifneeded(xfrd);
 1902     send_ok(ssl);
 1903     region_destroy(region);
 1904 }
 1905 
 1906 /** do the serverpid command: printout pid of server process */
 1907 static void
 1908 do_serverpid(RES* ssl, xfrd_state_type* xfrd)
 1909 {
 1910     (void)ssl_printf(ssl, "%u\n", (unsigned)xfrd->reload_pid);
 1911 }
 1912 
 1913 /** do the print_tsig command: printout tsig info */
 1914 static void
 1915 do_print_tsig(RES* ssl, xfrd_state_type* xfrd, char* arg)
 1916 {
 1917     if(*arg == '\0') {
 1918         struct key_options* key;
 1919         RBTREE_FOR(key, struct key_options*, xfrd->nsd->options->keys) {
 1920             if(!ssl_printf(ssl, "key: name: \"%s\" secret: \"%s\" algorithm: %s\n", key->name, key->secret, key->algorithm))
 1921                 return;
 1922         }
 1923         return;
 1924     } else {
 1925         struct key_options* key_opts = key_options_find(xfrd->nsd->options, arg);
 1926         if(!key_opts) {
 1927             (void)ssl_printf(ssl, "error: no such key with name: %s\n", arg);
 1928             return;
 1929         } else {
 1930             (void)ssl_printf(ssl, "key: name: \"%s\" secret: \"%s\" algorithm: %s\n", arg, key_opts->secret, key_opts->algorithm);
 1931         }
 1932     }
 1933 }
 1934 
 1935 /** do the update_tsig command: change existing tsig to new secret */
 1936 static void
 1937 do_update_tsig(RES* ssl, xfrd_state_type* xfrd, char* arg)
 1938 {
 1939     struct region* region = xfrd->nsd->options->region;
 1940     char* arg2 = NULL;
 1941     uint8_t data[65536]; /* 64K */
 1942     struct key_options* key_opt;
 1943 
 1944     if(*arg == '\0') {
 1945         (void)ssl_printf(ssl, "error: missing argument (keyname)\n");
 1946         return;
 1947     }
 1948     if(!find_arg2(ssl, arg, &arg2)) {
 1949         (void)ssl_printf(ssl, "error: missing argument (secret)\n");
 1950         return;
 1951     }
 1952     key_opt = key_options_find(xfrd->nsd->options, arg);
 1953     if(!key_opt) {
 1954         (void)ssl_printf(ssl, "error: no such key with name: %s\n", arg);
 1955         memset(arg2, 0xdd, strlen(arg2));
 1956         return;
 1957     }
 1958     if(b64_pton(arg2, data, sizeof(data)) == -1) {
 1959         (void)ssl_printf(ssl, "error: the secret: %s is not in b64 format\n", arg2);
 1960         memset(data, 0xdd, sizeof(data)); /* wipe secret */
 1961         memset(arg2, 0xdd, strlen(arg2));
 1962         return;
 1963     }
 1964     log_msg(LOG_INFO, "changing secret provided with the key: %s with old secret %s and algo: %s\n", arg, key_opt->secret, key_opt->algorithm);
 1965     if(key_opt->secret) {
 1966         /* wipe old secret */
 1967         memset(key_opt->secret, 0xdd, strlen(key_opt->secret));
 1968         region_recycle(region, key_opt->secret,
 1969             strlen(key_opt->secret)+1);
 1970     }
 1971     key_opt->secret = region_strdup(region, arg2);
 1972     log_msg(LOG_INFO, "the key: %s has new secret %s and algorithm: %s\n", arg, key_opt->secret, key_opt->algorithm);
 1973     /* wipe secret from temp parse buffer */
 1974     memset(arg2, 0xdd, strlen(arg2));
 1975     memset(data, 0xdd, sizeof(data));
 1976 
 1977     key_options_desetup(region, key_opt);
 1978     key_options_setup(region, key_opt);
 1979     task_new_add_key(xfrd->nsd->task[xfrd->nsd->mytask], xfrd->last_task,
 1980         key_opt);
 1981     xfrd_set_reload_now(xfrd);
 1982 
 1983     send_ok(ssl);
 1984 }
 1985 
 1986 /** do the add tsig command, add new key with name, secret and algo given */
 1987 static void
 1988 do_add_tsig(RES* ssl, xfrd_state_type* xfrd, char* arg)
 1989 {
 1990     char* arg2 = NULL;
 1991     char* arg3 = NULL;
 1992     uint8_t data[65536]; /* 64KB */
 1993     uint8_t dname[MAXDOMAINLEN+1];
 1994     char algo[256];
 1995     region_type* region = xfrd->nsd->options->region;
 1996     struct key_options* new_key_opt;
 1997 
 1998     if(*arg == '\0') {
 1999         (void)ssl_printf(ssl, "error: missing argument (keyname)\n");
 2000         return;
 2001     }
 2002     if(!find_arg3(ssl, arg, &arg2, &arg3)) {
 2003         strlcpy(algo, "hmac-sha256", sizeof(algo));
 2004     } else {
 2005         strlcpy(algo, arg3, sizeof(algo));
 2006     }
 2007     if(!arg2) {
 2008         (void)ssl_printf(ssl, "error: missing argument (secret)\n");
 2009         return;
 2010     }
 2011     if(key_options_find(xfrd->nsd->options, arg)) {
 2012         (void)ssl_printf(ssl, "error: key %s already exists\n", arg);
 2013         memset(arg2, 0xdd, strlen(arg2));
 2014         return;
 2015     }
 2016     if(b64_pton(arg2, data, sizeof(data)) == -1) {
 2017         (void)ssl_printf(ssl, "error: the secret: %s is not in b64 format\n", arg2);
 2018         memset(data, 0xdd, sizeof(data)); /* wipe secret */
 2019         memset(arg2, 0xdd, strlen(arg2));
 2020         return;
 2021     }
 2022     memset(data, 0xdd, sizeof(data)); /* wipe secret from temp buffer */
 2023     if(!dname_parse_wire(dname, arg)) {
 2024         (void)ssl_printf(ssl, "error: could not parse key name: %s\n", arg);
 2025         memset(arg2, 0xdd, strlen(arg2));
 2026         return;
 2027     }
 2028     if(tsig_get_algorithm_by_name(algo) == NULL) {
 2029         (void)ssl_printf(ssl, "error: unknown algorithm: %s\n", algo);
 2030         memset(arg2, 0xdd, strlen(arg2));
 2031         return;
 2032     }
 2033     log_msg(LOG_INFO, "adding key with name: %s and secret: %s with algo: %s\n", arg, arg2, algo);
 2034     new_key_opt = key_options_create(region);
 2035     new_key_opt->name = region_strdup(region, arg);
 2036     new_key_opt->secret = region_strdup(region, arg2);
 2037     new_key_opt->algorithm = region_strdup(region, algo);
 2038     add_key(xfrd, new_key_opt);
 2039 
 2040     /* wipe secret from temp buffer */
 2041     memset(arg2, 0xdd, strlen(arg2));
 2042     send_ok(ssl);
 2043 }
 2044 
 2045 /** set acl entries to use the given TSIG key */
 2046 static void
 2047 zopt_set_acl_to_tsig(struct acl_options* acl, struct region* region,
 2048     const char* key_name, struct key_options* key_opt)
 2049 {
 2050     while(acl) {
 2051         if(acl->blocked) {
 2052             acl = acl->next;
 2053             continue;
 2054         }
 2055         acl->nokey = 0;
 2056         if(acl->key_name)
 2057             region_recycle(region, (void*)acl->key_name,
 2058                 strlen(acl->key_name)+1);
 2059         acl->key_name = region_strdup(region, key_name);
 2060         acl->key_options = key_opt;
 2061         acl = acl->next;
 2062     }
 2063 }
 2064 
 2065 /** do the assoc_tsig command: associate the zone to use the tsig name */
 2066 static void
 2067 do_assoc_tsig(RES* ssl, xfrd_state_type* xfrd, char* arg)
 2068 {
 2069     region_type* region = xfrd->nsd->options->region;
 2070     char* arg2 = NULL;
 2071     struct zone_options* zone;
 2072     struct key_options* key_opt;
 2073 
 2074     if(*arg == '\0') {
 2075         (void)ssl_printf(ssl, "error: missing argument (zonename)\n");
 2076         return;
 2077     }
 2078     if(!find_arg2(ssl, arg, &arg2)) {
 2079         (void)ssl_printf(ssl, "error: missing argument (keyname)\n");
 2080         return;
 2081     }
 2082 
 2083     if(!get_zone_arg(ssl, xfrd, arg, &zone))
 2084         return;
 2085     if(!zone) {
 2086         (void)ssl_printf(ssl, "error: missing argument (zone)\n");
 2087         return;
 2088     }
 2089     key_opt = key_options_find(xfrd->nsd->options, arg2);
 2090     if(!key_opt) {
 2091         (void)ssl_printf(ssl, "error: key: %s does not exist\n", arg2);
 2092         return;
 2093     }
 2094 
 2095     zopt_set_acl_to_tsig(zone->pattern->allow_notify, region, arg2,
 2096         key_opt);
 2097     zopt_set_acl_to_tsig(zone->pattern->notify, region, arg2, key_opt);
 2098     zopt_set_acl_to_tsig(zone->pattern->request_xfr, region, arg2,
 2099         key_opt);
 2100     zopt_set_acl_to_tsig(zone->pattern->provide_xfr, region, arg2,
 2101         key_opt);
 2102     zopt_set_acl_to_tsig(zone->pattern->allow_query, region, arg2,
 2103         key_opt);
 2104 
 2105     task_new_add_pattern(xfrd->nsd->task[xfrd->nsd->mytask],
 2106         xfrd->last_task, zone->pattern);
 2107     xfrd_set_reload_now(xfrd);
 2108 
 2109     send_ok(ssl);
 2110 }
 2111 
 2112 /** see if TSIG key is used in the acl */
 2113 static int
 2114 acl_contains_tsig_key(struct acl_options* acl, const char* name)
 2115 {
 2116     while(acl) {
 2117         if(acl->key_name && strcmp(acl->key_name, name) == 0)
 2118             return 1;
 2119         acl = acl->next;
 2120     }
 2121     return 0;
 2122 }
 2123 
 2124 /** do the del_tsig command, remove an (unused) tsig */
 2125 static void
 2126 do_del_tsig(RES* ssl, xfrd_state_type* xfrd, char* arg) {
 2127     int used_key = 0;
 2128     struct zone_options* zone;
 2129     struct key_options* key_opt;
 2130 
 2131     if(*arg == '\0') {
 2132         (void)ssl_printf(ssl, "error: missing argument (keyname)\n");
 2133         return;
 2134     }
 2135     key_opt = key_options_find(xfrd->nsd->options, arg);
 2136     if(!key_opt) {
 2137         (void)ssl_printf(ssl, "key %s does not exist, nothing to be deleted\n", arg);
 2138         return;
 2139     }
 2140     RBTREE_FOR(zone, struct zone_options*, xfrd->nsd->options->zone_options)
 2141     {
 2142         if(acl_contains_tsig_key(zone->pattern->allow_notify, arg) ||
 2143            acl_contains_tsig_key(zone->pattern->notify, arg) ||
 2144            acl_contains_tsig_key(zone->pattern->request_xfr, arg) ||
 2145            acl_contains_tsig_key(zone->pattern->provide_xfr, arg) ||
 2146            acl_contains_tsig_key(zone->pattern->allow_query, arg)) {
 2147             if(!ssl_printf(ssl, "zone %s uses key %s\n",
 2148                 zone->name, arg))
 2149                 return;
 2150             used_key = 1;
 2151             break;
 2152         }
 2153     }
 2154 
 2155     if(used_key) {
 2156         (void)ssl_printf(ssl, "error: key: %s is in use and cannot be deleted\n", arg);
 2157         return;
 2158     } else {
 2159         remove_key(xfrd, arg);
 2160         log_msg(LOG_INFO, "key: %s is successfully deleted\n", arg);
 2161     }
 2162 
 2163     send_ok(ssl);
 2164 }
 2165 
 2166 /** check for name with end-of-string, space or tab after it */
 2167 static int
 2168 cmdcmp(char* p, const char* cmd, size_t len)
 2169 {
 2170     return strncmp(p,cmd,len)==0 && (p[len]==0||p[len]==' '||p[len]=='\t');
 2171 }
 2172 
 2173 /** execute a remote control command */
 2174 static void
 2175 execute_cmd(struct daemon_remote* rc, RES* ssl, char* cmd, struct rc_state* rs)
 2176 {
 2177     char* p = skipwhite(cmd);
 2178     /* compare command */
 2179     if(cmdcmp(p, "stop", 4)) {
 2180         do_stop(ssl, rc->xfrd);
 2181     } else if(cmdcmp(p, "reload", 6)) {
 2182         do_reload(ssl, rc->xfrd, skipwhite(p+6));
 2183     } else if(cmdcmp(p, "write", 5)) {
 2184         do_write(ssl, rc->xfrd, skipwhite(p+5));
 2185     } else if(cmdcmp(p, "status", 6)) {
 2186         do_status(ssl, rc->xfrd);
 2187     } else if(cmdcmp(p, "stats_noreset", 13)) {
 2188         do_stats(rc, 1, rs);
 2189     } else if(cmdcmp(p, "stats", 5)) {
 2190         do_stats(rc, 0, rs);
 2191     } else if(cmdcmp(p, "log_reopen", 10)) {
 2192         do_log_reopen(ssl, rc->xfrd);
 2193     } else if(cmdcmp(p, "addzone", 7)) {
 2194         do_addzone(ssl, rc->xfrd, skipwhite(p+7));
 2195     } else if(cmdcmp(p, "delzone", 7)) {
 2196         do_delzone(ssl, rc->xfrd, skipwhite(p+7));
 2197     } else if(cmdcmp(p, "changezone", 10)) {
 2198         do_changezone(ssl, rc->xfrd, skipwhite(p+10));
 2199     } else if(cmdcmp(p, "addzones", 8)) {
 2200         do_addzones(ssl, rc->xfrd);
 2201     } else if(cmdcmp(p, "delzones", 8)) {
 2202         do_delzones(ssl, rc->xfrd);
 2203     } else if(cmdcmp(p, "notify", 6)) {
 2204         do_notify(ssl, rc->xfrd, skipwhite(p+6));
 2205     } else if(cmdcmp(p, "transfer", 8)) {
 2206         do_transfer(ssl, rc->xfrd, skipwhite(p+8));
 2207     } else if(cmdcmp(p, "force_transfer", 14)) {
 2208         do_force_transfer(ssl, rc->xfrd, skipwhite(p+14));
 2209     } else if(cmdcmp(p, "zonestatus", 10)) {
 2210         do_zonestatus(ssl, rc->xfrd, skipwhite(p+10));
 2211     } else if(cmdcmp(p, "verbosity", 9)) {
 2212         do_verbosity(ssl, skipwhite(p+9));
 2213     } else if(cmdcmp(p, "repattern", 9)) {
 2214         do_repattern(ssl, rc->xfrd);
 2215     } else if(cmdcmp(p, "reconfig", 8)) {
 2216         do_repattern(ssl, rc->xfrd);
 2217     } else if(cmdcmp(p, "serverpid", 9)) {
 2218         do_serverpid(ssl, rc->xfrd);
 2219     } else if(cmdcmp(p, "print_tsig", 10)) {
 2220         do_print_tsig(ssl, rc->xfrd, skipwhite(p+10));
 2221     } else if(cmdcmp(p, "update_tsig", 11)) {
 2222         do_update_tsig(ssl, rc->xfrd, skipwhite(p+11));
 2223     } else if(cmdcmp(p, "add_tsig", 8)) {
 2224         do_add_tsig(ssl, rc->xfrd, skipwhite(p+8));
 2225     } else if(cmdcmp(p, "assoc_tsig", 10)) {
 2226         do_assoc_tsig(ssl, rc->xfrd, skipwhite(p+10));
 2227     } else if(cmdcmp(p, "del_tsig", 8)) {
 2228         do_del_tsig(ssl, rc->xfrd, skipwhite(p+8));
 2229     } else {
 2230         (void)ssl_printf(ssl, "error unknown command '%s'\n", p);
 2231     }
 2232 }
 2233 
 2234 /** handle remote control request */
 2235 static void
 2236 handle_req(struct daemon_remote* rc, struct rc_state* s, RES* res)
 2237 {
 2238     int r;
 2239     char pre[10];
 2240     char magic[8];
 2241     char buf[1024];
 2242     if (fcntl(s->c.ev_fd, F_SETFL, 0) == -1) { /* set blocking */
 2243         log_msg(LOG_ERR, "cannot fcntl rc: %s", strerror(errno));
 2244     }
 2245 
 2246     /* try to read magic UBCT[version]_space_ string */
 2247     if(res->ssl) {
 2248         ERR_clear_error();
 2249         if((r=SSL_read(res->ssl, magic, (int)sizeof(magic)-1)) <= 0) {
 2250             if(SSL_get_error(res->ssl, r) == SSL_ERROR_ZERO_RETURN)
 2251                 return;
 2252             log_crypto_err("could not SSL_read");
 2253             return;
 2254         }
 2255     } else {
 2256         while(1) {
 2257             ssize_t rr = read(res->fd, magic, sizeof(magic)-1);
 2258             if(rr <= 0) {
 2259                 if(rr == 0) return;
 2260                 if(errno == EINTR || errno == EAGAIN)
 2261                     continue;
 2262                 log_msg(LOG_ERR, "could not read: %s", strerror(errno));
 2263                 return;
 2264             }
 2265             r = (int)rr;
 2266             break;
 2267         }
 2268     }
 2269     magic[7] = 0;
 2270     if( r != 7 || strncmp(magic, "NSDCT", 5) != 0) {
 2271         VERBOSITY(2, (LOG_INFO, "control connection has bad header"));
 2272         /* probably wrong tool connected, ignore it completely */
 2273         return;
 2274     }
 2275 
 2276     /* read the command line */
 2277     if(!ssl_read_line(res, buf, sizeof(buf))) {
 2278         return;
 2279     }
 2280     snprintf(pre, sizeof(pre), "NSDCT%d ", NSD_CONTROL_VERSION);
 2281     if(strcmp(magic, pre) != 0) {
 2282         VERBOSITY(2, (LOG_INFO, "control connection had bad "
 2283             "version %s, cmd: %s", magic, buf));
 2284         (void)ssl_printf(res, "error version mismatch\n");
 2285         return;
 2286     }
 2287     VERBOSITY(2, (LOG_INFO, "control cmd: %s", buf));
 2288 
 2289     /* figure out what to do */
 2290     execute_cmd(rc, res, buf, s);
 2291 }
 2292 
 2293 /** handle SSL_do_handshake changes to the file descriptor to wait for later */
 2294 static void
 2295 remote_handshake_later(struct daemon_remote* rc, struct rc_state* s, int fd,
 2296     int r, int r2)
 2297 {
 2298     if(r2 == SSL_ERROR_WANT_READ) {
 2299         if(s->shake_state == rc_hs_read) {
 2300             /* try again later */
 2301             return;
 2302         }
 2303         s->shake_state = rc_hs_read;
 2304         event_del(&s->c);
 2305         memset(&s->c, 0, sizeof(s->c));
 2306         event_set(&s->c, fd, EV_PERSIST|EV_TIMEOUT|EV_READ,
 2307             remote_control_callback, s);
 2308         if(event_base_set(xfrd->event_base, &s->c) != 0)
 2309             log_msg(LOG_ERR, "remote_accept: cannot set event_base");
 2310         if(event_add(&s->c, &s->tval) != 0)
 2311             log_msg(LOG_ERR, "remote_accept: cannot add event");
 2312         return;
 2313     } else if(r2 == SSL_ERROR_WANT_WRITE) {
 2314         if(s->shake_state == rc_hs_write) {
 2315             /* try again later */
 2316             return;
 2317         }
 2318         s->shake_state = rc_hs_write;
 2319         event_del(&s->c);
 2320         memset(&s->c, 0, sizeof(s->c));
 2321         event_set(&s->c, fd, EV_PERSIST|EV_TIMEOUT|EV_WRITE,
 2322             remote_control_callback, s);
 2323         if(event_base_set(xfrd->event_base, &s->c) != 0)
 2324             log_msg(LOG_ERR, "remote_accept: cannot set event_base");
 2325         if(event_add(&s->c, &s->tval) != 0)
 2326             log_msg(LOG_ERR, "remote_accept: cannot add event");
 2327         return;
 2328     } else {
 2329         if(r == 0)
 2330             log_msg(LOG_ERR, "remote control connection closed prematurely");
 2331         log_crypto_err("remote control failed ssl");
 2332         clean_point(rc, s);
 2333     }
 2334 }
 2335 
 2336 static void
 2337 remote_control_callback(int fd, short event, void* arg)
 2338 {
 2339     RES res;
 2340     struct rc_state* s = (struct rc_state*)arg;
 2341     struct daemon_remote* rc = s->rc;
 2342     int r;
 2343     if( (event&EV_TIMEOUT) ) {
 2344         log_msg(LOG_ERR, "remote control timed out");
 2345         clean_point(rc, s);
 2346         return;
 2347     }
 2348     if(s->ssl) {
 2349         /* (continue to) setup the SSL connection */
 2350         ERR_clear_error();
 2351         r = SSL_do_handshake(s->ssl);
 2352         if(r != 1) {
 2353             int r2 = SSL_get_error(s->ssl, r);
 2354             remote_handshake_later(rc, s, fd, r, r2);
 2355             return;
 2356         }
 2357         s->shake_state = rc_none;
 2358     }
 2359 
 2360     /* once handshake has completed, check authentication */
 2361     if (!rc->use_cert) {
 2362         VERBOSITY(3, (LOG_INFO, "unauthenticated remote control connection"));
 2363     } else if(SSL_get_verify_result(s->ssl) == X509_V_OK) {
 2364         X509* x = SSL_get_peer_certificate(s->ssl);
 2365         if(!x) {
 2366             VERBOSITY(2, (LOG_INFO, "remote control connection "
 2367                 "provided no client certificate"));
 2368             clean_point(rc, s);
 2369             return;
 2370         }
 2371         VERBOSITY(3, (LOG_INFO, "remote control connection authenticated"));
 2372         X509_free(x);
 2373     } else {
 2374         VERBOSITY(2, (LOG_INFO, "remote control connection failed to "
 2375             "authenticate with client certificate"));
 2376         clean_point(rc, s);
 2377         return;
 2378     }
 2379 
 2380     /* if OK start to actually handle the request */
 2381     res.ssl = s->ssl;
 2382     res.fd = fd;
 2383     handle_req(rc, s, &res);
 2384 
 2385     if(!s->in_stats_list) {
 2386         VERBOSITY(3, (LOG_INFO, "remote control operation completed"));
 2387         clean_point(rc, s);
 2388     }
 2389 }
 2390 
 2391 #ifdef BIND8_STATS
 2392 static const char*
 2393 opcode2str(int o)
 2394 {
 2395     switch(o) {
 2396         case OPCODE_QUERY: return "QUERY";
 2397         case OPCODE_IQUERY: return "IQUERY";
 2398         case OPCODE_STATUS: return "STATUS";
 2399         case OPCODE_NOTIFY: return "NOTIFY";
 2400         case OPCODE_UPDATE: return "UPDATE";
 2401         default: return "OTHER";
 2402     }
 2403 }
 2404 
 2405 /** print long number */
 2406 static int
 2407 print_longnum(RES* ssl, char* desc, uint64_t x)
 2408 {
 2409     if(x > (uint64_t)1024*1024*1024) {
 2410         /* more than a Gb */
 2411         size_t front = (size_t)(x / (uint64_t)1000000);
 2412         size_t back = (size_t)(x % (uint64_t)1000000);
 2413         return ssl_printf(ssl, "%s%lu%6.6lu\n", desc, 
 2414             (unsigned long)front, (unsigned long)back);
 2415     } else {
 2416         return ssl_printf(ssl, "%s%lu\n", desc, (unsigned long)x);
 2417     }
 2418 }
 2419 
 2420 /* print one block of statistics.  n is name and d is delimiter */
 2421 static void
 2422 print_stat_block(RES* ssl, char* n, char* d, struct nsdst* st)
 2423 {
 2424     const char* rcstr[] = {"NOERROR", "FORMERR", "SERVFAIL", "NXDOMAIN",
 2425         "NOTIMP", "REFUSED", "YXDOMAIN", "YXRRSET", "NXRRSET", "NOTAUTH",
 2426         "NOTZONE", "RCODE11", "RCODE12", "RCODE13", "RCODE14", "RCODE15",
 2427         "BADVERS"
 2428     };
 2429     size_t i;
 2430     for(i=0; i<= 255; i++) {
 2431         if(inhibit_zero && st->qtype[i] == 0 &&
 2432             strncmp(rrtype_to_string(i), "TYPE", 4) == 0)
 2433             continue;
 2434         if(!ssl_printf(ssl, "%s%snum.type.%s=%lu\n", n, d,
 2435             rrtype_to_string(i), (unsigned long)st->qtype[i]))
 2436             return;
 2437     }
 2438 
 2439     /* opcode */
 2440     for(i=0; i<6; i++) {
 2441         if(inhibit_zero && st->opcode[i] == 0 && i != OPCODE_QUERY)
 2442             continue;
 2443         if(!ssl_printf(ssl, "%s%snum.opcode.%s=%lu\n", n, d,
 2444             opcode2str(i), (unsigned long)st->opcode[i]))
 2445             return;
 2446     }
 2447 
 2448     /* qclass */
 2449     for(i=0; i<4; i++) {
 2450         if(inhibit_zero && st->qclass[i] == 0 && i != CLASS_IN)
 2451             continue;
 2452         if(!ssl_printf(ssl, "%s%snum.class.%s=%lu\n", n, d,
 2453             rrclass_to_string(i), (unsigned long)st->qclass[i]))
 2454             return;
 2455     }
 2456 
 2457     /* rcode */
 2458     for(i=0; i<17; i++) {
 2459         if(inhibit_zero && st->rcode[i] == 0 &&
 2460             i > RCODE_YXDOMAIN) /* NSD does not use larger */
 2461             continue;
 2462         if(!ssl_printf(ssl, "%s%snum.rcode.%s=%lu\n", n, d, rcstr[i],
 2463             (unsigned long)st->rcode[i]))
 2464             return;
 2465     }
 2466 
 2467     /* edns */
 2468     if(!ssl_printf(ssl, "%s%snum.edns=%lu\n", n, d, (unsigned long)st->edns))
 2469         return;
 2470 
 2471     /* ednserr */
 2472     if(!ssl_printf(ssl, "%s%snum.ednserr=%lu\n", n, d,
 2473         (unsigned long)st->ednserr))
 2474         return;
 2475 
 2476     /* qudp */
 2477     if(!ssl_printf(ssl, "%s%snum.udp=%lu\n", n, d, (unsigned long)st->qudp))
 2478         return;
 2479     /* qudp6 */
 2480     if(!ssl_printf(ssl, "%s%snum.udp6=%lu\n", n, d, (unsigned long)st->qudp6))
 2481         return;
 2482     /* ctcp */
 2483     if(!ssl_printf(ssl, "%s%snum.tcp=%lu\n", n, d, (unsigned long)st->ctcp))
 2484         return;
 2485     /* ctcp6 */
 2486     if(!ssl_printf(ssl, "%s%snum.tcp6=%lu\n", n, d, (unsigned long)st->ctcp6))
 2487         return;
 2488     /* ctls */
 2489     if(!ssl_printf(ssl, "%s%snum.tls=%lu\n", n, d, (unsigned long)st->ctls))
 2490         return;
 2491     /* ctls6 */
 2492     if(!ssl_printf(ssl, "%s%snum.tls6=%lu\n", n, d, (unsigned long)st->ctls6))
 2493         return;
 2494 
 2495     /* nona */
 2496     if(!ssl_printf(ssl, "%s%snum.answer_wo_aa=%lu\n", n, d,
 2497         (unsigned long)st->nona))
 2498         return;
 2499 
 2500     /* rxerr */
 2501     if(!ssl_printf(ssl, "%s%snum.rxerr=%lu\n", n, d, (unsigned long)st->rxerr))
 2502         return;
 2503 
 2504     /* txerr */
 2505     if(!ssl_printf(ssl, "%s%snum.txerr=%lu\n", n, d, (unsigned long)st->txerr))
 2506         return;
 2507 
 2508     /* number of requested-axfr, number of times axfr served to clients */
 2509     if(!ssl_printf(ssl, "%s%snum.raxfr=%lu\n", n, d, (unsigned long)st->raxfr))
 2510         return;
 2511 
 2512     /* truncated */
 2513     if(!ssl_printf(ssl, "%s%snum.truncated=%lu\n", n, d,
 2514         (unsigned long)st->truncated))
 2515         return;
 2516 
 2517     /* dropped */
 2518     if(!ssl_printf(ssl, "%s%snum.dropped=%lu\n", n, d,
 2519         (unsigned long)st->dropped))
 2520         return;
 2521 }
 2522 
 2523 #ifdef USE_ZONE_STATS
 2524 static void
 2525 resize_zonestat(xfrd_state_type* xfrd, size_t num)
 2526 {
 2527     struct nsdst** a = xalloc_array_zero(num, sizeof(struct nsdst*));
 2528     if(xfrd->zonestat_clear_num != 0)
 2529         memcpy(a, xfrd->zonestat_clear, xfrd->zonestat_clear_num
 2530             * sizeof(struct nsdst*));
 2531     free(xfrd->zonestat_clear);
 2532     xfrd->zonestat_clear = a;
 2533     xfrd->zonestat_clear_num = num;
 2534 }
 2535 
 2536 static void
 2537 zonestat_print(RES* ssl, xfrd_state_type* xfrd, int clear)
 2538 {
 2539     struct zonestatname* n;
 2540     struct nsdst stat0, stat1;
 2541     RBTREE_FOR(n, struct zonestatname*, xfrd->nsd->options->zonestatnames){
 2542         char* name = (char*)n->node.key;
 2543         if(n->id >= xfrd->zonestat_safe)
 2544             continue; /* newly allocated and reload has not yet
 2545                 done and replied with new size */
 2546         if(name == NULL || name[0]==0)
 2547             continue; /* empty name, do not output */
 2548         /* the statistics are stored in two blocks, during reload
 2549          * the newly forked processes get the other block to use,
 2550          * these blocks are mmapped and are currently in use to
 2551          * add statistics to */
 2552         memcpy(&stat0, &xfrd->nsd->zonestat[0][n->id], sizeof(stat0));
 2553         memcpy(&stat1, &xfrd->nsd->zonestat[1][n->id], sizeof(stat1));
 2554         stats_add(&stat0, &stat1);
 2555         
 2556         /* save a copy of current (cumulative) stats in stat1 */
 2557         memcpy(&stat1, &stat0, sizeof(stat1));
 2558         /* subtract last total of stats that was 'cleared' */
 2559         if(n->id < xfrd->zonestat_clear_num &&
 2560             xfrd->zonestat_clear[n->id])
 2561             stats_subtract(&stat0, xfrd->zonestat_clear[n->id]);
 2562         if(clear) {
 2563             /* extend storage array if needed */
 2564             if(n->id >= xfrd->zonestat_clear_num) {
 2565                 if(n->id+1 < xfrd->nsd->options->zonestatnames->count)
 2566                     resize_zonestat(xfrd, xfrd->nsd->options->zonestatnames->count);
 2567                 else
 2568                     resize_zonestat(xfrd, n->id+1);
 2569             }
 2570             if(!xfrd->zonestat_clear[n->id])
 2571                 xfrd->zonestat_clear[n->id] = xalloc(
 2572                     sizeof(struct nsdst));
 2573             /* store last total of stats */
 2574             memcpy(xfrd->zonestat_clear[n->id], &stat1,
 2575                 sizeof(struct nsdst));
 2576         }
 2577 
 2578         /* stat0 contains the details that we want to print */
 2579         if(!ssl_printf(ssl, "%s%snum.queries=%lu\n", name, ".",
 2580             (unsigned long)(stat0.qudp + stat0.qudp6 + stat0.ctcp +
 2581                 stat0.ctcp6 + stat0.ctls + stat0.ctls6)))
 2582             return;
 2583         print_stat_block(ssl, name, ".", &stat0);
 2584     }
 2585 }
 2586 #endif /* USE_ZONE_STATS */
 2587 
 2588 static void
 2589 print_stats(RES* ssl, xfrd_state_type* xfrd, struct timeval* now, int clear)
 2590 {
 2591     size_t i;
 2592     stc_type total = 0;
 2593     struct timeval elapsed, uptime;
 2594 
 2595     /* per CPU and total */
 2596     for(i=0; i<xfrd->nsd->child_count; i++) {
 2597         if(!ssl_printf(ssl, "server%d.queries=%lu\n", (int)i,
 2598             (unsigned long)xfrd->nsd->children[i].query_count))
 2599             return;
 2600         total += xfrd->nsd->children[i].query_count;
 2601     }
 2602     if(!ssl_printf(ssl, "num.queries=%lu\n", (unsigned long)total))
 2603         return;
 2604 
 2605     /* time elapsed and uptime (in seconds) */
 2606     timeval_subtract(&uptime, now, &xfrd->nsd->rc->boot_time);
 2607     timeval_subtract(&elapsed, now, &xfrd->nsd->rc->stats_time);
 2608     if(!ssl_printf(ssl, "time.boot=%lu.%6.6lu\n",
 2609         (unsigned long)uptime.tv_sec, (unsigned long)uptime.tv_usec))
 2610         return;
 2611     if(!ssl_printf(ssl, "time.elapsed=%lu.%6.6lu\n",
 2612         (unsigned long)elapsed.tv_sec, (unsigned long)elapsed.tv_usec))
 2613         return;
 2614 
 2615     /* mem info, database on disksize */
 2616     if(!print_longnum(ssl, "size.db.disk=", xfrd->nsd->st.db_disk))
 2617         return;
 2618     if(!print_longnum(ssl, "size.db.mem=", xfrd->nsd->st.db_mem))
 2619         return;
 2620     if(!print_longnum(ssl, "size.xfrd.mem=", region_get_mem(xfrd->region)))
 2621         return;
 2622     if(!print_longnum(ssl, "size.config.disk=", 
 2623         xfrd->nsd->options->zonelist_off))
 2624         return;
 2625     if(!print_longnum(ssl, "size.config.mem=", region_get_mem(
 2626         xfrd->nsd->options->region)))
 2627         return;
 2628     print_stat_block(ssl, "", "", &xfrd->nsd->st);
 2629 
 2630     /* zone statistics */
 2631     if(!ssl_printf(ssl, "zone.master=%lu\n",
 2632         (unsigned long)(xfrd->notify_zones->count - xfrd->zones->count)))
 2633         return;
 2634     if(!ssl_printf(ssl, "zone.slave=%lu\n", (unsigned long)xfrd->zones->count))
 2635         return;
 2636 #ifdef USE_ZONE_STATS
 2637     zonestat_print(ssl, xfrd, clear); /* per-zone statistics */
 2638 #else
 2639     (void)clear;
 2640 #endif
 2641 }
 2642 
 2643 static void
 2644 clear_stats(xfrd_state_type* xfrd)
 2645 {
 2646     size_t i;
 2647     uint64_t dbd = xfrd->nsd->st.db_disk;
 2648     uint64_t dbm = xfrd->nsd->st.db_mem;
 2649     for(i=0; i<xfrd->nsd->child_count; i++) {
 2650         xfrd->nsd->children[i].query_count = 0;
 2651     }
 2652     memset(&xfrd->nsd->st, 0, sizeof(struct nsdst));
 2653     /* zonestats are cleared by storing the cumulative value that
 2654      * was last printed in the zonestat_clear array, and subtracting
 2655      * that before the next stats printout */
 2656     xfrd->nsd->st.db_disk = dbd;
 2657     xfrd->nsd->st.db_mem = dbm;
 2658 }
 2659 
 2660 void
 2661 daemon_remote_process_stats(struct daemon_remote* rc)
 2662 {
 2663     RES res;
 2664     struct rc_state* s;
 2665     struct timeval now;
 2666     if(!rc) return;
 2667     if(gettimeofday(&now, NULL) == -1)
 2668         log_msg(LOG_ERR, "gettimeofday: %s", strerror(errno));
 2669     /* pop one and give it stats */
 2670     while((s = rc->stats_list)) {
 2671         assert(s->in_stats_list);
 2672         res.ssl = s->ssl;
 2673         res.fd = s->fd;
 2674         print_stats(&res, rc->xfrd, &now, (s->in_stats_list == 1));
 2675         if(s->in_stats_list == 1) {
 2676             clear_stats(rc->xfrd);
 2677             rc->stats_time = now;
 2678         }
 2679         VERBOSITY(3, (LOG_INFO, "remote control stats printed"));
 2680         rc->stats_list = s->next;
 2681         s->in_stats_list = 0;
 2682         clean_point(rc, s);
 2683     }
 2684 }
 2685 #endif /* BIND8_STATS */
 2686 
 2687 int
 2688 create_local_accept_sock(const char *path, int* noproto)
 2689 {
 2690 #ifdef HAVE_SYS_UN_H
 2691     int s;
 2692     struct sockaddr_un usock;
 2693 
 2694     VERBOSITY(3, (LOG_INFO, "creating unix socket %s", path));
 2695 #ifdef HAVE_STRUCT_SOCKADDR_UN_SUN_LEN
 2696     /* this member exists on BSDs, not Linux */
 2697     usock.sun_len = (unsigned)sizeof(usock);
 2698 #endif
 2699     usock.sun_family = AF_LOCAL;
 2700     /* length is 92-108, 104 on FreeBSD */
 2701     (void)strlcpy(usock.sun_path, path, sizeof(usock.sun_path));
 2702 
 2703     if ((s = socket(AF_LOCAL, SOCK_STREAM, 0)) == -1) {
 2704         log_msg(LOG_ERR, "Cannot create local socket %s (%s)",
 2705             path, strerror(errno));
 2706         return -1;
 2707     }
 2708 
 2709     if (unlink(path) && errno != ENOENT) {
 2710         /* The socket already exists and cannot be removed */
 2711         log_msg(LOG_ERR, "Cannot remove old local socket %s (%s)",
 2712             path, strerror(errno));
 2713         goto err;
 2714     }
 2715 
 2716     if (bind(s, (struct sockaddr *)&usock,
 2717         (socklen_t)sizeof(struct sockaddr_un)) == -1) {
 2718         log_msg(LOG_ERR, "Cannot bind local socket %s (%s)",
 2719             path, strerror(errno));
 2720         goto err;
 2721     }
 2722 
 2723     if (fcntl(s, F_SETFL, O_NONBLOCK) == -1) {
 2724         log_msg(LOG_ERR, "Cannot set non-blocking mode");
 2725         goto err;
 2726     }
 2727 
 2728     if (listen(s, TCP_BACKLOG) == -1) {
 2729         log_msg(LOG_ERR, "can't listen: %s", strerror(errno));
 2730         goto err;
 2731     }
 2732 
 2733     (void)noproto; /*unused*/
 2734     return s;
 2735 
 2736 err:
 2737     close(s);
 2738     return -1;
 2739 
 2740 #else
 2741     (void)path;
 2742     log_msg(LOG_ERR, "Local sockets are not supported");
 2743     *noproto = 1;
 2744     return -1;
 2745 #endif
 2746 }
 2747 
 2748 #endif /* HAVE_SSL */