1238106Sdes/* 2238106Sdes * daemon/remote.c - remote control for the unbound daemon. 3238106Sdes * 4238106Sdes * Copyright (c) 2008, NLnet Labs. All rights reserved. 5238106Sdes * 6238106Sdes * This software is open source. 7238106Sdes * 8238106Sdes * Redistribution and use in source and binary forms, with or without 9238106Sdes * modification, are permitted provided that the following conditions 10238106Sdes * are met: 11238106Sdes * 12238106Sdes * Redistributions of source code must retain the above copyright notice, 13238106Sdes * this list of conditions and the following disclaimer. 14238106Sdes * 15238106Sdes * Redistributions in binary form must reproduce the above copyright notice, 16238106Sdes * this list of conditions and the following disclaimer in the documentation 17238106Sdes * and/or other materials provided with the distribution. 18238106Sdes * 19238106Sdes * Neither the name of the NLNET LABS nor the names of its contributors may 20238106Sdes * be used to endorse or promote products derived from this software without 21238106Sdes * specific prior written permission. 22238106Sdes * 23238106Sdes * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 24269257Sdes * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 25269257Sdes * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 26269257Sdes * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 27269257Sdes * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 28269257Sdes * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 29269257Sdes * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 30269257Sdes * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 31269257Sdes * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 32269257Sdes * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 33269257Sdes * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34238106Sdes */ 35238106Sdes 36238106Sdes/** 37238106Sdes * \file 38238106Sdes * 39238106Sdes * This file contains the remote control functionality for the daemon. 40238106Sdes * The remote control can be performed using either the commandline 41285206Sdes * unbound-control tool, or a TLS capable web browser. 42285206Sdes * The channel is secured using TLSv1, and certificates. 43238106Sdes * Both the server and the client(control tool) have their own keys. 44238106Sdes */ 45238106Sdes#include "config.h" 46238106Sdes#ifdef HAVE_OPENSSL_ERR_H 47238106Sdes#include <openssl/err.h> 48238106Sdes#endif 49285206Sdes#ifndef HEADER_DH_H 50285206Sdes#include <openssl/dh.h> 51285206Sdes#endif 52285206Sdes 53238106Sdes#include <ctype.h> 54238106Sdes#include "daemon/remote.h" 55238106Sdes#include "daemon/worker.h" 56238106Sdes#include "daemon/daemon.h" 57238106Sdes#include "daemon/stats.h" 58238106Sdes#include "daemon/cachedump.h" 59238106Sdes#include "util/log.h" 60238106Sdes#include "util/config_file.h" 61238106Sdes#include "util/net_help.h" 62238106Sdes#include "util/module.h" 63238106Sdes#include "services/listen_dnsport.h" 64238106Sdes#include "services/cache/rrset.h" 65238106Sdes#include "services/cache/infra.h" 66238106Sdes#include "services/mesh.h" 67238106Sdes#include "services/localzone.h" 68238106Sdes#include "util/storage/slabhash.h" 69238106Sdes#include "util/fptr_wlist.h" 70238106Sdes#include "util/data/dname.h" 71238106Sdes#include "validator/validator.h" 72238106Sdes#include "validator/val_kcache.h" 73238106Sdes#include "validator/val_kentry.h" 74238106Sdes#include "validator/val_anchor.h" 75238106Sdes#include "iterator/iterator.h" 76238106Sdes#include "iterator/iter_fwd.h" 77238106Sdes#include "iterator/iter_hints.h" 78238106Sdes#include "iterator/iter_delegpt.h" 79238106Sdes#include "services/outbound_list.h" 80238106Sdes#include "services/outside_network.h" 81269257Sdes#include "ldns/str2wire.h" 82269257Sdes#include "ldns/parseutil.h" 83269257Sdes#include "ldns/wire2str.h" 84269257Sdes#include "ldns/sbuffer.h" 85238106Sdes 86238106Sdes#ifdef HAVE_SYS_TYPES_H 87238106Sdes# include <sys/types.h> 88238106Sdes#endif 89285206Sdes#ifdef HAVE_SYS_STAT_H 90285206Sdes#include <sys/stat.h> 91285206Sdes#endif 92238106Sdes#ifdef HAVE_NETDB_H 93238106Sdes#include <netdb.h> 94238106Sdes#endif 95238106Sdes 96238106Sdes/* just for portability */ 97238106Sdes#ifdef SQ 98238106Sdes#undef SQ 99238106Sdes#endif 100238106Sdes 101238106Sdes/** what to put on statistics lines between var and value, ": " or "=" */ 102238106Sdes#define SQ "=" 103238106Sdes/** if true, inhibits a lot of =0 lines from the stats output */ 104238106Sdesstatic const int inhibit_zero = 1; 105238106Sdes 106238106Sdes/** subtract timers and the values do not overflow or become negative */ 107238106Sdesstatic void 108238106Sdestimeval_subtract(struct timeval* d, const struct timeval* end, 109238106Sdes const struct timeval* start) 110238106Sdes{ 111238106Sdes#ifndef S_SPLINT_S 112238106Sdes time_t end_usec = end->tv_usec; 113238106Sdes d->tv_sec = end->tv_sec - start->tv_sec; 114238106Sdes if(end_usec < start->tv_usec) { 115238106Sdes end_usec += 1000000; 116238106Sdes d->tv_sec--; 117238106Sdes } 118238106Sdes d->tv_usec = end_usec - start->tv_usec; 119238106Sdes#endif 120238106Sdes} 121238106Sdes 122238106Sdes/** divide sum of timers to get average */ 123238106Sdesstatic void 124238106Sdestimeval_divide(struct timeval* avg, const struct timeval* sum, size_t d) 125238106Sdes{ 126238106Sdes#ifndef S_SPLINT_S 127238106Sdes size_t leftover; 128238106Sdes if(d == 0) { 129238106Sdes avg->tv_sec = 0; 130238106Sdes avg->tv_usec = 0; 131238106Sdes return; 132238106Sdes } 133238106Sdes avg->tv_sec = sum->tv_sec / d; 134238106Sdes avg->tv_usec = sum->tv_usec / d; 135238106Sdes /* handle fraction from seconds divide */ 136238106Sdes leftover = sum->tv_sec - avg->tv_sec*d; 137238106Sdes avg->tv_usec += (leftover*1000000)/d; 138238106Sdes#endif 139238106Sdes} 140238106Sdes 141285206Sdes/* 142285206Sdes * The following function was generated using the openssl utility, using 143285206Sdes * the command : "openssl dhparam -dsaparam -C 512" 144285206Sdes */ 145285206Sdes#ifndef S_SPLINT_S 146285206SdesDH *get_dh512() 147285206Sdes{ 148285206Sdes static unsigned char dh512_p[]={ 149285206Sdes 0xC9,0xD7,0x05,0xDA,0x5F,0xAB,0x14,0xE8,0x11,0x56,0x77,0x85, 150285206Sdes 0xB1,0x24,0x2C,0x95,0x60,0xEA,0xE2,0x10,0x6F,0x0F,0x84,0xEC, 151285206Sdes 0xF4,0x45,0xE8,0x90,0x7A,0xA7,0x03,0xFF,0x5B,0x88,0x53,0xDE, 152285206Sdes 0xC4,0xDE,0xBC,0x42,0x78,0x71,0x23,0x7E,0x24,0xA5,0x5E,0x4E, 153285206Sdes 0xEF,0x6F,0xFF,0x5F,0xAF,0xBE,0x8A,0x77,0x62,0xB4,0x65,0x82, 154285206Sdes 0x7E,0xC9,0xED,0x2F, 155285206Sdes }; 156285206Sdes static unsigned char dh512_g[]={ 157285206Sdes 0x8D,0x3A,0x52,0xBC,0x8A,0x71,0x94,0x33,0x2F,0xE1,0xE8,0x4C, 158285206Sdes 0x73,0x47,0x03,0x4E,0x7D,0x40,0xE5,0x84,0xA0,0xB5,0x6D,0x10, 159285206Sdes 0x6F,0x90,0x43,0x05,0x1A,0xF9,0x0B,0x6A,0xD1,0x2A,0x9C,0x25, 160285206Sdes 0x0A,0xB9,0xD1,0x14,0xDC,0x35,0x1C,0x48,0x7C,0xC6,0x0C,0x6D, 161285206Sdes 0x32,0x1D,0xD3,0xC8,0x10,0xA8,0x82,0x14,0xA2,0x1C,0xF4,0x53, 162285206Sdes 0x23,0x3B,0x1C,0xB9, 163285206Sdes }; 164285206Sdes DH *dh; 165285206Sdes 166285206Sdes if ((dh=DH_new()) == NULL) return(NULL); 167285206Sdes dh->p=BN_bin2bn(dh512_p,sizeof(dh512_p),NULL); 168285206Sdes dh->g=BN_bin2bn(dh512_g,sizeof(dh512_g),NULL); 169285206Sdes if ((dh->p == NULL) || (dh->g == NULL)) 170285206Sdes { DH_free(dh); return(NULL); } 171285206Sdes dh->length = 160; 172285206Sdes return(dh); 173285206Sdes} 174285206Sdes#endif /* SPLINT */ 175285206Sdes 176238106Sdesstruct daemon_remote* 177238106Sdesdaemon_remote_create(struct config_file* cfg) 178238106Sdes{ 179238106Sdes char* s_cert; 180238106Sdes char* s_key; 181238106Sdes struct daemon_remote* rc = (struct daemon_remote*)calloc(1, 182238106Sdes sizeof(*rc)); 183238106Sdes if(!rc) { 184238106Sdes log_err("out of memory in daemon_remote_create"); 185238106Sdes return NULL; 186238106Sdes } 187238106Sdes rc->max_active = 10; 188238106Sdes 189238106Sdes if(!cfg->remote_control_enable) { 190238106Sdes rc->ctx = NULL; 191238106Sdes return rc; 192238106Sdes } 193238106Sdes rc->ctx = SSL_CTX_new(SSLv23_server_method()); 194238106Sdes if(!rc->ctx) { 195238106Sdes log_crypto_err("could not SSL_CTX_new"); 196238106Sdes free(rc); 197238106Sdes return NULL; 198238106Sdes } 199285206Sdes /* no SSLv2, SSLv3 because has defects */ 200238106Sdes if(!(SSL_CTX_set_options(rc->ctx, SSL_OP_NO_SSLv2) & SSL_OP_NO_SSLv2)){ 201238106Sdes log_crypto_err("could not set SSL_OP_NO_SSLv2"); 202238106Sdes daemon_remote_delete(rc); 203238106Sdes return NULL; 204238106Sdes } 205285206Sdes if(!(SSL_CTX_set_options(rc->ctx, SSL_OP_NO_SSLv3) & SSL_OP_NO_SSLv3)){ 206285206Sdes log_crypto_err("could not set SSL_OP_NO_SSLv3"); 207285206Sdes daemon_remote_delete(rc); 208285206Sdes return NULL; 209285206Sdes } 210285206Sdes 211285206Sdes if (cfg->remote_control_use_cert == 0) { 212285206Sdes /* No certificates are requested */ 213285206Sdes if(!SSL_CTX_set_cipher_list(rc->ctx, "aNULL")) { 214285206Sdes log_crypto_err("Failed to set aNULL cipher list"); 215285206Sdes return NULL; 216285206Sdes } 217285206Sdes 218285206Sdes /* Since we have no certificates and hence no source of 219285206Sdes * DH params, let's generate and set them 220285206Sdes */ 221285206Sdes if(!SSL_CTX_set_tmp_dh(rc->ctx,get_dh512())) { 222285206Sdes log_crypto_err("Wanted to set DH param, but failed"); 223285206Sdes return NULL; 224285206Sdes } 225285206Sdes return rc; 226285206Sdes } 227285206Sdes rc->use_cert = 1; 228238106Sdes s_cert = fname_after_chroot(cfg->server_cert_file, cfg, 1); 229238106Sdes s_key = fname_after_chroot(cfg->server_key_file, cfg, 1); 230238106Sdes if(!s_cert || !s_key) { 231238106Sdes log_err("out of memory in remote control fname"); 232238106Sdes goto setup_error; 233238106Sdes } 234238106Sdes verbose(VERB_ALGO, "setup SSL certificates"); 235238106Sdes if (!SSL_CTX_use_certificate_file(rc->ctx,s_cert,SSL_FILETYPE_PEM)) { 236238106Sdes log_err("Error for server-cert-file: %s", s_cert); 237238106Sdes log_crypto_err("Error in SSL_CTX use_certificate_file"); 238238106Sdes goto setup_error; 239238106Sdes } 240238106Sdes if(!SSL_CTX_use_PrivateKey_file(rc->ctx,s_key,SSL_FILETYPE_PEM)) { 241238106Sdes log_err("Error for server-key-file: %s", s_key); 242238106Sdes log_crypto_err("Error in SSL_CTX use_PrivateKey_file"); 243238106Sdes goto setup_error; 244238106Sdes } 245238106Sdes if(!SSL_CTX_check_private_key(rc->ctx)) { 246238106Sdes log_err("Error for server-key-file: %s", s_key); 247238106Sdes log_crypto_err("Error in SSL_CTX check_private_key"); 248238106Sdes goto setup_error; 249238106Sdes } 250238106Sdes if(!SSL_CTX_load_verify_locations(rc->ctx, s_cert, NULL)) { 251238106Sdes log_crypto_err("Error setting up SSL_CTX verify locations"); 252238106Sdes setup_error: 253238106Sdes free(s_cert); 254238106Sdes free(s_key); 255238106Sdes daemon_remote_delete(rc); 256238106Sdes return NULL; 257238106Sdes } 258238106Sdes SSL_CTX_set_client_CA_list(rc->ctx, SSL_load_client_CA_file(s_cert)); 259238106Sdes SSL_CTX_set_verify(rc->ctx, SSL_VERIFY_PEER, NULL); 260238106Sdes free(s_cert); 261238106Sdes free(s_key); 262238106Sdes 263238106Sdes return rc; 264238106Sdes} 265238106Sdes 266238106Sdesvoid daemon_remote_clear(struct daemon_remote* rc) 267238106Sdes{ 268238106Sdes struct rc_state* p, *np; 269238106Sdes if(!rc) return; 270238106Sdes /* but do not close the ports */ 271238106Sdes listen_list_delete(rc->accept_list); 272238106Sdes rc->accept_list = NULL; 273238106Sdes /* do close these sockets */ 274238106Sdes p = rc->busy_list; 275238106Sdes while(p) { 276238106Sdes np = p->next; 277238106Sdes if(p->ssl) 278238106Sdes SSL_free(p->ssl); 279238106Sdes comm_point_delete(p->c); 280238106Sdes free(p); 281238106Sdes p = np; 282238106Sdes } 283238106Sdes rc->busy_list = NULL; 284238106Sdes rc->active = 0; 285238106Sdes rc->worker = NULL; 286238106Sdes} 287238106Sdes 288238106Sdesvoid daemon_remote_delete(struct daemon_remote* rc) 289238106Sdes{ 290238106Sdes if(!rc) return; 291238106Sdes daemon_remote_clear(rc); 292238106Sdes if(rc->ctx) { 293238106Sdes SSL_CTX_free(rc->ctx); 294238106Sdes } 295238106Sdes free(rc); 296238106Sdes} 297238106Sdes 298238106Sdes/** 299238106Sdes * Add and open a new control port 300238106Sdes * @param ip: ip str 301238106Sdes * @param nr: port nr 302238106Sdes * @param list: list head 303238106Sdes * @param noproto_is_err: if lack of protocol support is an error. 304285206Sdes * @param cfg: config with username for chown of unix-sockets. 305238106Sdes * @return false on failure. 306238106Sdes */ 307238106Sdesstatic int 308285206Sdesadd_open(const char* ip, int nr, struct listen_port** list, int noproto_is_err, 309285206Sdes struct config_file* cfg) 310238106Sdes{ 311238106Sdes struct addrinfo hints; 312238106Sdes struct addrinfo* res; 313238106Sdes struct listen_port* n; 314238106Sdes int noproto; 315238106Sdes int fd, r; 316238106Sdes char port[15]; 317238106Sdes snprintf(port, sizeof(port), "%d", nr); 318238106Sdes port[sizeof(port)-1]=0; 319238106Sdes memset(&hints, 0, sizeof(hints)); 320285206Sdes 321285206Sdes if(ip[0] == '/') { 322285206Sdes /* This looks like a local socket */ 323285206Sdes fd = create_local_accept_sock(ip, &noproto); 324285206Sdes /* 325285206Sdes * Change socket ownership and permissions so users other 326285206Sdes * than root can access it provided they are in the same 327285206Sdes * group as the user we run as. 328285206Sdes */ 329285206Sdes if(fd != -1) { 330285206Sdes#ifdef HAVE_CHOWN 331285206Sdes if (cfg->username && cfg->username[0] && 332285206Sdes cfg_uid != (uid_t)-1) 333285206Sdes chown(ip, cfg_uid, cfg_gid); 334285206Sdes chmod(ip, (mode_t)(S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP)); 335285206Sdes#else 336285206Sdes (void)cfg; 337285206Sdes#endif 338285206Sdes } 339285206Sdes } else { 340285206Sdes hints.ai_socktype = SOCK_STREAM; 341285206Sdes hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST; 342285206Sdes if((r = getaddrinfo(ip, port, &hints, &res)) != 0 || !res) { 343238106Sdes#ifdef USE_WINSOCK 344285206Sdes if(!noproto_is_err && r == EAI_NONAME) { 345285206Sdes /* tried to lookup the address as name */ 346285206Sdes return 1; /* return success, but do nothing */ 347285206Sdes } 348238106Sdes#endif /* USE_WINSOCK */ 349285206Sdes log_err("control interface %s:%s getaddrinfo: %s %s", 350285206Sdes ip?ip:"default", port, gai_strerror(r), 351238106Sdes#ifdef EAI_SYSTEM 352285206Sdes r==EAI_SYSTEM?(char*)strerror(errno):"" 353238106Sdes#else 354285206Sdes "" 355238106Sdes#endif 356238106Sdes ); 357285206Sdes return 0; 358285206Sdes } 359285206Sdes 360285206Sdes /* open fd */ 361285206Sdes fd = create_tcp_accept_sock(res, 1, &noproto, 0); 362285206Sdes freeaddrinfo(res); 363238106Sdes } 364238106Sdes 365238106Sdes if(fd == -1 && noproto) { 366238106Sdes if(!noproto_is_err) 367238106Sdes return 1; /* return success, but do nothing */ 368238106Sdes log_err("cannot open control interface %s %d : " 369238106Sdes "protocol not supported", ip, nr); 370238106Sdes return 0; 371238106Sdes } 372238106Sdes if(fd == -1) { 373238106Sdes log_err("cannot open control interface %s %d", ip, nr); 374238106Sdes return 0; 375238106Sdes } 376238106Sdes 377238106Sdes /* alloc */ 378238106Sdes n = (struct listen_port*)calloc(1, sizeof(*n)); 379238106Sdes if(!n) { 380238106Sdes#ifndef USE_WINSOCK 381238106Sdes close(fd); 382238106Sdes#else 383238106Sdes closesocket(fd); 384238106Sdes#endif 385238106Sdes log_err("out of memory"); 386238106Sdes return 0; 387238106Sdes } 388238106Sdes n->next = *list; 389238106Sdes *list = n; 390238106Sdes n->fd = fd; 391238106Sdes return 1; 392238106Sdes} 393238106Sdes 394238106Sdesstruct listen_port* daemon_remote_open_ports(struct config_file* cfg) 395238106Sdes{ 396238106Sdes struct listen_port* l = NULL; 397238106Sdes log_assert(cfg->remote_control_enable && cfg->control_port); 398238106Sdes if(cfg->control_ifs) { 399238106Sdes struct config_strlist* p; 400238106Sdes for(p = cfg->control_ifs; p; p = p->next) { 401285206Sdes if(!add_open(p->str, cfg->control_port, &l, 1, cfg)) { 402238106Sdes listening_ports_free(l); 403238106Sdes return NULL; 404238106Sdes } 405238106Sdes } 406238106Sdes } else { 407238106Sdes /* defaults */ 408238106Sdes if(cfg->do_ip6 && 409285206Sdes !add_open("::1", cfg->control_port, &l, 0, cfg)) { 410238106Sdes listening_ports_free(l); 411238106Sdes return NULL; 412238106Sdes } 413238106Sdes if(cfg->do_ip4 && 414285206Sdes !add_open("127.0.0.1", cfg->control_port, &l, 1, cfg)) { 415238106Sdes listening_ports_free(l); 416238106Sdes return NULL; 417238106Sdes } 418238106Sdes } 419238106Sdes return l; 420238106Sdes} 421238106Sdes 422238106Sdes/** open accept commpoint */ 423238106Sdesstatic int 424238106Sdesaccept_open(struct daemon_remote* rc, int fd) 425238106Sdes{ 426238106Sdes struct listen_list* n = (struct listen_list*)malloc(sizeof(*n)); 427238106Sdes if(!n) { 428238106Sdes log_err("out of memory"); 429238106Sdes return 0; 430238106Sdes } 431238106Sdes n->next = rc->accept_list; 432238106Sdes rc->accept_list = n; 433238106Sdes /* open commpt */ 434238106Sdes n->com = comm_point_create_raw(rc->worker->base, fd, 0, 435238106Sdes &remote_accept_callback, rc); 436238106Sdes if(!n->com) 437238106Sdes return 0; 438238106Sdes /* keep this port open, its fd is kept in the rc portlist */ 439238106Sdes n->com->do_not_close = 1; 440238106Sdes return 1; 441238106Sdes} 442238106Sdes 443238106Sdesint daemon_remote_open_accept(struct daemon_remote* rc, 444238106Sdes struct listen_port* ports, struct worker* worker) 445238106Sdes{ 446238106Sdes struct listen_port* p; 447238106Sdes rc->worker = worker; 448238106Sdes for(p = ports; p; p = p->next) { 449238106Sdes if(!accept_open(rc, p->fd)) { 450238106Sdes log_err("could not create accept comm point"); 451238106Sdes return 0; 452238106Sdes } 453238106Sdes } 454238106Sdes return 1; 455238106Sdes} 456238106Sdes 457238106Sdesvoid daemon_remote_stop_accept(struct daemon_remote* rc) 458238106Sdes{ 459238106Sdes struct listen_list* p; 460238106Sdes for(p=rc->accept_list; p; p=p->next) { 461238106Sdes comm_point_stop_listening(p->com); 462238106Sdes } 463238106Sdes} 464238106Sdes 465238106Sdesvoid daemon_remote_start_accept(struct daemon_remote* rc) 466238106Sdes{ 467238106Sdes struct listen_list* p; 468238106Sdes for(p=rc->accept_list; p; p=p->next) { 469238106Sdes comm_point_start_listening(p->com, -1, -1); 470238106Sdes } 471238106Sdes} 472238106Sdes 473238106Sdesint remote_accept_callback(struct comm_point* c, void* arg, int err, 474238106Sdes struct comm_reply* ATTR_UNUSED(rep)) 475238106Sdes{ 476238106Sdes struct daemon_remote* rc = (struct daemon_remote*)arg; 477238106Sdes struct sockaddr_storage addr; 478238106Sdes socklen_t addrlen; 479238106Sdes int newfd; 480238106Sdes struct rc_state* n; 481238106Sdes if(err != NETEVENT_NOERROR) { 482238106Sdes log_err("error %d on remote_accept_callback", err); 483238106Sdes return 0; 484238106Sdes } 485238106Sdes /* perform the accept */ 486238106Sdes newfd = comm_point_perform_accept(c, &addr, &addrlen); 487238106Sdes if(newfd == -1) 488238106Sdes return 0; 489238106Sdes /* create new commpoint unless we are servicing already */ 490238106Sdes if(rc->active >= rc->max_active) { 491238106Sdes log_warn("drop incoming remote control: too many connections"); 492238106Sdes close_exit: 493238106Sdes#ifndef USE_WINSOCK 494238106Sdes close(newfd); 495238106Sdes#else 496238106Sdes closesocket(newfd); 497238106Sdes#endif 498238106Sdes return 0; 499238106Sdes } 500238106Sdes 501238106Sdes /* setup commpoint to service the remote control command */ 502238106Sdes n = (struct rc_state*)calloc(1, sizeof(*n)); 503238106Sdes if(!n) { 504238106Sdes log_err("out of memory"); 505238106Sdes goto close_exit; 506238106Sdes } 507238106Sdes /* start in reading state */ 508238106Sdes n->c = comm_point_create_raw(rc->worker->base, newfd, 0, 509238106Sdes &remote_control_callback, n); 510238106Sdes if(!n->c) { 511238106Sdes log_err("out of memory"); 512238106Sdes free(n); 513238106Sdes goto close_exit; 514238106Sdes } 515238106Sdes log_addr(VERB_QUERY, "new control connection from", &addr, addrlen); 516238106Sdes n->c->do_not_close = 0; 517238106Sdes comm_point_stop_listening(n->c); 518238106Sdes comm_point_start_listening(n->c, -1, REMOTE_CONTROL_TCP_TIMEOUT); 519238106Sdes memcpy(&n->c->repinfo.addr, &addr, addrlen); 520238106Sdes n->c->repinfo.addrlen = addrlen; 521238106Sdes n->shake_state = rc_hs_read; 522238106Sdes n->ssl = SSL_new(rc->ctx); 523238106Sdes if(!n->ssl) { 524238106Sdes log_crypto_err("could not SSL_new"); 525238106Sdes comm_point_delete(n->c); 526238106Sdes free(n); 527238106Sdes goto close_exit; 528238106Sdes } 529238106Sdes SSL_set_accept_state(n->ssl); 530238106Sdes (void)SSL_set_mode(n->ssl, SSL_MODE_AUTO_RETRY); 531238106Sdes if(!SSL_set_fd(n->ssl, newfd)) { 532238106Sdes log_crypto_err("could not SSL_set_fd"); 533238106Sdes SSL_free(n->ssl); 534238106Sdes comm_point_delete(n->c); 535238106Sdes free(n); 536238106Sdes goto close_exit; 537238106Sdes } 538238106Sdes 539238106Sdes n->rc = rc; 540238106Sdes n->next = rc->busy_list; 541238106Sdes rc->busy_list = n; 542238106Sdes rc->active ++; 543238106Sdes 544238106Sdes /* perform the first nonblocking read already, for windows, 545238106Sdes * so it can return wouldblock. could be faster too. */ 546238106Sdes (void)remote_control_callback(n->c, n, NETEVENT_NOERROR, NULL); 547238106Sdes return 0; 548238106Sdes} 549238106Sdes 550238106Sdes/** delete from list */ 551238106Sdesstatic void 552238106Sdesstate_list_remove_elem(struct rc_state** list, struct comm_point* c) 553238106Sdes{ 554238106Sdes while(*list) { 555238106Sdes if( (*list)->c == c) { 556238106Sdes *list = (*list)->next; 557238106Sdes return; 558238106Sdes } 559238106Sdes list = &(*list)->next; 560238106Sdes } 561238106Sdes} 562238106Sdes 563238106Sdes/** decrease active count and remove commpoint from busy list */ 564238106Sdesstatic void 565238106Sdesclean_point(struct daemon_remote* rc, struct rc_state* s) 566238106Sdes{ 567238106Sdes state_list_remove_elem(&rc->busy_list, s->c); 568238106Sdes rc->active --; 569238106Sdes if(s->ssl) { 570238106Sdes SSL_shutdown(s->ssl); 571238106Sdes SSL_free(s->ssl); 572238106Sdes } 573238106Sdes comm_point_delete(s->c); 574238106Sdes free(s); 575238106Sdes} 576238106Sdes 577238106Sdesint 578238106Sdesssl_print_text(SSL* ssl, const char* text) 579238106Sdes{ 580238106Sdes int r; 581238106Sdes if(!ssl) 582238106Sdes return 0; 583238106Sdes ERR_clear_error(); 584238106Sdes if((r=SSL_write(ssl, text, (int)strlen(text))) <= 0) { 585238106Sdes if(SSL_get_error(ssl, r) == SSL_ERROR_ZERO_RETURN) { 586238106Sdes verbose(VERB_QUERY, "warning, in SSL_write, peer " 587238106Sdes "closed connection"); 588238106Sdes return 0; 589238106Sdes } 590238106Sdes log_crypto_err("could not SSL_write"); 591238106Sdes return 0; 592238106Sdes } 593238106Sdes return 1; 594238106Sdes} 595238106Sdes 596238106Sdes/** print text over the ssl connection */ 597238106Sdesstatic int 598238106Sdesssl_print_vmsg(SSL* ssl, const char* format, va_list args) 599238106Sdes{ 600238106Sdes char msg[1024]; 601238106Sdes vsnprintf(msg, sizeof(msg), format, args); 602238106Sdes return ssl_print_text(ssl, msg); 603238106Sdes} 604238106Sdes 605238106Sdes/** printf style printing to the ssl connection */ 606238106Sdesint ssl_printf(SSL* ssl, const char* format, ...) 607238106Sdes{ 608238106Sdes va_list args; 609238106Sdes int ret; 610238106Sdes va_start(args, format); 611238106Sdes ret = ssl_print_vmsg(ssl, format, args); 612238106Sdes va_end(args); 613238106Sdes return ret; 614238106Sdes} 615238106Sdes 616238106Sdesint 617238106Sdesssl_read_line(SSL* ssl, char* buf, size_t max) 618238106Sdes{ 619238106Sdes int r; 620238106Sdes size_t len = 0; 621238106Sdes if(!ssl) 622238106Sdes return 0; 623238106Sdes while(len < max) { 624238106Sdes ERR_clear_error(); 625238106Sdes if((r=SSL_read(ssl, buf+len, 1)) <= 0) { 626238106Sdes if(SSL_get_error(ssl, r) == SSL_ERROR_ZERO_RETURN) { 627238106Sdes buf[len] = 0; 628238106Sdes return 1; 629238106Sdes } 630238106Sdes log_crypto_err("could not SSL_read"); 631238106Sdes return 0; 632238106Sdes } 633238106Sdes if(buf[len] == '\n') { 634238106Sdes /* return string without \n */ 635238106Sdes buf[len] = 0; 636238106Sdes return 1; 637238106Sdes } 638238106Sdes len++; 639238106Sdes } 640238106Sdes buf[max-1] = 0; 641238106Sdes log_err("control line too long (%d): %s", (int)max, buf); 642238106Sdes return 0; 643238106Sdes} 644238106Sdes 645238106Sdes/** skip whitespace, return new pointer into string */ 646238106Sdesstatic char* 647238106Sdesskipwhite(char* str) 648238106Sdes{ 649238106Sdes /* EOS \0 is not a space */ 650285206Sdes while( isspace((unsigned char)*str) ) 651238106Sdes str++; 652238106Sdes return str; 653238106Sdes} 654238106Sdes 655238106Sdes/** send the OK to the control client */ 656238106Sdesstatic void send_ok(SSL* ssl) 657238106Sdes{ 658238106Sdes (void)ssl_printf(ssl, "ok\n"); 659238106Sdes} 660238106Sdes 661238106Sdes/** do the stop command */ 662238106Sdesstatic void 663238106Sdesdo_stop(SSL* ssl, struct daemon_remote* rc) 664238106Sdes{ 665238106Sdes rc->worker->need_to_exit = 1; 666238106Sdes comm_base_exit(rc->worker->base); 667238106Sdes send_ok(ssl); 668238106Sdes} 669238106Sdes 670238106Sdes/** do the reload command */ 671238106Sdesstatic void 672238106Sdesdo_reload(SSL* ssl, struct daemon_remote* rc) 673238106Sdes{ 674238106Sdes rc->worker->need_to_exit = 0; 675238106Sdes comm_base_exit(rc->worker->base); 676238106Sdes send_ok(ssl); 677238106Sdes} 678238106Sdes 679238106Sdes/** do the verbosity command */ 680238106Sdesstatic void 681238106Sdesdo_verbosity(SSL* ssl, char* str) 682238106Sdes{ 683238106Sdes int val = atoi(str); 684238106Sdes if(val == 0 && strcmp(str, "0") != 0) { 685238106Sdes ssl_printf(ssl, "error in verbosity number syntax: %s\n", str); 686238106Sdes return; 687238106Sdes } 688238106Sdes verbosity = val; 689238106Sdes send_ok(ssl); 690238106Sdes} 691238106Sdes 692238106Sdes/** print stats from statinfo */ 693238106Sdesstatic int 694238106Sdesprint_stats(SSL* ssl, const char* nm, struct stats_info* s) 695238106Sdes{ 696238106Sdes struct timeval avg; 697285206Sdes if(!ssl_printf(ssl, "%s.num.queries"SQ"%lu\n", nm, 698285206Sdes (unsigned long)s->svr.num_queries)) return 0; 699285206Sdes if(!ssl_printf(ssl, "%s.num.cachehits"SQ"%lu\n", nm, 700285206Sdes (unsigned long)(s->svr.num_queries 701238106Sdes - s->svr.num_queries_missed_cache))) return 0; 702285206Sdes if(!ssl_printf(ssl, "%s.num.cachemiss"SQ"%lu\n", nm, 703285206Sdes (unsigned long)s->svr.num_queries_missed_cache)) return 0; 704285206Sdes if(!ssl_printf(ssl, "%s.num.prefetch"SQ"%lu\n", nm, 705285206Sdes (unsigned long)s->svr.num_queries_prefetch)) return 0; 706285206Sdes if(!ssl_printf(ssl, "%s.num.recursivereplies"SQ"%lu\n", nm, 707285206Sdes (unsigned long)s->mesh_replies_sent)) return 0; 708238106Sdes if(!ssl_printf(ssl, "%s.requestlist.avg"SQ"%g\n", nm, 709238106Sdes (s->svr.num_queries_missed_cache+s->svr.num_queries_prefetch)? 710238106Sdes (double)s->svr.sum_query_list_size/ 711238106Sdes (s->svr.num_queries_missed_cache+ 712238106Sdes s->svr.num_queries_prefetch) : 0.0)) return 0; 713285206Sdes if(!ssl_printf(ssl, "%s.requestlist.max"SQ"%lu\n", nm, 714285206Sdes (unsigned long)s->svr.max_query_list_size)) return 0; 715285206Sdes if(!ssl_printf(ssl, "%s.requestlist.overwritten"SQ"%lu\n", nm, 716285206Sdes (unsigned long)s->mesh_jostled)) return 0; 717285206Sdes if(!ssl_printf(ssl, "%s.requestlist.exceeded"SQ"%lu\n", nm, 718285206Sdes (unsigned long)s->mesh_dropped)) return 0; 719285206Sdes if(!ssl_printf(ssl, "%s.requestlist.current.all"SQ"%lu\n", nm, 720285206Sdes (unsigned long)s->mesh_num_states)) return 0; 721285206Sdes if(!ssl_printf(ssl, "%s.requestlist.current.user"SQ"%lu\n", nm, 722285206Sdes (unsigned long)s->mesh_num_reply_states)) return 0; 723238106Sdes timeval_divide(&avg, &s->mesh_replies_sum_wait, s->mesh_replies_sent); 724269257Sdes if(!ssl_printf(ssl, "%s.recursion.time.avg"SQ ARG_LL "d.%6.6d\n", nm, 725269257Sdes (long long)avg.tv_sec, (int)avg.tv_usec)) return 0; 726238106Sdes if(!ssl_printf(ssl, "%s.recursion.time.median"SQ"%g\n", nm, 727238106Sdes s->mesh_time_median)) return 0; 728238106Sdes return 1; 729238106Sdes} 730238106Sdes 731238106Sdes/** print stats for one thread */ 732238106Sdesstatic int 733238106Sdesprint_thread_stats(SSL* ssl, int i, struct stats_info* s) 734238106Sdes{ 735238106Sdes char nm[16]; 736238106Sdes snprintf(nm, sizeof(nm), "thread%d", i); 737238106Sdes nm[sizeof(nm)-1]=0; 738238106Sdes return print_stats(ssl, nm, s); 739238106Sdes} 740238106Sdes 741238106Sdes/** print long number */ 742238106Sdesstatic int 743255579Sdesprint_longnum(SSL* ssl, const char* desc, size_t x) 744238106Sdes{ 745238106Sdes if(x > 1024*1024*1024) { 746238106Sdes /* more than a Gb */ 747238106Sdes size_t front = x / (size_t)1000000; 748238106Sdes size_t back = x % (size_t)1000000; 749238106Sdes return ssl_printf(ssl, "%s%u%6.6u\n", desc, 750238106Sdes (unsigned)front, (unsigned)back); 751238106Sdes } else { 752285206Sdes return ssl_printf(ssl, "%s%lu\n", desc, (unsigned long)x); 753238106Sdes } 754238106Sdes} 755238106Sdes 756238106Sdes/** print mem stats */ 757238106Sdesstatic int 758238106Sdesprint_mem(SSL* ssl, struct worker* worker, struct daemon* daemon) 759238106Sdes{ 760238106Sdes int m; 761238106Sdes size_t msg, rrset, val, iter; 762238106Sdes#ifdef HAVE_SBRK 763238106Sdes extern void* unbound_start_brk; 764238106Sdes void* cur = sbrk(0); 765238106Sdes if(!print_longnum(ssl, "mem.total.sbrk"SQ, 766238106Sdes (size_t)((char*)cur - (char*)unbound_start_brk))) return 0; 767238106Sdes#endif /* HAVE_SBRK */ 768238106Sdes msg = slabhash_get_mem(daemon->env->msg_cache); 769238106Sdes rrset = slabhash_get_mem(&daemon->env->rrset_cache->table); 770238106Sdes val=0; 771238106Sdes iter=0; 772238106Sdes m = modstack_find(&worker->env.mesh->mods, "validator"); 773238106Sdes if(m != -1) { 774238106Sdes fptr_ok(fptr_whitelist_mod_get_mem(worker->env.mesh-> 775238106Sdes mods.mod[m]->get_mem)); 776238106Sdes val = (*worker->env.mesh->mods.mod[m]->get_mem) 777238106Sdes (&worker->env, m); 778238106Sdes } 779238106Sdes m = modstack_find(&worker->env.mesh->mods, "iterator"); 780238106Sdes if(m != -1) { 781238106Sdes fptr_ok(fptr_whitelist_mod_get_mem(worker->env.mesh-> 782238106Sdes mods.mod[m]->get_mem)); 783238106Sdes iter = (*worker->env.mesh->mods.mod[m]->get_mem) 784238106Sdes (&worker->env, m); 785238106Sdes } 786238106Sdes 787238106Sdes if(!print_longnum(ssl, "mem.cache.rrset"SQ, rrset)) 788238106Sdes return 0; 789238106Sdes if(!print_longnum(ssl, "mem.cache.message"SQ, msg)) 790238106Sdes return 0; 791238106Sdes if(!print_longnum(ssl, "mem.mod.iterator"SQ, iter)) 792238106Sdes return 0; 793238106Sdes if(!print_longnum(ssl, "mem.mod.validator"SQ, val)) 794238106Sdes return 0; 795238106Sdes return 1; 796238106Sdes} 797238106Sdes 798238106Sdes/** print uptime stats */ 799238106Sdesstatic int 800238106Sdesprint_uptime(SSL* ssl, struct worker* worker, int reset) 801238106Sdes{ 802238106Sdes struct timeval now = *worker->env.now_tv; 803238106Sdes struct timeval up, dt; 804238106Sdes timeval_subtract(&up, &now, &worker->daemon->time_boot); 805238106Sdes timeval_subtract(&dt, &now, &worker->daemon->time_last_stat); 806238106Sdes if(reset) 807238106Sdes worker->daemon->time_last_stat = now; 808269257Sdes if(!ssl_printf(ssl, "time.now"SQ ARG_LL "d.%6.6d\n", 809269257Sdes (long long)now.tv_sec, (unsigned)now.tv_usec)) return 0; 810269257Sdes if(!ssl_printf(ssl, "time.up"SQ ARG_LL "d.%6.6d\n", 811269257Sdes (long long)up.tv_sec, (unsigned)up.tv_usec)) return 0; 812269257Sdes if(!ssl_printf(ssl, "time.elapsed"SQ ARG_LL "d.%6.6d\n", 813269257Sdes (long long)dt.tv_sec, (unsigned)dt.tv_usec)) return 0; 814238106Sdes return 1; 815238106Sdes} 816238106Sdes 817238106Sdes/** print extended histogram */ 818238106Sdesstatic int 819238106Sdesprint_hist(SSL* ssl, struct stats_info* s) 820238106Sdes{ 821238106Sdes struct timehist* hist; 822238106Sdes size_t i; 823238106Sdes hist = timehist_setup(); 824238106Sdes if(!hist) { 825238106Sdes log_err("out of memory"); 826238106Sdes return 0; 827238106Sdes } 828238106Sdes timehist_import(hist, s->svr.hist, NUM_BUCKETS_HIST); 829238106Sdes for(i=0; i<hist->num; i++) { 830238106Sdes if(!ssl_printf(ssl, 831285206Sdes "histogram.%6.6d.%6.6d.to.%6.6d.%6.6d=%lu\n", 832238106Sdes (int)hist->buckets[i].lower.tv_sec, 833238106Sdes (int)hist->buckets[i].lower.tv_usec, 834238106Sdes (int)hist->buckets[i].upper.tv_sec, 835238106Sdes (int)hist->buckets[i].upper.tv_usec, 836285206Sdes (unsigned long)hist->buckets[i].count)) { 837238106Sdes timehist_delete(hist); 838238106Sdes return 0; 839238106Sdes } 840238106Sdes } 841238106Sdes timehist_delete(hist); 842238106Sdes return 1; 843238106Sdes} 844238106Sdes 845238106Sdes/** print extended stats */ 846238106Sdesstatic int 847238106Sdesprint_ext(SSL* ssl, struct stats_info* s) 848238106Sdes{ 849238106Sdes int i; 850238106Sdes char nm[16]; 851269257Sdes const sldns_rr_descriptor* desc; 852269257Sdes const sldns_lookup_table* lt; 853238106Sdes /* TYPE */ 854238106Sdes for(i=0; i<STATS_QTYPE_NUM; i++) { 855238106Sdes if(inhibit_zero && s->svr.qtype[i] == 0) 856238106Sdes continue; 857269257Sdes desc = sldns_rr_descript((uint16_t)i); 858238106Sdes if(desc && desc->_name) { 859238106Sdes snprintf(nm, sizeof(nm), "%s", desc->_name); 860238106Sdes } else if (i == LDNS_RR_TYPE_IXFR) { 861238106Sdes snprintf(nm, sizeof(nm), "IXFR"); 862238106Sdes } else if (i == LDNS_RR_TYPE_AXFR) { 863238106Sdes snprintf(nm, sizeof(nm), "AXFR"); 864238106Sdes } else if (i == LDNS_RR_TYPE_MAILA) { 865238106Sdes snprintf(nm, sizeof(nm), "MAILA"); 866238106Sdes } else if (i == LDNS_RR_TYPE_MAILB) { 867238106Sdes snprintf(nm, sizeof(nm), "MAILB"); 868238106Sdes } else if (i == LDNS_RR_TYPE_ANY) { 869238106Sdes snprintf(nm, sizeof(nm), "ANY"); 870238106Sdes } else { 871238106Sdes snprintf(nm, sizeof(nm), "TYPE%d", i); 872238106Sdes } 873285206Sdes if(!ssl_printf(ssl, "num.query.type.%s"SQ"%lu\n", 874285206Sdes nm, (unsigned long)s->svr.qtype[i])) return 0; 875238106Sdes } 876238106Sdes if(!inhibit_zero || s->svr.qtype_big) { 877285206Sdes if(!ssl_printf(ssl, "num.query.type.other"SQ"%lu\n", 878285206Sdes (unsigned long)s->svr.qtype_big)) return 0; 879238106Sdes } 880238106Sdes /* CLASS */ 881238106Sdes for(i=0; i<STATS_QCLASS_NUM; i++) { 882238106Sdes if(inhibit_zero && s->svr.qclass[i] == 0) 883238106Sdes continue; 884269257Sdes lt = sldns_lookup_by_id(sldns_rr_classes, i); 885238106Sdes if(lt && lt->name) { 886238106Sdes snprintf(nm, sizeof(nm), "%s", lt->name); 887238106Sdes } else { 888238106Sdes snprintf(nm, sizeof(nm), "CLASS%d", i); 889238106Sdes } 890285206Sdes if(!ssl_printf(ssl, "num.query.class.%s"SQ"%lu\n", 891285206Sdes nm, (unsigned long)s->svr.qclass[i])) return 0; 892238106Sdes } 893238106Sdes if(!inhibit_zero || s->svr.qclass_big) { 894285206Sdes if(!ssl_printf(ssl, "num.query.class.other"SQ"%lu\n", 895285206Sdes (unsigned long)s->svr.qclass_big)) return 0; 896238106Sdes } 897238106Sdes /* OPCODE */ 898238106Sdes for(i=0; i<STATS_OPCODE_NUM; i++) { 899238106Sdes if(inhibit_zero && s->svr.qopcode[i] == 0) 900238106Sdes continue; 901269257Sdes lt = sldns_lookup_by_id(sldns_opcodes, i); 902238106Sdes if(lt && lt->name) { 903238106Sdes snprintf(nm, sizeof(nm), "%s", lt->name); 904238106Sdes } else { 905238106Sdes snprintf(nm, sizeof(nm), "OPCODE%d", i); 906238106Sdes } 907285206Sdes if(!ssl_printf(ssl, "num.query.opcode.%s"SQ"%lu\n", 908285206Sdes nm, (unsigned long)s->svr.qopcode[i])) return 0; 909238106Sdes } 910238106Sdes /* transport */ 911285206Sdes if(!ssl_printf(ssl, "num.query.tcp"SQ"%lu\n", 912285206Sdes (unsigned long)s->svr.qtcp)) return 0; 913285206Sdes if(!ssl_printf(ssl, "num.query.tcpout"SQ"%lu\n", 914285206Sdes (unsigned long)s->svr.qtcp_outgoing)) return 0; 915285206Sdes if(!ssl_printf(ssl, "num.query.ipv6"SQ"%lu\n", 916285206Sdes (unsigned long)s->svr.qipv6)) return 0; 917238106Sdes /* flags */ 918285206Sdes if(!ssl_printf(ssl, "num.query.flags.QR"SQ"%lu\n", 919285206Sdes (unsigned long)s->svr.qbit_QR)) return 0; 920285206Sdes if(!ssl_printf(ssl, "num.query.flags.AA"SQ"%lu\n", 921285206Sdes (unsigned long)s->svr.qbit_AA)) return 0; 922285206Sdes if(!ssl_printf(ssl, "num.query.flags.TC"SQ"%lu\n", 923285206Sdes (unsigned long)s->svr.qbit_TC)) return 0; 924285206Sdes if(!ssl_printf(ssl, "num.query.flags.RD"SQ"%lu\n", 925285206Sdes (unsigned long)s->svr.qbit_RD)) return 0; 926285206Sdes if(!ssl_printf(ssl, "num.query.flags.RA"SQ"%lu\n", 927285206Sdes (unsigned long)s->svr.qbit_RA)) return 0; 928285206Sdes if(!ssl_printf(ssl, "num.query.flags.Z"SQ"%lu\n", 929285206Sdes (unsigned long)s->svr.qbit_Z)) return 0; 930285206Sdes if(!ssl_printf(ssl, "num.query.flags.AD"SQ"%lu\n", 931285206Sdes (unsigned long)s->svr.qbit_AD)) return 0; 932285206Sdes if(!ssl_printf(ssl, "num.query.flags.CD"SQ"%lu\n", 933285206Sdes (unsigned long)s->svr.qbit_CD)) return 0; 934285206Sdes if(!ssl_printf(ssl, "num.query.edns.present"SQ"%lu\n", 935285206Sdes (unsigned long)s->svr.qEDNS)) return 0; 936285206Sdes if(!ssl_printf(ssl, "num.query.edns.DO"SQ"%lu\n", 937285206Sdes (unsigned long)s->svr.qEDNS_DO)) return 0; 938238106Sdes 939238106Sdes /* RCODE */ 940238106Sdes for(i=0; i<STATS_RCODE_NUM; i++) { 941285206Sdes /* Always include RCODEs 0-5 */ 942285206Sdes if(inhibit_zero && i > LDNS_RCODE_REFUSED && s->svr.ans_rcode[i] == 0) 943238106Sdes continue; 944269257Sdes lt = sldns_lookup_by_id(sldns_rcodes, i); 945238106Sdes if(lt && lt->name) { 946238106Sdes snprintf(nm, sizeof(nm), "%s", lt->name); 947238106Sdes } else { 948238106Sdes snprintf(nm, sizeof(nm), "RCODE%d", i); 949238106Sdes } 950285206Sdes if(!ssl_printf(ssl, "num.answer.rcode.%s"SQ"%lu\n", 951285206Sdes nm, (unsigned long)s->svr.ans_rcode[i])) return 0; 952238106Sdes } 953238106Sdes if(!inhibit_zero || s->svr.ans_rcode_nodata) { 954285206Sdes if(!ssl_printf(ssl, "num.answer.rcode.nodata"SQ"%lu\n", 955285206Sdes (unsigned long)s->svr.ans_rcode_nodata)) return 0; 956238106Sdes } 957238106Sdes /* validation */ 958285206Sdes if(!ssl_printf(ssl, "num.answer.secure"SQ"%lu\n", 959285206Sdes (unsigned long)s->svr.ans_secure)) return 0; 960285206Sdes if(!ssl_printf(ssl, "num.answer.bogus"SQ"%lu\n", 961285206Sdes (unsigned long)s->svr.ans_bogus)) return 0; 962285206Sdes if(!ssl_printf(ssl, "num.rrset.bogus"SQ"%lu\n", 963285206Sdes (unsigned long)s->svr.rrset_bogus)) return 0; 964238106Sdes /* threat detection */ 965285206Sdes if(!ssl_printf(ssl, "unwanted.queries"SQ"%lu\n", 966285206Sdes (unsigned long)s->svr.unwanted_queries)) return 0; 967285206Sdes if(!ssl_printf(ssl, "unwanted.replies"SQ"%lu\n", 968285206Sdes (unsigned long)s->svr.unwanted_replies)) return 0; 969285206Sdes /* cache counts */ 970285206Sdes if(!ssl_printf(ssl, "msg.cache.count"SQ"%u\n", 971285206Sdes (unsigned)s->svr.msg_cache_count)) return 0; 972285206Sdes if(!ssl_printf(ssl, "rrset.cache.count"SQ"%u\n", 973285206Sdes (unsigned)s->svr.rrset_cache_count)) return 0; 974285206Sdes if(!ssl_printf(ssl, "infra.cache.count"SQ"%u\n", 975285206Sdes (unsigned)s->svr.infra_cache_count)) return 0; 976285206Sdes if(!ssl_printf(ssl, "key.cache.count"SQ"%u\n", 977285206Sdes (unsigned)s->svr.key_cache_count)) return 0; 978238106Sdes return 1; 979238106Sdes} 980238106Sdes 981238106Sdes/** do the stats command */ 982238106Sdesstatic void 983238106Sdesdo_stats(SSL* ssl, struct daemon_remote* rc, int reset) 984238106Sdes{ 985238106Sdes struct daemon* daemon = rc->worker->daemon; 986238106Sdes struct stats_info total; 987238106Sdes struct stats_info s; 988238106Sdes int i; 989238106Sdes log_assert(daemon->num > 0); 990238106Sdes /* gather all thread statistics in one place */ 991238106Sdes for(i=0; i<daemon->num; i++) { 992238106Sdes server_stats_obtain(rc->worker, daemon->workers[i], &s, reset); 993238106Sdes if(!print_thread_stats(ssl, i, &s)) 994238106Sdes return; 995238106Sdes if(i == 0) 996238106Sdes total = s; 997238106Sdes else server_stats_add(&total, &s); 998238106Sdes } 999238106Sdes /* print the thread statistics */ 1000238106Sdes total.mesh_time_median /= (double)daemon->num; 1001238106Sdes if(!print_stats(ssl, "total", &total)) 1002238106Sdes return; 1003238106Sdes if(!print_uptime(ssl, rc->worker, reset)) 1004238106Sdes return; 1005238106Sdes if(daemon->cfg->stat_extended) { 1006238106Sdes if(!print_mem(ssl, rc->worker, daemon)) 1007238106Sdes return; 1008238106Sdes if(!print_hist(ssl, &total)) 1009238106Sdes return; 1010238106Sdes if(!print_ext(ssl, &total)) 1011238106Sdes return; 1012238106Sdes } 1013238106Sdes} 1014238106Sdes 1015238106Sdes/** parse commandline argument domain name */ 1016238106Sdesstatic int 1017238106Sdesparse_arg_name(SSL* ssl, char* str, uint8_t** res, size_t* len, int* labs) 1018238106Sdes{ 1019269257Sdes uint8_t nm[LDNS_MAX_DOMAINLEN+1]; 1020269257Sdes size_t nmlen = sizeof(nm); 1021269257Sdes int status; 1022238106Sdes *res = NULL; 1023238106Sdes *len = 0; 1024238106Sdes *labs = 0; 1025269257Sdes status = sldns_str2wire_dname_buf(str, nm, &nmlen); 1026269257Sdes if(status != 0) { 1027269257Sdes ssl_printf(ssl, "error cannot parse name %s at %d: %s\n", str, 1028269257Sdes LDNS_WIREPARSE_OFFSET(status), 1029269257Sdes sldns_get_errorstr_parse(status)); 1030238106Sdes return 0; 1031238106Sdes } 1032269257Sdes *res = memdup(nm, nmlen); 1033238106Sdes if(!*res) { 1034238106Sdes ssl_printf(ssl, "error out of memory\n"); 1035238106Sdes return 0; 1036238106Sdes } 1037238106Sdes *labs = dname_count_size_labels(*res, len); 1038238106Sdes return 1; 1039238106Sdes} 1040238106Sdes 1041238106Sdes/** find second argument, modifies string */ 1042238106Sdesstatic int 1043238106Sdesfind_arg2(SSL* ssl, char* arg, char** arg2) 1044238106Sdes{ 1045238106Sdes char* as = strchr(arg, ' '); 1046238106Sdes char* at = strchr(arg, '\t'); 1047238106Sdes if(as && at) { 1048238106Sdes if(at < as) 1049238106Sdes as = at; 1050238106Sdes as[0]=0; 1051238106Sdes *arg2 = skipwhite(as+1); 1052238106Sdes } else if(as) { 1053238106Sdes as[0]=0; 1054238106Sdes *arg2 = skipwhite(as+1); 1055238106Sdes } else if(at) { 1056238106Sdes at[0]=0; 1057238106Sdes *arg2 = skipwhite(at+1); 1058238106Sdes } else { 1059238106Sdes ssl_printf(ssl, "error could not find next argument " 1060238106Sdes "after %s\n", arg); 1061238106Sdes return 0; 1062238106Sdes } 1063238106Sdes return 1; 1064238106Sdes} 1065238106Sdes 1066238106Sdes/** Add a new zone */ 1067238106Sdesstatic void 1068238106Sdesdo_zone_add(SSL* ssl, struct worker* worker, char* arg) 1069238106Sdes{ 1070238106Sdes uint8_t* nm; 1071238106Sdes int nmlabs; 1072238106Sdes size_t nmlen; 1073238106Sdes char* arg2; 1074238106Sdes enum localzone_type t; 1075238106Sdes struct local_zone* z; 1076238106Sdes if(!find_arg2(ssl, arg, &arg2)) 1077238106Sdes return; 1078238106Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1079238106Sdes return; 1080238106Sdes if(!local_zone_str2type(arg2, &t)) { 1081238106Sdes ssl_printf(ssl, "error not a zone type. %s\n", arg2); 1082238106Sdes free(nm); 1083238106Sdes return; 1084238106Sdes } 1085269257Sdes lock_rw_wrlock(&worker->daemon->local_zones->lock); 1086238106Sdes if((z=local_zones_find(worker->daemon->local_zones, nm, nmlen, 1087238106Sdes nmlabs, LDNS_RR_CLASS_IN))) { 1088238106Sdes /* already present in tree */ 1089238106Sdes lock_rw_wrlock(&z->lock); 1090238106Sdes z->type = t; /* update type anyway */ 1091238106Sdes lock_rw_unlock(&z->lock); 1092238106Sdes free(nm); 1093269257Sdes lock_rw_unlock(&worker->daemon->local_zones->lock); 1094238106Sdes send_ok(ssl); 1095238106Sdes return; 1096238106Sdes } 1097238106Sdes if(!local_zones_add_zone(worker->daemon->local_zones, nm, nmlen, 1098238106Sdes nmlabs, LDNS_RR_CLASS_IN, t)) { 1099269257Sdes lock_rw_unlock(&worker->daemon->local_zones->lock); 1100238106Sdes ssl_printf(ssl, "error out of memory\n"); 1101238106Sdes return; 1102238106Sdes } 1103269257Sdes lock_rw_unlock(&worker->daemon->local_zones->lock); 1104238106Sdes send_ok(ssl); 1105238106Sdes} 1106238106Sdes 1107238106Sdes/** Remove a zone */ 1108238106Sdesstatic void 1109238106Sdesdo_zone_remove(SSL* ssl, struct worker* worker, char* arg) 1110238106Sdes{ 1111238106Sdes uint8_t* nm; 1112238106Sdes int nmlabs; 1113238106Sdes size_t nmlen; 1114238106Sdes struct local_zone* z; 1115238106Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1116238106Sdes return; 1117269257Sdes lock_rw_wrlock(&worker->daemon->local_zones->lock); 1118238106Sdes if((z=local_zones_find(worker->daemon->local_zones, nm, nmlen, 1119238106Sdes nmlabs, LDNS_RR_CLASS_IN))) { 1120238106Sdes /* present in tree */ 1121238106Sdes local_zones_del_zone(worker->daemon->local_zones, z); 1122238106Sdes } 1123269257Sdes lock_rw_unlock(&worker->daemon->local_zones->lock); 1124238106Sdes free(nm); 1125238106Sdes send_ok(ssl); 1126238106Sdes} 1127238106Sdes 1128238106Sdes/** Add new RR data */ 1129238106Sdesstatic void 1130238106Sdesdo_data_add(SSL* ssl, struct worker* worker, char* arg) 1131238106Sdes{ 1132269257Sdes if(!local_zones_add_RR(worker->daemon->local_zones, arg)) { 1133238106Sdes ssl_printf(ssl,"error in syntax or out of memory, %s\n", arg); 1134238106Sdes return; 1135238106Sdes } 1136238106Sdes send_ok(ssl); 1137238106Sdes} 1138238106Sdes 1139238106Sdes/** Remove RR data */ 1140238106Sdesstatic void 1141238106Sdesdo_data_remove(SSL* ssl, struct worker* worker, char* arg) 1142238106Sdes{ 1143238106Sdes uint8_t* nm; 1144238106Sdes int nmlabs; 1145238106Sdes size_t nmlen; 1146238106Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1147238106Sdes return; 1148238106Sdes local_zones_del_data(worker->daemon->local_zones, nm, 1149238106Sdes nmlen, nmlabs, LDNS_RR_CLASS_IN); 1150238106Sdes free(nm); 1151238106Sdes send_ok(ssl); 1152238106Sdes} 1153238106Sdes 1154238106Sdes/** cache lookup of nameservers */ 1155238106Sdesstatic void 1156238106Sdesdo_lookup(SSL* ssl, struct worker* worker, char* arg) 1157238106Sdes{ 1158238106Sdes uint8_t* nm; 1159238106Sdes int nmlabs; 1160238106Sdes size_t nmlen; 1161238106Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1162238106Sdes return; 1163238106Sdes (void)print_deleg_lookup(ssl, worker, nm, nmlen, nmlabs); 1164238106Sdes free(nm); 1165238106Sdes} 1166238106Sdes 1167238106Sdes/** flush something from rrset and msg caches */ 1168238106Sdesstatic void 1169238106Sdesdo_cache_remove(struct worker* worker, uint8_t* nm, size_t nmlen, 1170238106Sdes uint16_t t, uint16_t c) 1171238106Sdes{ 1172238106Sdes hashvalue_t h; 1173238106Sdes struct query_info k; 1174238106Sdes rrset_cache_remove(worker->env.rrset_cache, nm, nmlen, t, c, 0); 1175238106Sdes if(t == LDNS_RR_TYPE_SOA) 1176238106Sdes rrset_cache_remove(worker->env.rrset_cache, nm, nmlen, t, c, 1177238106Sdes PACKED_RRSET_SOA_NEG); 1178238106Sdes k.qname = nm; 1179238106Sdes k.qname_len = nmlen; 1180238106Sdes k.qtype = t; 1181238106Sdes k.qclass = c; 1182285206Sdes h = query_info_hash(&k, 0); 1183238106Sdes slabhash_remove(worker->env.msg_cache, h, &k); 1184285206Sdes if(t == LDNS_RR_TYPE_AAAA) { 1185285206Sdes /* for AAAA also flush dns64 bit_cd packet */ 1186285206Sdes h = query_info_hash(&k, BIT_CD); 1187285206Sdes slabhash_remove(worker->env.msg_cache, h, &k); 1188285206Sdes } 1189238106Sdes} 1190238106Sdes 1191238106Sdes/** flush a type */ 1192238106Sdesstatic void 1193238106Sdesdo_flush_type(SSL* ssl, struct worker* worker, char* arg) 1194238106Sdes{ 1195238106Sdes uint8_t* nm; 1196238106Sdes int nmlabs; 1197238106Sdes size_t nmlen; 1198238106Sdes char* arg2; 1199238106Sdes uint16_t t; 1200238106Sdes if(!find_arg2(ssl, arg, &arg2)) 1201238106Sdes return; 1202238106Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1203238106Sdes return; 1204269257Sdes t = sldns_get_rr_type_by_name(arg2); 1205238106Sdes do_cache_remove(worker, nm, nmlen, t, LDNS_RR_CLASS_IN); 1206238106Sdes 1207238106Sdes free(nm); 1208238106Sdes send_ok(ssl); 1209238106Sdes} 1210238106Sdes 1211238106Sdes/** flush statistics */ 1212238106Sdesstatic void 1213238106Sdesdo_flush_stats(SSL* ssl, struct worker* worker) 1214238106Sdes{ 1215238106Sdes worker_stats_clear(worker); 1216238106Sdes send_ok(ssl); 1217238106Sdes} 1218238106Sdes 1219238106Sdes/** 1220238106Sdes * Local info for deletion functions 1221238106Sdes */ 1222238106Sdesstruct del_info { 1223238106Sdes /** worker */ 1224238106Sdes struct worker* worker; 1225238106Sdes /** name to delete */ 1226238106Sdes uint8_t* name; 1227238106Sdes /** length */ 1228238106Sdes size_t len; 1229238106Sdes /** labels */ 1230238106Sdes int labs; 1231238106Sdes /** now */ 1232269257Sdes time_t now; 1233238106Sdes /** time to invalidate to */ 1234269257Sdes time_t expired; 1235238106Sdes /** number of rrsets removed */ 1236238106Sdes size_t num_rrsets; 1237238106Sdes /** number of msgs removed */ 1238238106Sdes size_t num_msgs; 1239238106Sdes /** number of key entries removed */ 1240238106Sdes size_t num_keys; 1241238106Sdes /** length of addr */ 1242238106Sdes socklen_t addrlen; 1243238106Sdes /** socket address for host deletion */ 1244238106Sdes struct sockaddr_storage addr; 1245238106Sdes}; 1246238106Sdes 1247238106Sdes/** callback to delete hosts in infra cache */ 1248238106Sdesstatic void 1249238106Sdesinfra_del_host(struct lruhash_entry* e, void* arg) 1250238106Sdes{ 1251238106Sdes /* entry is locked */ 1252238106Sdes struct del_info* inf = (struct del_info*)arg; 1253238106Sdes struct infra_key* k = (struct infra_key*)e->key; 1254238106Sdes if(sockaddr_cmp(&inf->addr, inf->addrlen, &k->addr, k->addrlen) == 0) { 1255238106Sdes struct infra_data* d = (struct infra_data*)e->data; 1256238106Sdes d->probedelay = 0; 1257238106Sdes d->timeout_A = 0; 1258238106Sdes d->timeout_AAAA = 0; 1259238106Sdes d->timeout_other = 0; 1260238106Sdes rtt_init(&d->rtt); 1261238106Sdes if(d->ttl >= inf->now) { 1262238106Sdes d->ttl = inf->expired; 1263238106Sdes inf->num_keys++; 1264238106Sdes } 1265238106Sdes } 1266238106Sdes} 1267238106Sdes 1268238106Sdes/** flush infra cache */ 1269238106Sdesstatic void 1270238106Sdesdo_flush_infra(SSL* ssl, struct worker* worker, char* arg) 1271238106Sdes{ 1272238106Sdes struct sockaddr_storage addr; 1273238106Sdes socklen_t len; 1274238106Sdes struct del_info inf; 1275238106Sdes if(strcmp(arg, "all") == 0) { 1276238106Sdes slabhash_clear(worker->env.infra_cache->hosts); 1277238106Sdes send_ok(ssl); 1278238106Sdes return; 1279238106Sdes } 1280238106Sdes if(!ipstrtoaddr(arg, UNBOUND_DNS_PORT, &addr, &len)) { 1281238106Sdes (void)ssl_printf(ssl, "error parsing ip addr: '%s'\n", arg); 1282238106Sdes return; 1283238106Sdes } 1284238106Sdes /* delete all entries from cache */ 1285238106Sdes /* what we do is to set them all expired */ 1286238106Sdes inf.worker = worker; 1287238106Sdes inf.name = 0; 1288238106Sdes inf.len = 0; 1289238106Sdes inf.labs = 0; 1290238106Sdes inf.now = *worker->env.now; 1291238106Sdes inf.expired = *worker->env.now; 1292238106Sdes inf.expired -= 3; /* handle 3 seconds skew between threads */ 1293238106Sdes inf.num_rrsets = 0; 1294238106Sdes inf.num_msgs = 0; 1295238106Sdes inf.num_keys = 0; 1296238106Sdes inf.addrlen = len; 1297238106Sdes memmove(&inf.addr, &addr, len); 1298238106Sdes slabhash_traverse(worker->env.infra_cache->hosts, 1, &infra_del_host, 1299238106Sdes &inf); 1300238106Sdes send_ok(ssl); 1301238106Sdes} 1302238106Sdes 1303238106Sdes/** flush requestlist */ 1304238106Sdesstatic void 1305238106Sdesdo_flush_requestlist(SSL* ssl, struct worker* worker) 1306238106Sdes{ 1307238106Sdes mesh_delete_all(worker->env.mesh); 1308238106Sdes send_ok(ssl); 1309238106Sdes} 1310238106Sdes 1311238106Sdes/** callback to delete rrsets in a zone */ 1312238106Sdesstatic void 1313238106Sdeszone_del_rrset(struct lruhash_entry* e, void* arg) 1314238106Sdes{ 1315238106Sdes /* entry is locked */ 1316238106Sdes struct del_info* inf = (struct del_info*)arg; 1317238106Sdes struct ub_packed_rrset_key* k = (struct ub_packed_rrset_key*)e->key; 1318238106Sdes if(dname_subdomain_c(k->rk.dname, inf->name)) { 1319238106Sdes struct packed_rrset_data* d = 1320238106Sdes (struct packed_rrset_data*)e->data; 1321238106Sdes if(d->ttl >= inf->now) { 1322238106Sdes d->ttl = inf->expired; 1323238106Sdes inf->num_rrsets++; 1324238106Sdes } 1325238106Sdes } 1326238106Sdes} 1327238106Sdes 1328238106Sdes/** callback to delete messages in a zone */ 1329238106Sdesstatic void 1330238106Sdeszone_del_msg(struct lruhash_entry* e, void* arg) 1331238106Sdes{ 1332238106Sdes /* entry is locked */ 1333238106Sdes struct del_info* inf = (struct del_info*)arg; 1334238106Sdes struct msgreply_entry* k = (struct msgreply_entry*)e->key; 1335238106Sdes if(dname_subdomain_c(k->key.qname, inf->name)) { 1336238106Sdes struct reply_info* d = (struct reply_info*)e->data; 1337238106Sdes if(d->ttl >= inf->now) { 1338238106Sdes d->ttl = inf->expired; 1339238106Sdes inf->num_msgs++; 1340238106Sdes } 1341238106Sdes } 1342238106Sdes} 1343238106Sdes 1344238106Sdes/** callback to delete keys in zone */ 1345238106Sdesstatic void 1346238106Sdeszone_del_kcache(struct lruhash_entry* e, void* arg) 1347238106Sdes{ 1348238106Sdes /* entry is locked */ 1349238106Sdes struct del_info* inf = (struct del_info*)arg; 1350238106Sdes struct key_entry_key* k = (struct key_entry_key*)e->key; 1351238106Sdes if(dname_subdomain_c(k->name, inf->name)) { 1352238106Sdes struct key_entry_data* d = (struct key_entry_data*)e->data; 1353238106Sdes if(d->ttl >= inf->now) { 1354238106Sdes d->ttl = inf->expired; 1355238106Sdes inf->num_keys++; 1356238106Sdes } 1357238106Sdes } 1358238106Sdes} 1359238106Sdes 1360238106Sdes/** remove all rrsets and keys from zone from cache */ 1361238106Sdesstatic void 1362238106Sdesdo_flush_zone(SSL* ssl, struct worker* worker, char* arg) 1363238106Sdes{ 1364238106Sdes uint8_t* nm; 1365238106Sdes int nmlabs; 1366238106Sdes size_t nmlen; 1367238106Sdes struct del_info inf; 1368238106Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1369238106Sdes return; 1370238106Sdes /* delete all RRs and key entries from zone */ 1371238106Sdes /* what we do is to set them all expired */ 1372238106Sdes inf.worker = worker; 1373238106Sdes inf.name = nm; 1374238106Sdes inf.len = nmlen; 1375238106Sdes inf.labs = nmlabs; 1376238106Sdes inf.now = *worker->env.now; 1377238106Sdes inf.expired = *worker->env.now; 1378238106Sdes inf.expired -= 3; /* handle 3 seconds skew between threads */ 1379238106Sdes inf.num_rrsets = 0; 1380238106Sdes inf.num_msgs = 0; 1381238106Sdes inf.num_keys = 0; 1382238106Sdes slabhash_traverse(&worker->env.rrset_cache->table, 1, 1383238106Sdes &zone_del_rrset, &inf); 1384238106Sdes 1385238106Sdes slabhash_traverse(worker->env.msg_cache, 1, &zone_del_msg, &inf); 1386238106Sdes 1387238106Sdes /* and validator cache */ 1388238106Sdes if(worker->env.key_cache) { 1389238106Sdes slabhash_traverse(worker->env.key_cache->slab, 1, 1390238106Sdes &zone_del_kcache, &inf); 1391238106Sdes } 1392238106Sdes 1393238106Sdes free(nm); 1394238106Sdes 1395285206Sdes (void)ssl_printf(ssl, "ok removed %lu rrsets, %lu messages " 1396285206Sdes "and %lu key entries\n", (unsigned long)inf.num_rrsets, 1397285206Sdes (unsigned long)inf.num_msgs, (unsigned long)inf.num_keys); 1398238106Sdes} 1399238106Sdes 1400249141Sdes/** callback to delete bogus rrsets */ 1401249141Sdesstatic void 1402249141Sdesbogus_del_rrset(struct lruhash_entry* e, void* arg) 1403249141Sdes{ 1404249141Sdes /* entry is locked */ 1405249141Sdes struct del_info* inf = (struct del_info*)arg; 1406249141Sdes struct packed_rrset_data* d = (struct packed_rrset_data*)e->data; 1407249141Sdes if(d->security == sec_status_bogus) { 1408249141Sdes d->ttl = inf->expired; 1409249141Sdes inf->num_rrsets++; 1410249141Sdes } 1411249141Sdes} 1412249141Sdes 1413249141Sdes/** callback to delete bogus messages */ 1414249141Sdesstatic void 1415249141Sdesbogus_del_msg(struct lruhash_entry* e, void* arg) 1416249141Sdes{ 1417249141Sdes /* entry is locked */ 1418249141Sdes struct del_info* inf = (struct del_info*)arg; 1419249141Sdes struct reply_info* d = (struct reply_info*)e->data; 1420249141Sdes if(d->security == sec_status_bogus) { 1421249141Sdes d->ttl = inf->expired; 1422249141Sdes inf->num_msgs++; 1423249141Sdes } 1424249141Sdes} 1425249141Sdes 1426249141Sdes/** callback to delete bogus keys */ 1427249141Sdesstatic void 1428249141Sdesbogus_del_kcache(struct lruhash_entry* e, void* arg) 1429249141Sdes{ 1430249141Sdes /* entry is locked */ 1431249141Sdes struct del_info* inf = (struct del_info*)arg; 1432249141Sdes struct key_entry_data* d = (struct key_entry_data*)e->data; 1433249141Sdes if(d->isbad) { 1434249141Sdes d->ttl = inf->expired; 1435249141Sdes inf->num_keys++; 1436249141Sdes } 1437249141Sdes} 1438249141Sdes 1439285206Sdes/** remove all bogus rrsets, msgs and keys from cache */ 1440249141Sdesstatic void 1441249141Sdesdo_flush_bogus(SSL* ssl, struct worker* worker) 1442249141Sdes{ 1443249141Sdes struct del_info inf; 1444249141Sdes /* what we do is to set them all expired */ 1445249141Sdes inf.worker = worker; 1446249141Sdes inf.now = *worker->env.now; 1447249141Sdes inf.expired = *worker->env.now; 1448249141Sdes inf.expired -= 3; /* handle 3 seconds skew between threads */ 1449249141Sdes inf.num_rrsets = 0; 1450249141Sdes inf.num_msgs = 0; 1451249141Sdes inf.num_keys = 0; 1452249141Sdes slabhash_traverse(&worker->env.rrset_cache->table, 1, 1453249141Sdes &bogus_del_rrset, &inf); 1454249141Sdes 1455249141Sdes slabhash_traverse(worker->env.msg_cache, 1, &bogus_del_msg, &inf); 1456249141Sdes 1457249141Sdes /* and validator cache */ 1458249141Sdes if(worker->env.key_cache) { 1459249141Sdes slabhash_traverse(worker->env.key_cache->slab, 1, 1460249141Sdes &bogus_del_kcache, &inf); 1461249141Sdes } 1462249141Sdes 1463285206Sdes (void)ssl_printf(ssl, "ok removed %lu rrsets, %lu messages " 1464285206Sdes "and %lu key entries\n", (unsigned long)inf.num_rrsets, 1465285206Sdes (unsigned long)inf.num_msgs, (unsigned long)inf.num_keys); 1466249141Sdes} 1467249141Sdes 1468285206Sdes/** callback to delete negative and servfail rrsets */ 1469285206Sdesstatic void 1470285206Sdesnegative_del_rrset(struct lruhash_entry* e, void* arg) 1471285206Sdes{ 1472285206Sdes /* entry is locked */ 1473285206Sdes struct del_info* inf = (struct del_info*)arg; 1474285206Sdes struct ub_packed_rrset_key* k = (struct ub_packed_rrset_key*)e->key; 1475285206Sdes struct packed_rrset_data* d = (struct packed_rrset_data*)e->data; 1476285206Sdes /* delete the parentside negative cache rrsets, 1477285206Sdes * these are namerserver rrsets that failed lookup, rdata empty */ 1478285206Sdes if((k->rk.flags & PACKED_RRSET_PARENT_SIDE) && d->count == 1 && 1479285206Sdes d->rrsig_count == 0 && d->rr_len[0] == 0) { 1480285206Sdes d->ttl = inf->expired; 1481285206Sdes inf->num_rrsets++; 1482285206Sdes } 1483285206Sdes} 1484285206Sdes 1485285206Sdes/** callback to delete negative and servfail messages */ 1486285206Sdesstatic void 1487285206Sdesnegative_del_msg(struct lruhash_entry* e, void* arg) 1488285206Sdes{ 1489285206Sdes /* entry is locked */ 1490285206Sdes struct del_info* inf = (struct del_info*)arg; 1491285206Sdes struct reply_info* d = (struct reply_info*)e->data; 1492285206Sdes /* rcode not NOERROR: NXDOMAIN, SERVFAIL, ..: an nxdomain or error 1493285206Sdes * or NOERROR rcode with ANCOUNT==0: a NODATA answer */ 1494285206Sdes if(FLAGS_GET_RCODE(d->flags) != 0 || d->an_numrrsets == 0) { 1495285206Sdes d->ttl = inf->expired; 1496285206Sdes inf->num_msgs++; 1497285206Sdes } 1498285206Sdes} 1499285206Sdes 1500285206Sdes/** callback to delete negative key entries */ 1501285206Sdesstatic void 1502285206Sdesnegative_del_kcache(struct lruhash_entry* e, void* arg) 1503285206Sdes{ 1504285206Sdes /* entry is locked */ 1505285206Sdes struct del_info* inf = (struct del_info*)arg; 1506285206Sdes struct key_entry_data* d = (struct key_entry_data*)e->data; 1507285206Sdes /* could be bad because of lookup failure on the DS, DNSKEY, which 1508285206Sdes * was nxdomain or servfail, and thus a result of negative lookups */ 1509285206Sdes if(d->isbad) { 1510285206Sdes d->ttl = inf->expired; 1511285206Sdes inf->num_keys++; 1512285206Sdes } 1513285206Sdes} 1514285206Sdes 1515285206Sdes/** remove all negative(NODATA,NXDOMAIN), and servfail messages from cache */ 1516285206Sdesstatic void 1517285206Sdesdo_flush_negative(SSL* ssl, struct worker* worker) 1518285206Sdes{ 1519285206Sdes struct del_info inf; 1520285206Sdes /* what we do is to set them all expired */ 1521285206Sdes inf.worker = worker; 1522285206Sdes inf.now = *worker->env.now; 1523285206Sdes inf.expired = *worker->env.now; 1524285206Sdes inf.expired -= 3; /* handle 3 seconds skew between threads */ 1525285206Sdes inf.num_rrsets = 0; 1526285206Sdes inf.num_msgs = 0; 1527285206Sdes inf.num_keys = 0; 1528285206Sdes slabhash_traverse(&worker->env.rrset_cache->table, 1, 1529285206Sdes &negative_del_rrset, &inf); 1530285206Sdes 1531285206Sdes slabhash_traverse(worker->env.msg_cache, 1, &negative_del_msg, &inf); 1532285206Sdes 1533285206Sdes /* and validator cache */ 1534285206Sdes if(worker->env.key_cache) { 1535285206Sdes slabhash_traverse(worker->env.key_cache->slab, 1, 1536285206Sdes &negative_del_kcache, &inf); 1537285206Sdes } 1538285206Sdes 1539285206Sdes (void)ssl_printf(ssl, "ok removed %lu rrsets, %lu messages " 1540285206Sdes "and %lu key entries\n", (unsigned long)inf.num_rrsets, 1541285206Sdes (unsigned long)inf.num_msgs, (unsigned long)inf.num_keys); 1542285206Sdes} 1543285206Sdes 1544238106Sdes/** remove name rrset from cache */ 1545238106Sdesstatic void 1546238106Sdesdo_flush_name(SSL* ssl, struct worker* w, char* arg) 1547238106Sdes{ 1548238106Sdes uint8_t* nm; 1549238106Sdes int nmlabs; 1550238106Sdes size_t nmlen; 1551238106Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1552238106Sdes return; 1553238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_A, LDNS_RR_CLASS_IN); 1554238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_AAAA, LDNS_RR_CLASS_IN); 1555238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_NS, LDNS_RR_CLASS_IN); 1556238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_SOA, LDNS_RR_CLASS_IN); 1557238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_CNAME, LDNS_RR_CLASS_IN); 1558238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_DNAME, LDNS_RR_CLASS_IN); 1559238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_MX, LDNS_RR_CLASS_IN); 1560238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_PTR, LDNS_RR_CLASS_IN); 1561238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_SRV, LDNS_RR_CLASS_IN); 1562238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_NAPTR, LDNS_RR_CLASS_IN); 1563238106Sdes 1564238106Sdes free(nm); 1565238106Sdes send_ok(ssl); 1566238106Sdes} 1567238106Sdes 1568238106Sdes/** printout a delegation point info */ 1569238106Sdesstatic int 1570255579Sdesssl_print_name_dp(SSL* ssl, const char* str, uint8_t* nm, uint16_t dclass, 1571238106Sdes struct delegpt* dp) 1572238106Sdes{ 1573238106Sdes char buf[257]; 1574238106Sdes struct delegpt_ns* ns; 1575238106Sdes struct delegpt_addr* a; 1576238106Sdes int f = 0; 1577238106Sdes if(str) { /* print header for forward, stub */ 1578269257Sdes char* c = sldns_wire2str_class(dclass); 1579238106Sdes dname_str(nm, buf); 1580285206Sdes if(!ssl_printf(ssl, "%s %s %s ", buf, (c?c:"CLASS??"), str)) { 1581238106Sdes free(c); 1582238106Sdes return 0; 1583238106Sdes } 1584238106Sdes free(c); 1585238106Sdes } 1586238106Sdes for(ns = dp->nslist; ns; ns = ns->next) { 1587238106Sdes dname_str(ns->name, buf); 1588238106Sdes if(!ssl_printf(ssl, "%s%s", (f?" ":""), buf)) 1589238106Sdes return 0; 1590238106Sdes f = 1; 1591238106Sdes } 1592238106Sdes for(a = dp->target_list; a; a = a->next_target) { 1593238106Sdes addr_to_str(&a->addr, a->addrlen, buf, sizeof(buf)); 1594238106Sdes if(!ssl_printf(ssl, "%s%s", (f?" ":""), buf)) 1595238106Sdes return 0; 1596238106Sdes f = 1; 1597238106Sdes } 1598238106Sdes return ssl_printf(ssl, "\n"); 1599238106Sdes} 1600238106Sdes 1601238106Sdes 1602238106Sdes/** print root forwards */ 1603238106Sdesstatic int 1604238106Sdesprint_root_fwds(SSL* ssl, struct iter_forwards* fwds, uint8_t* root) 1605238106Sdes{ 1606238106Sdes struct delegpt* dp; 1607238106Sdes dp = forwards_lookup(fwds, root, LDNS_RR_CLASS_IN); 1608238106Sdes if(!dp) 1609238106Sdes return ssl_printf(ssl, "off (using root hints)\n"); 1610238106Sdes /* if dp is returned it must be the root */ 1611238106Sdes log_assert(query_dname_compare(dp->name, root)==0); 1612238106Sdes return ssl_print_name_dp(ssl, NULL, root, LDNS_RR_CLASS_IN, dp); 1613238106Sdes} 1614238106Sdes 1615238106Sdes/** parse args into delegpt */ 1616238106Sdesstatic struct delegpt* 1617238106Sdesparse_delegpt(SSL* ssl, char* args, uint8_t* nm, int allow_names) 1618238106Sdes{ 1619238106Sdes /* parse args and add in */ 1620238106Sdes char* p = args; 1621238106Sdes char* todo; 1622238106Sdes struct delegpt* dp = delegpt_create_mlc(nm); 1623238106Sdes struct sockaddr_storage addr; 1624238106Sdes socklen_t addrlen; 1625238106Sdes if(!dp) { 1626238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1627238106Sdes return NULL; 1628238106Sdes } 1629238106Sdes while(p) { 1630238106Sdes todo = p; 1631238106Sdes p = strchr(p, ' '); /* find next spot, if any */ 1632238106Sdes if(p) { 1633238106Sdes *p++ = 0; /* end this spot */ 1634238106Sdes p = skipwhite(p); /* position at next spot */ 1635238106Sdes } 1636238106Sdes /* parse address */ 1637238106Sdes if(!extstrtoaddr(todo, &addr, &addrlen)) { 1638238106Sdes if(allow_names) { 1639238106Sdes uint8_t* n = NULL; 1640238106Sdes size_t ln; 1641238106Sdes int lb; 1642238106Sdes if(!parse_arg_name(ssl, todo, &n, &ln, &lb)) { 1643238106Sdes (void)ssl_printf(ssl, "error cannot " 1644238106Sdes "parse IP address or name " 1645238106Sdes "'%s'\n", todo); 1646238106Sdes delegpt_free_mlc(dp); 1647238106Sdes return NULL; 1648238106Sdes } 1649238106Sdes if(!delegpt_add_ns_mlc(dp, n, 0)) { 1650238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1651249141Sdes free(n); 1652238106Sdes delegpt_free_mlc(dp); 1653238106Sdes return NULL; 1654238106Sdes } 1655238106Sdes free(n); 1656238106Sdes 1657238106Sdes } else { 1658238106Sdes (void)ssl_printf(ssl, "error cannot parse" 1659238106Sdes " IP address '%s'\n", todo); 1660238106Sdes delegpt_free_mlc(dp); 1661238106Sdes return NULL; 1662238106Sdes } 1663238106Sdes } else { 1664238106Sdes /* add address */ 1665238106Sdes if(!delegpt_add_addr_mlc(dp, &addr, addrlen, 0, 0)) { 1666238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1667238106Sdes delegpt_free_mlc(dp); 1668238106Sdes return NULL; 1669238106Sdes } 1670238106Sdes } 1671238106Sdes } 1672238106Sdes return dp; 1673238106Sdes} 1674238106Sdes 1675238106Sdes/** do the status command */ 1676238106Sdesstatic void 1677238106Sdesdo_forward(SSL* ssl, struct worker* worker, char* args) 1678238106Sdes{ 1679238106Sdes struct iter_forwards* fwd = worker->env.fwds; 1680238106Sdes uint8_t* root = (uint8_t*)"\000"; 1681238106Sdes if(!fwd) { 1682238106Sdes (void)ssl_printf(ssl, "error: structure not allocated\n"); 1683238106Sdes return; 1684238106Sdes } 1685238106Sdes if(args == NULL || args[0] == 0) { 1686238106Sdes (void)print_root_fwds(ssl, fwd, root); 1687238106Sdes return; 1688238106Sdes } 1689238106Sdes /* set root forwards for this thread. since we are in remote control 1690238106Sdes * the actual mesh is not running, so we can freely edit it. */ 1691238106Sdes /* delete all the existing queries first */ 1692238106Sdes mesh_delete_all(worker->env.mesh); 1693238106Sdes if(strcmp(args, "off") == 0) { 1694238106Sdes forwards_delete_zone(fwd, LDNS_RR_CLASS_IN, root); 1695238106Sdes } else { 1696238106Sdes struct delegpt* dp; 1697238106Sdes if(!(dp = parse_delegpt(ssl, args, root, 0))) 1698238106Sdes return; 1699238106Sdes if(!forwards_add_zone(fwd, LDNS_RR_CLASS_IN, dp)) { 1700238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1701238106Sdes return; 1702238106Sdes } 1703238106Sdes } 1704238106Sdes send_ok(ssl); 1705238106Sdes} 1706238106Sdes 1707238106Sdesstatic int 1708238106Sdesparse_fs_args(SSL* ssl, char* args, uint8_t** nm, struct delegpt** dp, 1709238106Sdes int* insecure, int* prime) 1710238106Sdes{ 1711238106Sdes char* zonename; 1712238106Sdes char* rest; 1713238106Sdes size_t nmlen; 1714238106Sdes int nmlabs; 1715238106Sdes /* parse all -x args */ 1716238106Sdes while(args[0] == '+') { 1717238106Sdes if(!find_arg2(ssl, args, &rest)) 1718238106Sdes return 0; 1719238106Sdes while(*(++args) != 0) { 1720238106Sdes if(*args == 'i' && insecure) 1721238106Sdes *insecure = 1; 1722238106Sdes else if(*args == 'p' && prime) 1723238106Sdes *prime = 1; 1724238106Sdes else { 1725238106Sdes (void)ssl_printf(ssl, "error: unknown option %s\n", args); 1726238106Sdes return 0; 1727238106Sdes } 1728238106Sdes } 1729238106Sdes args = rest; 1730238106Sdes } 1731238106Sdes /* parse name */ 1732238106Sdes if(dp) { 1733238106Sdes if(!find_arg2(ssl, args, &rest)) 1734238106Sdes return 0; 1735238106Sdes zonename = args; 1736238106Sdes args = rest; 1737238106Sdes } else zonename = args; 1738238106Sdes if(!parse_arg_name(ssl, zonename, nm, &nmlen, &nmlabs)) 1739238106Sdes return 0; 1740238106Sdes 1741238106Sdes /* parse dp */ 1742238106Sdes if(dp) { 1743238106Sdes if(!(*dp = parse_delegpt(ssl, args, *nm, 1))) { 1744238106Sdes free(*nm); 1745238106Sdes return 0; 1746238106Sdes } 1747238106Sdes } 1748238106Sdes return 1; 1749238106Sdes} 1750238106Sdes 1751238106Sdes/** do the forward_add command */ 1752238106Sdesstatic void 1753238106Sdesdo_forward_add(SSL* ssl, struct worker* worker, char* args) 1754238106Sdes{ 1755238106Sdes struct iter_forwards* fwd = worker->env.fwds; 1756238106Sdes int insecure = 0; 1757238106Sdes uint8_t* nm = NULL; 1758238106Sdes struct delegpt* dp = NULL; 1759238106Sdes if(!parse_fs_args(ssl, args, &nm, &dp, &insecure, NULL)) 1760238106Sdes return; 1761269257Sdes if(insecure && worker->env.anchors) { 1762238106Sdes if(!anchors_add_insecure(worker->env.anchors, LDNS_RR_CLASS_IN, 1763238106Sdes nm)) { 1764238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1765238106Sdes delegpt_free_mlc(dp); 1766238106Sdes free(nm); 1767238106Sdes return; 1768238106Sdes } 1769238106Sdes } 1770238106Sdes if(!forwards_add_zone(fwd, LDNS_RR_CLASS_IN, dp)) { 1771238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1772238106Sdes free(nm); 1773238106Sdes return; 1774238106Sdes } 1775238106Sdes free(nm); 1776238106Sdes send_ok(ssl); 1777238106Sdes} 1778238106Sdes 1779238106Sdes/** do the forward_remove command */ 1780238106Sdesstatic void 1781238106Sdesdo_forward_remove(SSL* ssl, struct worker* worker, char* args) 1782238106Sdes{ 1783238106Sdes struct iter_forwards* fwd = worker->env.fwds; 1784238106Sdes int insecure = 0; 1785238106Sdes uint8_t* nm = NULL; 1786238106Sdes if(!parse_fs_args(ssl, args, &nm, NULL, &insecure, NULL)) 1787238106Sdes return; 1788269257Sdes if(insecure && worker->env.anchors) 1789238106Sdes anchors_delete_insecure(worker->env.anchors, LDNS_RR_CLASS_IN, 1790238106Sdes nm); 1791238106Sdes forwards_delete_zone(fwd, LDNS_RR_CLASS_IN, nm); 1792238106Sdes free(nm); 1793238106Sdes send_ok(ssl); 1794238106Sdes} 1795238106Sdes 1796238106Sdes/** do the stub_add command */ 1797238106Sdesstatic void 1798238106Sdesdo_stub_add(SSL* ssl, struct worker* worker, char* args) 1799238106Sdes{ 1800238106Sdes struct iter_forwards* fwd = worker->env.fwds; 1801238106Sdes int insecure = 0, prime = 0; 1802238106Sdes uint8_t* nm = NULL; 1803238106Sdes struct delegpt* dp = NULL; 1804238106Sdes if(!parse_fs_args(ssl, args, &nm, &dp, &insecure, &prime)) 1805238106Sdes return; 1806269257Sdes if(insecure && worker->env.anchors) { 1807238106Sdes if(!anchors_add_insecure(worker->env.anchors, LDNS_RR_CLASS_IN, 1808238106Sdes nm)) { 1809238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1810238106Sdes delegpt_free_mlc(dp); 1811238106Sdes free(nm); 1812238106Sdes return; 1813238106Sdes } 1814238106Sdes } 1815238106Sdes if(!forwards_add_stub_hole(fwd, LDNS_RR_CLASS_IN, nm)) { 1816269257Sdes if(insecure && worker->env.anchors) 1817269257Sdes anchors_delete_insecure(worker->env.anchors, 1818269257Sdes LDNS_RR_CLASS_IN, nm); 1819238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1820238106Sdes delegpt_free_mlc(dp); 1821238106Sdes free(nm); 1822238106Sdes return; 1823238106Sdes } 1824238106Sdes if(!hints_add_stub(worker->env.hints, LDNS_RR_CLASS_IN, dp, !prime)) { 1825238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1826238106Sdes forwards_delete_stub_hole(fwd, LDNS_RR_CLASS_IN, nm); 1827269257Sdes if(insecure && worker->env.anchors) 1828269257Sdes anchors_delete_insecure(worker->env.anchors, 1829269257Sdes LDNS_RR_CLASS_IN, nm); 1830238106Sdes free(nm); 1831238106Sdes return; 1832238106Sdes } 1833238106Sdes free(nm); 1834238106Sdes send_ok(ssl); 1835238106Sdes} 1836238106Sdes 1837238106Sdes/** do the stub_remove command */ 1838238106Sdesstatic void 1839238106Sdesdo_stub_remove(SSL* ssl, struct worker* worker, char* args) 1840238106Sdes{ 1841238106Sdes struct iter_forwards* fwd = worker->env.fwds; 1842238106Sdes int insecure = 0; 1843238106Sdes uint8_t* nm = NULL; 1844238106Sdes if(!parse_fs_args(ssl, args, &nm, NULL, &insecure, NULL)) 1845238106Sdes return; 1846269257Sdes if(insecure && worker->env.anchors) 1847238106Sdes anchors_delete_insecure(worker->env.anchors, LDNS_RR_CLASS_IN, 1848238106Sdes nm); 1849238106Sdes forwards_delete_stub_hole(fwd, LDNS_RR_CLASS_IN, nm); 1850238106Sdes hints_delete_stub(worker->env.hints, LDNS_RR_CLASS_IN, nm); 1851238106Sdes free(nm); 1852238106Sdes send_ok(ssl); 1853238106Sdes} 1854238106Sdes 1855269257Sdes/** do the insecure_add command */ 1856269257Sdesstatic void 1857269257Sdesdo_insecure_add(SSL* ssl, struct worker* worker, char* arg) 1858269257Sdes{ 1859269257Sdes size_t nmlen; 1860269257Sdes int nmlabs; 1861269257Sdes uint8_t* nm = NULL; 1862269257Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1863269257Sdes return; 1864269257Sdes if(worker->env.anchors) { 1865269257Sdes if(!anchors_add_insecure(worker->env.anchors, 1866269257Sdes LDNS_RR_CLASS_IN, nm)) { 1867269257Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1868269257Sdes free(nm); 1869269257Sdes return; 1870269257Sdes } 1871269257Sdes } 1872269257Sdes free(nm); 1873269257Sdes send_ok(ssl); 1874269257Sdes} 1875269257Sdes 1876269257Sdes/** do the insecure_remove command */ 1877269257Sdesstatic void 1878269257Sdesdo_insecure_remove(SSL* ssl, struct worker* worker, char* arg) 1879269257Sdes{ 1880269257Sdes size_t nmlen; 1881269257Sdes int nmlabs; 1882269257Sdes uint8_t* nm = NULL; 1883269257Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1884269257Sdes return; 1885269257Sdes if(worker->env.anchors) 1886269257Sdes anchors_delete_insecure(worker->env.anchors, 1887269257Sdes LDNS_RR_CLASS_IN, nm); 1888269257Sdes free(nm); 1889269257Sdes send_ok(ssl); 1890269257Sdes} 1891269257Sdes 1892238106Sdes/** do the status command */ 1893238106Sdesstatic void 1894238106Sdesdo_status(SSL* ssl, struct worker* worker) 1895238106Sdes{ 1896238106Sdes int i; 1897238106Sdes time_t uptime; 1898238106Sdes if(!ssl_printf(ssl, "version: %s\n", PACKAGE_VERSION)) 1899238106Sdes return; 1900238106Sdes if(!ssl_printf(ssl, "verbosity: %d\n", verbosity)) 1901238106Sdes return; 1902238106Sdes if(!ssl_printf(ssl, "threads: %d\n", worker->daemon->num)) 1903238106Sdes return; 1904238106Sdes if(!ssl_printf(ssl, "modules: %d [", worker->daemon->mods.num)) 1905238106Sdes return; 1906238106Sdes for(i=0; i<worker->daemon->mods.num; i++) { 1907238106Sdes if(!ssl_printf(ssl, " %s", worker->daemon->mods.mod[i]->name)) 1908238106Sdes return; 1909238106Sdes } 1910238106Sdes if(!ssl_printf(ssl, " ]\n")) 1911238106Sdes return; 1912238106Sdes uptime = (time_t)time(NULL) - (time_t)worker->daemon->time_boot.tv_sec; 1913269257Sdes if(!ssl_printf(ssl, "uptime: " ARG_LL "d seconds\n", (long long)uptime)) 1914238106Sdes return; 1915285206Sdes if(!ssl_printf(ssl, "options:%s%s\n" , 1916285206Sdes (worker->daemon->reuseport?" reuseport":""), 1917285206Sdes (worker->daemon->rc->accept_list?" control(ssl)":""))) 1918285206Sdes return; 1919238106Sdes if(!ssl_printf(ssl, "unbound (pid %d) is running...\n", 1920238106Sdes (int)getpid())) 1921238106Sdes return; 1922238106Sdes} 1923238106Sdes 1924238106Sdes/** get age for the mesh state */ 1925238106Sdesstatic void 1926238106Sdesget_mesh_age(struct mesh_state* m, char* buf, size_t len, 1927238106Sdes struct module_env* env) 1928238106Sdes{ 1929238106Sdes if(m->reply_list) { 1930238106Sdes struct timeval d; 1931238106Sdes struct mesh_reply* r = m->reply_list; 1932238106Sdes /* last reply is the oldest */ 1933238106Sdes while(r && r->next) 1934238106Sdes r = r->next; 1935238106Sdes timeval_subtract(&d, env->now_tv, &r->start_time); 1936269257Sdes snprintf(buf, len, ARG_LL "d.%6.6d", 1937269257Sdes (long long)d.tv_sec, (int)d.tv_usec); 1938238106Sdes } else { 1939238106Sdes snprintf(buf, len, "-"); 1940238106Sdes } 1941238106Sdes} 1942238106Sdes 1943238106Sdes/** get status of a mesh state */ 1944238106Sdesstatic void 1945238106Sdesget_mesh_status(struct mesh_area* mesh, struct mesh_state* m, 1946238106Sdes char* buf, size_t len) 1947238106Sdes{ 1948238106Sdes enum module_ext_state s = m->s.ext_state[m->s.curmod]; 1949238106Sdes const char *modname = mesh->mods.mod[m->s.curmod]->name; 1950238106Sdes size_t l; 1951238106Sdes if(strcmp(modname, "iterator") == 0 && s == module_wait_reply && 1952238106Sdes m->s.minfo[m->s.curmod]) { 1953238106Sdes /* break into iterator to find out who its waiting for */ 1954238106Sdes struct iter_qstate* qstate = (struct iter_qstate*) 1955238106Sdes m->s.minfo[m->s.curmod]; 1956238106Sdes struct outbound_list* ol = &qstate->outlist; 1957238106Sdes struct outbound_entry* e; 1958238106Sdes snprintf(buf, len, "%s wait for", modname); 1959238106Sdes l = strlen(buf); 1960238106Sdes buf += l; len -= l; 1961238106Sdes if(ol->first == NULL) 1962238106Sdes snprintf(buf, len, " (empty_list)"); 1963238106Sdes for(e = ol->first; e; e = e->next) { 1964238106Sdes snprintf(buf, len, " "); 1965238106Sdes l = strlen(buf); 1966238106Sdes buf += l; len -= l; 1967238106Sdes addr_to_str(&e->qsent->addr, e->qsent->addrlen, 1968238106Sdes buf, len); 1969238106Sdes l = strlen(buf); 1970238106Sdes buf += l; len -= l; 1971238106Sdes } 1972238106Sdes } else if(s == module_wait_subquery) { 1973238106Sdes /* look in subs from mesh state to see what */ 1974238106Sdes char nm[257]; 1975238106Sdes struct mesh_state_ref* sub; 1976238106Sdes snprintf(buf, len, "%s wants", modname); 1977238106Sdes l = strlen(buf); 1978238106Sdes buf += l; len -= l; 1979238106Sdes if(m->sub_set.count == 0) 1980238106Sdes snprintf(buf, len, " (empty_list)"); 1981238106Sdes RBTREE_FOR(sub, struct mesh_state_ref*, &m->sub_set) { 1982269257Sdes char* t = sldns_wire2str_type(sub->s->s.qinfo.qtype); 1983269257Sdes char* c = sldns_wire2str_class(sub->s->s.qinfo.qclass); 1984238106Sdes dname_str(sub->s->s.qinfo.qname, nm); 1985269257Sdes snprintf(buf, len, " %s %s %s", (t?t:"TYPE??"), 1986269257Sdes (c?c:"CLASS??"), nm); 1987238106Sdes l = strlen(buf); 1988238106Sdes buf += l; len -= l; 1989238106Sdes free(t); 1990238106Sdes free(c); 1991238106Sdes } 1992238106Sdes } else { 1993238106Sdes snprintf(buf, len, "%s is %s", modname, strextstate(s)); 1994238106Sdes } 1995238106Sdes} 1996238106Sdes 1997238106Sdes/** do the dump_requestlist command */ 1998238106Sdesstatic void 1999238106Sdesdo_dump_requestlist(SSL* ssl, struct worker* worker) 2000238106Sdes{ 2001238106Sdes struct mesh_area* mesh; 2002238106Sdes struct mesh_state* m; 2003238106Sdes int num = 0; 2004238106Sdes char buf[257]; 2005238106Sdes char timebuf[32]; 2006238106Sdes char statbuf[10240]; 2007238106Sdes if(!ssl_printf(ssl, "thread #%d\n", worker->thread_num)) 2008238106Sdes return; 2009238106Sdes if(!ssl_printf(ssl, "# type cl name seconds module status\n")) 2010238106Sdes return; 2011238106Sdes /* show worker mesh contents */ 2012238106Sdes mesh = worker->env.mesh; 2013238106Sdes if(!mesh) return; 2014238106Sdes RBTREE_FOR(m, struct mesh_state*, &mesh->all) { 2015269257Sdes char* t = sldns_wire2str_type(m->s.qinfo.qtype); 2016269257Sdes char* c = sldns_wire2str_class(m->s.qinfo.qclass); 2017238106Sdes dname_str(m->s.qinfo.qname, buf); 2018238106Sdes get_mesh_age(m, timebuf, sizeof(timebuf), &worker->env); 2019238106Sdes get_mesh_status(mesh, m, statbuf, sizeof(statbuf)); 2020238106Sdes if(!ssl_printf(ssl, "%3d %4s %2s %s %s %s\n", 2021269257Sdes num, (t?t:"TYPE??"), (c?c:"CLASS??"), buf, timebuf, 2022269257Sdes statbuf)) { 2023238106Sdes free(t); 2024238106Sdes free(c); 2025238106Sdes return; 2026238106Sdes } 2027238106Sdes num++; 2028238106Sdes free(t); 2029238106Sdes free(c); 2030238106Sdes } 2031238106Sdes} 2032238106Sdes 2033238106Sdes/** structure for argument data for dump infra host */ 2034238106Sdesstruct infra_arg { 2035238106Sdes /** the infra cache */ 2036238106Sdes struct infra_cache* infra; 2037238106Sdes /** the SSL connection */ 2038238106Sdes SSL* ssl; 2039238106Sdes /** the time now */ 2040269257Sdes time_t now; 2041285206Sdes /** ssl failure? stop writing and skip the rest. If the tcp 2042285206Sdes * connection is broken, and writes fail, we then stop writing. */ 2043285206Sdes int ssl_failed; 2044238106Sdes}; 2045238106Sdes 2046238106Sdes/** callback for every host element in the infra cache */ 2047238106Sdesstatic void 2048238106Sdesdump_infra_host(struct lruhash_entry* e, void* arg) 2049238106Sdes{ 2050238106Sdes struct infra_arg* a = (struct infra_arg*)arg; 2051238106Sdes struct infra_key* k = (struct infra_key*)e->key; 2052238106Sdes struct infra_data* d = (struct infra_data*)e->data; 2053238106Sdes char ip_str[1024]; 2054238106Sdes char name[257]; 2055285206Sdes if(a->ssl_failed) 2056285206Sdes return; 2057238106Sdes addr_to_str(&k->addr, k->addrlen, ip_str, sizeof(ip_str)); 2058238106Sdes dname_str(k->zonename, name); 2059238106Sdes /* skip expired stuff (only backed off) */ 2060238106Sdes if(d->ttl < a->now) { 2061238106Sdes if(d->rtt.rto >= USEFUL_SERVER_TOP_TIMEOUT) { 2062238106Sdes if(!ssl_printf(a->ssl, "%s %s expired rto %d\n", ip_str, 2063285206Sdes name, d->rtt.rto)) { 2064285206Sdes a->ssl_failed = 1; 2065285206Sdes return; 2066285206Sdes } 2067238106Sdes } 2068238106Sdes return; 2069238106Sdes } 2070285206Sdes if(!ssl_printf(a->ssl, "%s %s ttl %lu ping %d var %d rtt %d rto %d " 2071238106Sdes "tA %d tAAAA %d tother %d " 2072238106Sdes "ednsknown %d edns %d delay %d lame dnssec %d rec %d A %d " 2073285206Sdes "other %d\n", ip_str, name, (unsigned long)(d->ttl - a->now), 2074238106Sdes d->rtt.srtt, d->rtt.rttvar, rtt_notimeout(&d->rtt), d->rtt.rto, 2075238106Sdes d->timeout_A, d->timeout_AAAA, d->timeout_other, 2076238106Sdes (int)d->edns_lame_known, (int)d->edns_version, 2077238106Sdes (int)(a->now<d->probedelay?d->probedelay-a->now:0), 2078238106Sdes (int)d->isdnsseclame, (int)d->rec_lame, (int)d->lame_type_A, 2079285206Sdes (int)d->lame_other)) { 2080285206Sdes a->ssl_failed = 1; 2081238106Sdes return; 2082285206Sdes } 2083238106Sdes} 2084238106Sdes 2085238106Sdes/** do the dump_infra command */ 2086238106Sdesstatic void 2087238106Sdesdo_dump_infra(SSL* ssl, struct worker* worker) 2088238106Sdes{ 2089238106Sdes struct infra_arg arg; 2090238106Sdes arg.infra = worker->env.infra_cache; 2091238106Sdes arg.ssl = ssl; 2092238106Sdes arg.now = *worker->env.now; 2093285206Sdes arg.ssl_failed = 0; 2094238106Sdes slabhash_traverse(arg.infra->hosts, 0, &dump_infra_host, (void*)&arg); 2095238106Sdes} 2096238106Sdes 2097238106Sdes/** do the log_reopen command */ 2098238106Sdesstatic void 2099238106Sdesdo_log_reopen(SSL* ssl, struct worker* worker) 2100238106Sdes{ 2101238106Sdes struct config_file* cfg = worker->env.cfg; 2102238106Sdes send_ok(ssl); 2103238106Sdes log_init(cfg->logfile, cfg->use_syslog, cfg->chrootdir); 2104238106Sdes} 2105238106Sdes 2106238106Sdes/** do the set_option command */ 2107238106Sdesstatic void 2108238106Sdesdo_set_option(SSL* ssl, struct worker* worker, char* arg) 2109238106Sdes{ 2110238106Sdes char* arg2; 2111238106Sdes if(!find_arg2(ssl, arg, &arg2)) 2112238106Sdes return; 2113238106Sdes if(!config_set_option(worker->env.cfg, arg, arg2)) { 2114238106Sdes (void)ssl_printf(ssl, "error setting option\n"); 2115238106Sdes return; 2116238106Sdes } 2117238106Sdes send_ok(ssl); 2118238106Sdes} 2119238106Sdes 2120238106Sdes/* routine to printout option values over SSL */ 2121238106Sdesvoid remote_get_opt_ssl(char* line, void* arg) 2122238106Sdes{ 2123238106Sdes SSL* ssl = (SSL*)arg; 2124238106Sdes (void)ssl_printf(ssl, "%s\n", line); 2125238106Sdes} 2126238106Sdes 2127238106Sdes/** do the get_option command */ 2128238106Sdesstatic void 2129238106Sdesdo_get_option(SSL* ssl, struct worker* worker, char* arg) 2130238106Sdes{ 2131238106Sdes int r; 2132238106Sdes r = config_get_option(worker->env.cfg, arg, remote_get_opt_ssl, ssl); 2133238106Sdes if(!r) { 2134238106Sdes (void)ssl_printf(ssl, "error unknown option\n"); 2135238106Sdes return; 2136238106Sdes } 2137238106Sdes} 2138238106Sdes 2139238106Sdes/** do the list_forwards command */ 2140238106Sdesstatic void 2141238106Sdesdo_list_forwards(SSL* ssl, struct worker* worker) 2142238106Sdes{ 2143238106Sdes /* since its a per-worker structure no locks needed */ 2144238106Sdes struct iter_forwards* fwds = worker->env.fwds; 2145238106Sdes struct iter_forward_zone* z; 2146285206Sdes struct trust_anchor* a; 2147285206Sdes int insecure; 2148238106Sdes RBTREE_FOR(z, struct iter_forward_zone*, fwds->tree) { 2149238106Sdes if(!z->dp) continue; /* skip empty marker for stub */ 2150285206Sdes 2151285206Sdes /* see if it is insecure */ 2152285206Sdes insecure = 0; 2153285206Sdes if(worker->env.anchors && 2154285206Sdes (a=anchor_find(worker->env.anchors, z->name, 2155285206Sdes z->namelabs, z->namelen, z->dclass))) { 2156285206Sdes if(!a->keylist && !a->numDS && !a->numDNSKEY) 2157285206Sdes insecure = 1; 2158285206Sdes lock_basic_unlock(&a->lock); 2159285206Sdes } 2160285206Sdes 2161285206Sdes if(!ssl_print_name_dp(ssl, (insecure?"forward +i":"forward"), 2162285206Sdes z->name, z->dclass, z->dp)) 2163238106Sdes return; 2164238106Sdes } 2165238106Sdes} 2166238106Sdes 2167238106Sdes/** do the list_stubs command */ 2168238106Sdesstatic void 2169238106Sdesdo_list_stubs(SSL* ssl, struct worker* worker) 2170238106Sdes{ 2171238106Sdes struct iter_hints_stub* z; 2172285206Sdes struct trust_anchor* a; 2173285206Sdes int insecure; 2174285206Sdes char str[32]; 2175238106Sdes RBTREE_FOR(z, struct iter_hints_stub*, &worker->env.hints->tree) { 2176285206Sdes 2177285206Sdes /* see if it is insecure */ 2178285206Sdes insecure = 0; 2179285206Sdes if(worker->env.anchors && 2180285206Sdes (a=anchor_find(worker->env.anchors, z->node.name, 2181285206Sdes z->node.labs, z->node.len, z->node.dclass))) { 2182285206Sdes if(!a->keylist && !a->numDS && !a->numDNSKEY) 2183285206Sdes insecure = 1; 2184285206Sdes lock_basic_unlock(&a->lock); 2185285206Sdes } 2186285206Sdes 2187285206Sdes snprintf(str, sizeof(str), "stub %sprime%s", 2188285206Sdes (z->noprime?"no":""), (insecure?" +i":"")); 2189285206Sdes if(!ssl_print_name_dp(ssl, str, z->node.name, 2190238106Sdes z->node.dclass, z->dp)) 2191238106Sdes return; 2192238106Sdes } 2193238106Sdes} 2194238106Sdes 2195238106Sdes/** do the list_local_zones command */ 2196238106Sdesstatic void 2197238106Sdesdo_list_local_zones(SSL* ssl, struct worker* worker) 2198238106Sdes{ 2199238106Sdes struct local_zones* zones = worker->daemon->local_zones; 2200238106Sdes struct local_zone* z; 2201238106Sdes char buf[257]; 2202269257Sdes lock_rw_rdlock(&zones->lock); 2203238106Sdes RBTREE_FOR(z, struct local_zone*, &zones->ztree) { 2204238106Sdes lock_rw_rdlock(&z->lock); 2205238106Sdes dname_str(z->name, buf); 2206285206Sdes if(!ssl_printf(ssl, "%s %s\n", buf, 2207285206Sdes local_zone_type2str(z->type))) { 2208285206Sdes /* failure to print */ 2209285206Sdes lock_rw_unlock(&z->lock); 2210285206Sdes lock_rw_unlock(&zones->lock); 2211285206Sdes return; 2212285206Sdes } 2213238106Sdes lock_rw_unlock(&z->lock); 2214238106Sdes } 2215269257Sdes lock_rw_unlock(&zones->lock); 2216238106Sdes} 2217238106Sdes 2218238106Sdes/** do the list_local_data command */ 2219238106Sdesstatic void 2220238106Sdesdo_list_local_data(SSL* ssl, struct worker* worker) 2221238106Sdes{ 2222238106Sdes struct local_zones* zones = worker->daemon->local_zones; 2223238106Sdes struct local_zone* z; 2224238106Sdes struct local_data* d; 2225238106Sdes struct local_rrset* p; 2226269257Sdes char* s = (char*)sldns_buffer_begin(worker->env.scratch_buffer); 2227269257Sdes size_t slen = sldns_buffer_capacity(worker->env.scratch_buffer); 2228269257Sdes lock_rw_rdlock(&zones->lock); 2229238106Sdes RBTREE_FOR(z, struct local_zone*, &zones->ztree) { 2230238106Sdes lock_rw_rdlock(&z->lock); 2231238106Sdes RBTREE_FOR(d, struct local_data*, &z->data) { 2232238106Sdes for(p = d->rrsets; p; p = p->next) { 2233269257Sdes struct packed_rrset_data* d = 2234269257Sdes (struct packed_rrset_data*)p->rrset->entry.data; 2235269257Sdes size_t i; 2236269257Sdes for(i=0; i<d->count + d->rrsig_count; i++) { 2237269257Sdes if(!packed_rr_to_string(p->rrset, i, 2238269257Sdes 0, s, slen)) { 2239269257Sdes if(!ssl_printf(ssl, "BADRR\n")) 2240269257Sdes return; 2241269257Sdes } 2242269257Sdes if(!ssl_printf(ssl, "%s\n", s)) 2243269257Sdes return; 2244269257Sdes } 2245238106Sdes } 2246238106Sdes } 2247238106Sdes lock_rw_unlock(&z->lock); 2248238106Sdes } 2249269257Sdes lock_rw_unlock(&zones->lock); 2250238106Sdes} 2251238106Sdes 2252238106Sdes/** tell other processes to execute the command */ 2253238106Sdesstatic void 2254238106Sdesdistribute_cmd(struct daemon_remote* rc, SSL* ssl, char* cmd) 2255238106Sdes{ 2256238106Sdes int i; 2257238106Sdes if(!cmd || !ssl) 2258238106Sdes return; 2259238106Sdes /* skip i=0 which is me */ 2260238106Sdes for(i=1; i<rc->worker->daemon->num; i++) { 2261238106Sdes worker_send_cmd(rc->worker->daemon->workers[i], 2262238106Sdes worker_cmd_remote); 2263238106Sdes if(!tube_write_msg(rc->worker->daemon->workers[i]->cmd, 2264238106Sdes (uint8_t*)cmd, strlen(cmd)+1, 0)) { 2265238106Sdes ssl_printf(ssl, "error could not distribute cmd\n"); 2266238106Sdes return; 2267238106Sdes } 2268238106Sdes } 2269238106Sdes} 2270238106Sdes 2271238106Sdes/** check for name with end-of-string, space or tab after it */ 2272238106Sdesstatic int 2273238106Sdescmdcmp(char* p, const char* cmd, size_t len) 2274238106Sdes{ 2275238106Sdes return strncmp(p,cmd,len)==0 && (p[len]==0||p[len]==' '||p[len]=='\t'); 2276238106Sdes} 2277238106Sdes 2278238106Sdes/** execute a remote control command */ 2279238106Sdesstatic void 2280238106Sdesexecute_cmd(struct daemon_remote* rc, SSL* ssl, char* cmd, 2281238106Sdes struct worker* worker) 2282238106Sdes{ 2283238106Sdes char* p = skipwhite(cmd); 2284238106Sdes /* compare command */ 2285238106Sdes if(cmdcmp(p, "stop", 4)) { 2286238106Sdes do_stop(ssl, rc); 2287238106Sdes return; 2288238106Sdes } else if(cmdcmp(p, "reload", 6)) { 2289238106Sdes do_reload(ssl, rc); 2290238106Sdes return; 2291238106Sdes } else if(cmdcmp(p, "stats_noreset", 13)) { 2292238106Sdes do_stats(ssl, rc, 0); 2293238106Sdes return; 2294238106Sdes } else if(cmdcmp(p, "stats", 5)) { 2295238106Sdes do_stats(ssl, rc, 1); 2296238106Sdes return; 2297238106Sdes } else if(cmdcmp(p, "status", 6)) { 2298238106Sdes do_status(ssl, worker); 2299238106Sdes return; 2300238106Sdes } else if(cmdcmp(p, "dump_cache", 10)) { 2301238106Sdes (void)dump_cache(ssl, worker); 2302238106Sdes return; 2303238106Sdes } else if(cmdcmp(p, "load_cache", 10)) { 2304238106Sdes if(load_cache(ssl, worker)) send_ok(ssl); 2305238106Sdes return; 2306238106Sdes } else if(cmdcmp(p, "list_forwards", 13)) { 2307238106Sdes do_list_forwards(ssl, worker); 2308238106Sdes return; 2309238106Sdes } else if(cmdcmp(p, "list_stubs", 10)) { 2310238106Sdes do_list_stubs(ssl, worker); 2311238106Sdes return; 2312238106Sdes } else if(cmdcmp(p, "list_local_zones", 16)) { 2313238106Sdes do_list_local_zones(ssl, worker); 2314238106Sdes return; 2315238106Sdes } else if(cmdcmp(p, "list_local_data", 15)) { 2316238106Sdes do_list_local_data(ssl, worker); 2317238106Sdes return; 2318238106Sdes } else if(cmdcmp(p, "stub_add", 8)) { 2319238106Sdes /* must always distribute this cmd */ 2320238106Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2321238106Sdes do_stub_add(ssl, worker, skipwhite(p+8)); 2322238106Sdes return; 2323238106Sdes } else if(cmdcmp(p, "stub_remove", 11)) { 2324238106Sdes /* must always distribute this cmd */ 2325238106Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2326238106Sdes do_stub_remove(ssl, worker, skipwhite(p+11)); 2327238106Sdes return; 2328238106Sdes } else if(cmdcmp(p, "forward_add", 11)) { 2329238106Sdes /* must always distribute this cmd */ 2330238106Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2331238106Sdes do_forward_add(ssl, worker, skipwhite(p+11)); 2332238106Sdes return; 2333238106Sdes } else if(cmdcmp(p, "forward_remove", 14)) { 2334238106Sdes /* must always distribute this cmd */ 2335238106Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2336238106Sdes do_forward_remove(ssl, worker, skipwhite(p+14)); 2337238106Sdes return; 2338269257Sdes } else if(cmdcmp(p, "insecure_add", 12)) { 2339269257Sdes /* must always distribute this cmd */ 2340269257Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2341269257Sdes do_insecure_add(ssl, worker, skipwhite(p+12)); 2342269257Sdes return; 2343269257Sdes } else if(cmdcmp(p, "insecure_remove", 15)) { 2344269257Sdes /* must always distribute this cmd */ 2345269257Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2346269257Sdes do_insecure_remove(ssl, worker, skipwhite(p+15)); 2347269257Sdes return; 2348238106Sdes } else if(cmdcmp(p, "forward", 7)) { 2349238106Sdes /* must always distribute this cmd */ 2350238106Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2351238106Sdes do_forward(ssl, worker, skipwhite(p+7)); 2352238106Sdes return; 2353238106Sdes } else if(cmdcmp(p, "flush_stats", 11)) { 2354238106Sdes /* must always distribute this cmd */ 2355238106Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2356238106Sdes do_flush_stats(ssl, worker); 2357238106Sdes return; 2358238106Sdes } else if(cmdcmp(p, "flush_requestlist", 17)) { 2359238106Sdes /* must always distribute this cmd */ 2360238106Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2361238106Sdes do_flush_requestlist(ssl, worker); 2362238106Sdes return; 2363238106Sdes } else if(cmdcmp(p, "lookup", 6)) { 2364238106Sdes do_lookup(ssl, worker, skipwhite(p+6)); 2365238106Sdes return; 2366238106Sdes } 2367238106Sdes 2368238106Sdes#ifdef THREADS_DISABLED 2369238106Sdes /* other processes must execute the command as well */ 2370238106Sdes /* commands that should not be distributed, returned above. */ 2371238106Sdes if(rc) { /* only if this thread is the master (rc) thread */ 2372238106Sdes /* done before the code below, which may split the string */ 2373238106Sdes distribute_cmd(rc, ssl, cmd); 2374238106Sdes } 2375238106Sdes#endif 2376238106Sdes if(cmdcmp(p, "verbosity", 9)) { 2377238106Sdes do_verbosity(ssl, skipwhite(p+9)); 2378238106Sdes } else if(cmdcmp(p, "local_zone_remove", 17)) { 2379238106Sdes do_zone_remove(ssl, worker, skipwhite(p+17)); 2380238106Sdes } else if(cmdcmp(p, "local_zone", 10)) { 2381238106Sdes do_zone_add(ssl, worker, skipwhite(p+10)); 2382238106Sdes } else if(cmdcmp(p, "local_data_remove", 17)) { 2383238106Sdes do_data_remove(ssl, worker, skipwhite(p+17)); 2384238106Sdes } else if(cmdcmp(p, "local_data", 10)) { 2385238106Sdes do_data_add(ssl, worker, skipwhite(p+10)); 2386238106Sdes } else if(cmdcmp(p, "flush_zone", 10)) { 2387238106Sdes do_flush_zone(ssl, worker, skipwhite(p+10)); 2388238106Sdes } else if(cmdcmp(p, "flush_type", 10)) { 2389238106Sdes do_flush_type(ssl, worker, skipwhite(p+10)); 2390238106Sdes } else if(cmdcmp(p, "flush_infra", 11)) { 2391238106Sdes do_flush_infra(ssl, worker, skipwhite(p+11)); 2392238106Sdes } else if(cmdcmp(p, "flush", 5)) { 2393238106Sdes do_flush_name(ssl, worker, skipwhite(p+5)); 2394238106Sdes } else if(cmdcmp(p, "dump_requestlist", 16)) { 2395238106Sdes do_dump_requestlist(ssl, worker); 2396238106Sdes } else if(cmdcmp(p, "dump_infra", 10)) { 2397238106Sdes do_dump_infra(ssl, worker); 2398238106Sdes } else if(cmdcmp(p, "log_reopen", 10)) { 2399238106Sdes do_log_reopen(ssl, worker); 2400238106Sdes } else if(cmdcmp(p, "set_option", 10)) { 2401238106Sdes do_set_option(ssl, worker, skipwhite(p+10)); 2402238106Sdes } else if(cmdcmp(p, "get_option", 10)) { 2403238106Sdes do_get_option(ssl, worker, skipwhite(p+10)); 2404249141Sdes } else if(cmdcmp(p, "flush_bogus", 11)) { 2405249141Sdes do_flush_bogus(ssl, worker); 2406285206Sdes } else if(cmdcmp(p, "flush_negative", 14)) { 2407285206Sdes do_flush_negative(ssl, worker); 2408238106Sdes } else { 2409238106Sdes (void)ssl_printf(ssl, "error unknown command '%s'\n", p); 2410238106Sdes } 2411238106Sdes} 2412238106Sdes 2413238106Sdesvoid 2414238106Sdesdaemon_remote_exec(struct worker* worker) 2415238106Sdes{ 2416238106Sdes /* read the cmd string */ 2417238106Sdes uint8_t* msg = NULL; 2418238106Sdes uint32_t len = 0; 2419238106Sdes if(!tube_read_msg(worker->cmd, &msg, &len, 0)) { 2420238106Sdes log_err("daemon_remote_exec: tube_read_msg failed"); 2421238106Sdes return; 2422238106Sdes } 2423238106Sdes verbose(VERB_ALGO, "remote exec distributed: %s", (char*)msg); 2424238106Sdes execute_cmd(NULL, NULL, (char*)msg, worker); 2425238106Sdes free(msg); 2426238106Sdes} 2427238106Sdes 2428238106Sdes/** handle remote control request */ 2429238106Sdesstatic void 2430238106Sdeshandle_req(struct daemon_remote* rc, struct rc_state* s, SSL* ssl) 2431238106Sdes{ 2432238106Sdes int r; 2433238106Sdes char pre[10]; 2434238106Sdes char magic[7]; 2435238106Sdes char buf[1024]; 2436238106Sdes#ifdef USE_WINSOCK 2437238106Sdes /* makes it possible to set the socket blocking again. */ 2438238106Sdes /* basically removes it from winsock_event ... */ 2439238106Sdes WSAEventSelect(s->c->fd, NULL, 0); 2440238106Sdes#endif 2441238106Sdes fd_set_block(s->c->fd); 2442238106Sdes 2443238106Sdes /* try to read magic UBCT[version]_space_ string */ 2444238106Sdes ERR_clear_error(); 2445238106Sdes if((r=SSL_read(ssl, magic, (int)sizeof(magic)-1)) <= 0) { 2446238106Sdes if(SSL_get_error(ssl, r) == SSL_ERROR_ZERO_RETURN) 2447238106Sdes return; 2448238106Sdes log_crypto_err("could not SSL_read"); 2449238106Sdes return; 2450238106Sdes } 2451238106Sdes magic[6] = 0; 2452238106Sdes if( r != 6 || strncmp(magic, "UBCT", 4) != 0) { 2453238106Sdes verbose(VERB_QUERY, "control connection has bad magic string"); 2454238106Sdes /* probably wrong tool connected, ignore it completely */ 2455238106Sdes return; 2456238106Sdes } 2457238106Sdes 2458238106Sdes /* read the command line */ 2459238106Sdes if(!ssl_read_line(ssl, buf, sizeof(buf))) { 2460238106Sdes return; 2461238106Sdes } 2462238106Sdes snprintf(pre, sizeof(pre), "UBCT%d ", UNBOUND_CONTROL_VERSION); 2463238106Sdes if(strcmp(magic, pre) != 0) { 2464238106Sdes verbose(VERB_QUERY, "control connection had bad " 2465238106Sdes "version %s, cmd: %s", magic, buf); 2466238106Sdes ssl_printf(ssl, "error version mismatch\n"); 2467238106Sdes return; 2468238106Sdes } 2469238106Sdes verbose(VERB_DETAIL, "control cmd: %s", buf); 2470238106Sdes 2471238106Sdes /* figure out what to do */ 2472238106Sdes execute_cmd(rc, ssl, buf, rc->worker); 2473238106Sdes} 2474238106Sdes 2475238106Sdesint remote_control_callback(struct comm_point* c, void* arg, int err, 2476238106Sdes struct comm_reply* ATTR_UNUSED(rep)) 2477238106Sdes{ 2478238106Sdes struct rc_state* s = (struct rc_state*)arg; 2479238106Sdes struct daemon_remote* rc = s->rc; 2480238106Sdes int r; 2481238106Sdes if(err != NETEVENT_NOERROR) { 2482238106Sdes if(err==NETEVENT_TIMEOUT) 2483238106Sdes log_err("remote control timed out"); 2484238106Sdes clean_point(rc, s); 2485238106Sdes return 0; 2486238106Sdes } 2487238106Sdes /* (continue to) setup the SSL connection */ 2488238106Sdes ERR_clear_error(); 2489238106Sdes r = SSL_do_handshake(s->ssl); 2490238106Sdes if(r != 1) { 2491238106Sdes int r2 = SSL_get_error(s->ssl, r); 2492238106Sdes if(r2 == SSL_ERROR_WANT_READ) { 2493238106Sdes if(s->shake_state == rc_hs_read) { 2494238106Sdes /* try again later */ 2495238106Sdes return 0; 2496238106Sdes } 2497238106Sdes s->shake_state = rc_hs_read; 2498238106Sdes comm_point_listen_for_rw(c, 1, 0); 2499238106Sdes return 0; 2500238106Sdes } else if(r2 == SSL_ERROR_WANT_WRITE) { 2501238106Sdes if(s->shake_state == rc_hs_write) { 2502238106Sdes /* try again later */ 2503238106Sdes return 0; 2504238106Sdes } 2505238106Sdes s->shake_state = rc_hs_write; 2506238106Sdes comm_point_listen_for_rw(c, 0, 1); 2507238106Sdes return 0; 2508238106Sdes } else { 2509238106Sdes if(r == 0) 2510238106Sdes log_err("remote control connection closed prematurely"); 2511238106Sdes log_addr(1, "failed connection from", 2512238106Sdes &s->c->repinfo.addr, s->c->repinfo.addrlen); 2513238106Sdes log_crypto_err("remote control failed ssl"); 2514238106Sdes clean_point(rc, s); 2515238106Sdes return 0; 2516238106Sdes } 2517238106Sdes } 2518238106Sdes s->shake_state = rc_none; 2519238106Sdes 2520238106Sdes /* once handshake has completed, check authentication */ 2521285206Sdes if (!rc->use_cert) { 2522285206Sdes verbose(VERB_ALGO, "unauthenticated remote control connection"); 2523285206Sdes } else if(SSL_get_verify_result(s->ssl) == X509_V_OK) { 2524238106Sdes X509* x = SSL_get_peer_certificate(s->ssl); 2525238106Sdes if(!x) { 2526238106Sdes verbose(VERB_DETAIL, "remote control connection " 2527238106Sdes "provided no client certificate"); 2528238106Sdes clean_point(rc, s); 2529238106Sdes return 0; 2530238106Sdes } 2531238106Sdes verbose(VERB_ALGO, "remote control connection authenticated"); 2532238106Sdes X509_free(x); 2533238106Sdes } else { 2534238106Sdes verbose(VERB_DETAIL, "remote control connection failed to " 2535238106Sdes "authenticate with client certificate"); 2536238106Sdes clean_point(rc, s); 2537238106Sdes return 0; 2538238106Sdes } 2539238106Sdes 2540238106Sdes /* if OK start to actually handle the request */ 2541238106Sdes handle_req(rc, s, s->ssl); 2542238106Sdes 2543238106Sdes verbose(VERB_ALGO, "remote control operation completed"); 2544238106Sdes clean_point(rc, s); 2545238106Sdes return 0; 2546238106Sdes} 2547