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" 81291767Sdes#include "sldns/str2wire.h" 82291767Sdes#include "sldns/parseutil.h" 83291767Sdes#include "sldns/wire2str.h" 84291767Sdes#include "sldns/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 143291767Sdes * the command : "openssl dhparam -dsaparam -C 1024" 144291767Sdes * (some openssl versions reject DH that is 'too small', eg. 512). 145285206Sdes */ 146285206Sdes#ifndef S_SPLINT_S 147291767SdesDH *get_dh1024() 148285206Sdes{ 149291767Sdes static unsigned char dh1024_p[]={ 150291767Sdes 0xB3,0x67,0x2E,0x3B,0x68,0xC5,0xDA,0x58,0x46,0xD6,0x2B,0xD3, 151291767Sdes 0x41,0x78,0x97,0xE4,0xE1,0x61,0x71,0x68,0xE6,0x0F,0x1D,0x78, 152291767Sdes 0x05,0xAA,0xF0,0xFF,0x30,0xDF,0xAC,0x49,0x7F,0xE0,0x90,0xFE, 153291767Sdes 0xB9,0x56,0x4E,0x3F,0xE2,0x98,0x8A,0xED,0xF5,0x28,0x39,0xEF, 154291767Sdes 0x2E,0xA6,0xB7,0x67,0xB2,0x43,0xE4,0x53,0xF8,0xEB,0x2C,0x1F, 155291767Sdes 0x06,0x77,0x3A,0x6F,0x62,0x98,0xC1,0x3B,0xF7,0xBA,0x4D,0x93, 156291767Sdes 0xF7,0xEB,0x5A,0xAD,0xC5,0x5F,0xF0,0xB7,0x24,0x35,0x81,0xF7, 157291767Sdes 0x7F,0x1F,0x24,0xC0,0xDF,0xD3,0xD8,0x40,0x72,0x7E,0xF3,0x19, 158291767Sdes 0x2B,0x26,0x27,0xF4,0xB6,0xB3,0xD4,0x7D,0x08,0x23,0xBE,0x68, 159291767Sdes 0x2B,0xCA,0xB4,0x46,0xA8,0x9E,0xDD,0x6C,0x3D,0x75,0xA6,0x48, 160291767Sdes 0xF7,0x44,0x43,0xBF,0x91,0xC2,0xB4,0x49, 161291767Sdes }; 162291767Sdes static unsigned char dh1024_g[]={ 163291767Sdes 0x5F,0x37,0xB5,0x80,0x4D,0xB4,0xC4,0xB2,0x37,0x12,0xD5,0x2F, 164291767Sdes 0x56,0x81,0xB0,0xDF,0x3D,0x27,0xA2,0x54,0xE7,0x14,0x65,0x2D, 165291767Sdes 0x72,0xA8,0x97,0xE0,0xA9,0x4A,0x09,0x5E,0x89,0xBE,0x34,0x9A, 166291767Sdes 0x90,0x98,0xC1,0xE8,0xBB,0x01,0x2B,0xC2,0x74,0x74,0x90,0x59, 167291767Sdes 0x0B,0x72,0x62,0x5C,0xFD,0x49,0x63,0x4B,0x38,0x91,0xF1,0x7F, 168291767Sdes 0x13,0x25,0xEB,0x52,0x50,0x47,0xA2,0x8C,0x32,0x28,0x42,0xAC, 169291767Sdes 0xBD,0x7A,0xCC,0x58,0xBE,0x36,0xDA,0x6A,0x24,0x06,0xC7,0xF1, 170291767Sdes 0xDA,0x8D,0x8A,0x3B,0x03,0xFA,0x6F,0x25,0xE5,0x20,0xA7,0xD6, 171291767Sdes 0x6F,0x74,0x61,0x53,0x14,0x81,0x29,0x04,0xB5,0x61,0x12,0x53, 172291767Sdes 0xA3,0xD6,0x09,0x98,0x0C,0x8F,0x1C,0xBB,0xD7,0x1C,0x2C,0xEE, 173291767Sdes 0x56,0x4B,0x74,0x8F,0x4A,0xF8,0xA9,0xD5, 174291767Sdes }; 175285206Sdes DH *dh; 176285206Sdes 177285206Sdes if ((dh=DH_new()) == NULL) return(NULL); 178291767Sdes dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL); 179291767Sdes dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL); 180285206Sdes if ((dh->p == NULL) || (dh->g == NULL)) 181291767Sdes { DH_free(dh); return(NULL); } 182285206Sdes dh->length = 160; 183285206Sdes return(dh); 184285206Sdes} 185285206Sdes#endif /* SPLINT */ 186285206Sdes 187238106Sdesstruct daemon_remote* 188238106Sdesdaemon_remote_create(struct config_file* cfg) 189238106Sdes{ 190238106Sdes char* s_cert; 191238106Sdes char* s_key; 192238106Sdes struct daemon_remote* rc = (struct daemon_remote*)calloc(1, 193238106Sdes sizeof(*rc)); 194238106Sdes if(!rc) { 195238106Sdes log_err("out of memory in daemon_remote_create"); 196238106Sdes return NULL; 197238106Sdes } 198238106Sdes rc->max_active = 10; 199238106Sdes 200238106Sdes if(!cfg->remote_control_enable) { 201238106Sdes rc->ctx = NULL; 202238106Sdes return rc; 203238106Sdes } 204238106Sdes rc->ctx = SSL_CTX_new(SSLv23_server_method()); 205238106Sdes if(!rc->ctx) { 206238106Sdes log_crypto_err("could not SSL_CTX_new"); 207238106Sdes free(rc); 208238106Sdes return NULL; 209238106Sdes } 210285206Sdes /* no SSLv2, SSLv3 because has defects */ 211294190Sdes if((SSL_CTX_set_options(rc->ctx, SSL_OP_NO_SSLv2) & SSL_OP_NO_SSLv2) 212294190Sdes != SSL_OP_NO_SSLv2){ 213238106Sdes log_crypto_err("could not set SSL_OP_NO_SSLv2"); 214238106Sdes daemon_remote_delete(rc); 215238106Sdes return NULL; 216238106Sdes } 217294190Sdes if((SSL_CTX_set_options(rc->ctx, SSL_OP_NO_SSLv3) & SSL_OP_NO_SSLv3) 218294190Sdes != SSL_OP_NO_SSLv3){ 219285206Sdes log_crypto_err("could not set SSL_OP_NO_SSLv3"); 220285206Sdes daemon_remote_delete(rc); 221285206Sdes return NULL; 222285206Sdes } 223285206Sdes 224285206Sdes if (cfg->remote_control_use_cert == 0) { 225285206Sdes /* No certificates are requested */ 226285206Sdes if(!SSL_CTX_set_cipher_list(rc->ctx, "aNULL")) { 227285206Sdes log_crypto_err("Failed to set aNULL cipher list"); 228285206Sdes return NULL; 229285206Sdes } 230285206Sdes 231285206Sdes /* Since we have no certificates and hence no source of 232285206Sdes * DH params, let's generate and set them 233285206Sdes */ 234291767Sdes if(!SSL_CTX_set_tmp_dh(rc->ctx,get_dh1024())) { 235285206Sdes log_crypto_err("Wanted to set DH param, but failed"); 236285206Sdes return NULL; 237285206Sdes } 238285206Sdes return rc; 239285206Sdes } 240285206Sdes rc->use_cert = 1; 241238106Sdes s_cert = fname_after_chroot(cfg->server_cert_file, cfg, 1); 242238106Sdes s_key = fname_after_chroot(cfg->server_key_file, cfg, 1); 243238106Sdes if(!s_cert || !s_key) { 244238106Sdes log_err("out of memory in remote control fname"); 245238106Sdes goto setup_error; 246238106Sdes } 247238106Sdes verbose(VERB_ALGO, "setup SSL certificates"); 248291767Sdes if (!SSL_CTX_use_certificate_chain_file(rc->ctx,s_cert)) { 249238106Sdes log_err("Error for server-cert-file: %s", s_cert); 250291767Sdes log_crypto_err("Error in SSL_CTX use_certificate_chain_file"); 251238106Sdes goto setup_error; 252238106Sdes } 253238106Sdes if(!SSL_CTX_use_PrivateKey_file(rc->ctx,s_key,SSL_FILETYPE_PEM)) { 254238106Sdes log_err("Error for server-key-file: %s", s_key); 255238106Sdes log_crypto_err("Error in SSL_CTX use_PrivateKey_file"); 256238106Sdes goto setup_error; 257238106Sdes } 258238106Sdes if(!SSL_CTX_check_private_key(rc->ctx)) { 259238106Sdes log_err("Error for server-key-file: %s", s_key); 260238106Sdes log_crypto_err("Error in SSL_CTX check_private_key"); 261238106Sdes goto setup_error; 262238106Sdes } 263291767Sdes#if HAVE_DECL_SSL_CTX_SET_ECDH_AUTO 264291767Sdes if(!SSL_CTX_set_ecdh_auto(rc->ctx,1)) { 265291767Sdes log_crypto_err("Error in SSL_CTX_ecdh_auto, not enabling ECDHE"); 266291767Sdes } 267291767Sdes#elif defined(USE_ECDSA) 268291767Sdes if(1) { 269291767Sdes EC_KEY *ecdh = EC_KEY_new_by_curve_name (NID_X9_62_prime256v1); 270291767Sdes if (!ecdh) { 271291767Sdes log_crypto_err("could not find p256, not enabling ECDHE"); 272291767Sdes } else { 273291767Sdes if (1 != SSL_CTX_set_tmp_ecdh (rc->ctx, ecdh)) { 274291767Sdes log_crypto_err("Error in SSL_CTX_set_tmp_ecdh, not enabling ECDHE"); 275291767Sdes } 276291767Sdes EC_KEY_free (ecdh); 277291767Sdes } 278291767Sdes } 279291767Sdes#endif 280238106Sdes if(!SSL_CTX_load_verify_locations(rc->ctx, s_cert, NULL)) { 281238106Sdes log_crypto_err("Error setting up SSL_CTX verify locations"); 282238106Sdes setup_error: 283238106Sdes free(s_cert); 284238106Sdes free(s_key); 285238106Sdes daemon_remote_delete(rc); 286238106Sdes return NULL; 287238106Sdes } 288238106Sdes SSL_CTX_set_client_CA_list(rc->ctx, SSL_load_client_CA_file(s_cert)); 289238106Sdes SSL_CTX_set_verify(rc->ctx, SSL_VERIFY_PEER, NULL); 290238106Sdes free(s_cert); 291238106Sdes free(s_key); 292238106Sdes 293238106Sdes return rc; 294238106Sdes} 295238106Sdes 296238106Sdesvoid daemon_remote_clear(struct daemon_remote* rc) 297238106Sdes{ 298238106Sdes struct rc_state* p, *np; 299238106Sdes if(!rc) return; 300238106Sdes /* but do not close the ports */ 301238106Sdes listen_list_delete(rc->accept_list); 302238106Sdes rc->accept_list = NULL; 303238106Sdes /* do close these sockets */ 304238106Sdes p = rc->busy_list; 305238106Sdes while(p) { 306238106Sdes np = p->next; 307238106Sdes if(p->ssl) 308238106Sdes SSL_free(p->ssl); 309238106Sdes comm_point_delete(p->c); 310238106Sdes free(p); 311238106Sdes p = np; 312238106Sdes } 313238106Sdes rc->busy_list = NULL; 314238106Sdes rc->active = 0; 315238106Sdes rc->worker = NULL; 316238106Sdes} 317238106Sdes 318238106Sdesvoid daemon_remote_delete(struct daemon_remote* rc) 319238106Sdes{ 320238106Sdes if(!rc) return; 321238106Sdes daemon_remote_clear(rc); 322238106Sdes if(rc->ctx) { 323238106Sdes SSL_CTX_free(rc->ctx); 324238106Sdes } 325238106Sdes free(rc); 326238106Sdes} 327238106Sdes 328238106Sdes/** 329238106Sdes * Add and open a new control port 330238106Sdes * @param ip: ip str 331238106Sdes * @param nr: port nr 332238106Sdes * @param list: list head 333238106Sdes * @param noproto_is_err: if lack of protocol support is an error. 334285206Sdes * @param cfg: config with username for chown of unix-sockets. 335238106Sdes * @return false on failure. 336238106Sdes */ 337238106Sdesstatic int 338285206Sdesadd_open(const char* ip, int nr, struct listen_port** list, int noproto_is_err, 339285206Sdes struct config_file* cfg) 340238106Sdes{ 341238106Sdes struct addrinfo hints; 342238106Sdes struct addrinfo* res; 343238106Sdes struct listen_port* n; 344238106Sdes int noproto; 345238106Sdes int fd, r; 346238106Sdes char port[15]; 347238106Sdes snprintf(port, sizeof(port), "%d", nr); 348238106Sdes port[sizeof(port)-1]=0; 349238106Sdes memset(&hints, 0, sizeof(hints)); 350285206Sdes 351285206Sdes if(ip[0] == '/') { 352285206Sdes /* This looks like a local socket */ 353285206Sdes fd = create_local_accept_sock(ip, &noproto); 354285206Sdes /* 355285206Sdes * Change socket ownership and permissions so users other 356285206Sdes * than root can access it provided they are in the same 357285206Sdes * group as the user we run as. 358285206Sdes */ 359285206Sdes if(fd != -1) { 360285206Sdes#ifdef HAVE_CHOWN 361285206Sdes if (cfg->username && cfg->username[0] && 362285206Sdes cfg_uid != (uid_t)-1) 363285206Sdes chown(ip, cfg_uid, cfg_gid); 364285206Sdes chmod(ip, (mode_t)(S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP)); 365285206Sdes#else 366285206Sdes (void)cfg; 367285206Sdes#endif 368285206Sdes } 369285206Sdes } else { 370285206Sdes hints.ai_socktype = SOCK_STREAM; 371285206Sdes hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST; 372285206Sdes if((r = getaddrinfo(ip, port, &hints, &res)) != 0 || !res) { 373238106Sdes#ifdef USE_WINSOCK 374285206Sdes if(!noproto_is_err && r == EAI_NONAME) { 375285206Sdes /* tried to lookup the address as name */ 376285206Sdes return 1; /* return success, but do nothing */ 377285206Sdes } 378238106Sdes#endif /* USE_WINSOCK */ 379285206Sdes log_err("control interface %s:%s getaddrinfo: %s %s", 380285206Sdes ip?ip:"default", port, gai_strerror(r), 381238106Sdes#ifdef EAI_SYSTEM 382285206Sdes r==EAI_SYSTEM?(char*)strerror(errno):"" 383238106Sdes#else 384285206Sdes "" 385238106Sdes#endif 386238106Sdes ); 387285206Sdes return 0; 388285206Sdes } 389285206Sdes 390285206Sdes /* open fd */ 391291767Sdes fd = create_tcp_accept_sock(res, 1, &noproto, 0, 392291767Sdes cfg->ip_transparent); 393285206Sdes freeaddrinfo(res); 394238106Sdes } 395238106Sdes 396238106Sdes if(fd == -1 && noproto) { 397238106Sdes if(!noproto_is_err) 398238106Sdes return 1; /* return success, but do nothing */ 399238106Sdes log_err("cannot open control interface %s %d : " 400238106Sdes "protocol not supported", ip, nr); 401238106Sdes return 0; 402238106Sdes } 403238106Sdes if(fd == -1) { 404238106Sdes log_err("cannot open control interface %s %d", ip, nr); 405238106Sdes return 0; 406238106Sdes } 407238106Sdes 408238106Sdes /* alloc */ 409238106Sdes n = (struct listen_port*)calloc(1, sizeof(*n)); 410238106Sdes if(!n) { 411238106Sdes#ifndef USE_WINSOCK 412238106Sdes close(fd); 413238106Sdes#else 414238106Sdes closesocket(fd); 415238106Sdes#endif 416238106Sdes log_err("out of memory"); 417238106Sdes return 0; 418238106Sdes } 419238106Sdes n->next = *list; 420238106Sdes *list = n; 421238106Sdes n->fd = fd; 422238106Sdes return 1; 423238106Sdes} 424238106Sdes 425238106Sdesstruct listen_port* daemon_remote_open_ports(struct config_file* cfg) 426238106Sdes{ 427238106Sdes struct listen_port* l = NULL; 428238106Sdes log_assert(cfg->remote_control_enable && cfg->control_port); 429238106Sdes if(cfg->control_ifs) { 430238106Sdes struct config_strlist* p; 431238106Sdes for(p = cfg->control_ifs; p; p = p->next) { 432285206Sdes if(!add_open(p->str, cfg->control_port, &l, 1, cfg)) { 433238106Sdes listening_ports_free(l); 434238106Sdes return NULL; 435238106Sdes } 436238106Sdes } 437238106Sdes } else { 438238106Sdes /* defaults */ 439238106Sdes if(cfg->do_ip6 && 440285206Sdes !add_open("::1", cfg->control_port, &l, 0, cfg)) { 441238106Sdes listening_ports_free(l); 442238106Sdes return NULL; 443238106Sdes } 444238106Sdes if(cfg->do_ip4 && 445285206Sdes !add_open("127.0.0.1", cfg->control_port, &l, 1, cfg)) { 446238106Sdes listening_ports_free(l); 447238106Sdes return NULL; 448238106Sdes } 449238106Sdes } 450238106Sdes return l; 451238106Sdes} 452238106Sdes 453238106Sdes/** open accept commpoint */ 454238106Sdesstatic int 455238106Sdesaccept_open(struct daemon_remote* rc, int fd) 456238106Sdes{ 457238106Sdes struct listen_list* n = (struct listen_list*)malloc(sizeof(*n)); 458238106Sdes if(!n) { 459238106Sdes log_err("out of memory"); 460238106Sdes return 0; 461238106Sdes } 462238106Sdes n->next = rc->accept_list; 463238106Sdes rc->accept_list = n; 464238106Sdes /* open commpt */ 465238106Sdes n->com = comm_point_create_raw(rc->worker->base, fd, 0, 466238106Sdes &remote_accept_callback, rc); 467238106Sdes if(!n->com) 468238106Sdes return 0; 469238106Sdes /* keep this port open, its fd is kept in the rc portlist */ 470238106Sdes n->com->do_not_close = 1; 471238106Sdes return 1; 472238106Sdes} 473238106Sdes 474238106Sdesint daemon_remote_open_accept(struct daemon_remote* rc, 475238106Sdes struct listen_port* ports, struct worker* worker) 476238106Sdes{ 477238106Sdes struct listen_port* p; 478238106Sdes rc->worker = worker; 479238106Sdes for(p = ports; p; p = p->next) { 480238106Sdes if(!accept_open(rc, p->fd)) { 481238106Sdes log_err("could not create accept comm point"); 482238106Sdes return 0; 483238106Sdes } 484238106Sdes } 485238106Sdes return 1; 486238106Sdes} 487238106Sdes 488238106Sdesvoid daemon_remote_stop_accept(struct daemon_remote* rc) 489238106Sdes{ 490238106Sdes struct listen_list* p; 491238106Sdes for(p=rc->accept_list; p; p=p->next) { 492238106Sdes comm_point_stop_listening(p->com); 493238106Sdes } 494238106Sdes} 495238106Sdes 496238106Sdesvoid daemon_remote_start_accept(struct daemon_remote* rc) 497238106Sdes{ 498238106Sdes struct listen_list* p; 499238106Sdes for(p=rc->accept_list; p; p=p->next) { 500238106Sdes comm_point_start_listening(p->com, -1, -1); 501238106Sdes } 502238106Sdes} 503238106Sdes 504238106Sdesint remote_accept_callback(struct comm_point* c, void* arg, int err, 505238106Sdes struct comm_reply* ATTR_UNUSED(rep)) 506238106Sdes{ 507238106Sdes struct daemon_remote* rc = (struct daemon_remote*)arg; 508238106Sdes struct sockaddr_storage addr; 509238106Sdes socklen_t addrlen; 510238106Sdes int newfd; 511238106Sdes struct rc_state* n; 512238106Sdes if(err != NETEVENT_NOERROR) { 513238106Sdes log_err("error %d on remote_accept_callback", err); 514238106Sdes return 0; 515238106Sdes } 516238106Sdes /* perform the accept */ 517238106Sdes newfd = comm_point_perform_accept(c, &addr, &addrlen); 518238106Sdes if(newfd == -1) 519238106Sdes return 0; 520238106Sdes /* create new commpoint unless we are servicing already */ 521238106Sdes if(rc->active >= rc->max_active) { 522238106Sdes log_warn("drop incoming remote control: too many connections"); 523238106Sdes close_exit: 524238106Sdes#ifndef USE_WINSOCK 525238106Sdes close(newfd); 526238106Sdes#else 527238106Sdes closesocket(newfd); 528238106Sdes#endif 529238106Sdes return 0; 530238106Sdes } 531238106Sdes 532238106Sdes /* setup commpoint to service the remote control command */ 533238106Sdes n = (struct rc_state*)calloc(1, sizeof(*n)); 534238106Sdes if(!n) { 535238106Sdes log_err("out of memory"); 536238106Sdes goto close_exit; 537238106Sdes } 538238106Sdes /* start in reading state */ 539238106Sdes n->c = comm_point_create_raw(rc->worker->base, newfd, 0, 540238106Sdes &remote_control_callback, n); 541238106Sdes if(!n->c) { 542238106Sdes log_err("out of memory"); 543238106Sdes free(n); 544238106Sdes goto close_exit; 545238106Sdes } 546238106Sdes log_addr(VERB_QUERY, "new control connection from", &addr, addrlen); 547238106Sdes n->c->do_not_close = 0; 548238106Sdes comm_point_stop_listening(n->c); 549238106Sdes comm_point_start_listening(n->c, -1, REMOTE_CONTROL_TCP_TIMEOUT); 550238106Sdes memcpy(&n->c->repinfo.addr, &addr, addrlen); 551238106Sdes n->c->repinfo.addrlen = addrlen; 552238106Sdes n->shake_state = rc_hs_read; 553238106Sdes n->ssl = SSL_new(rc->ctx); 554238106Sdes if(!n->ssl) { 555238106Sdes log_crypto_err("could not SSL_new"); 556238106Sdes comm_point_delete(n->c); 557238106Sdes free(n); 558238106Sdes goto close_exit; 559238106Sdes } 560238106Sdes SSL_set_accept_state(n->ssl); 561238106Sdes (void)SSL_set_mode(n->ssl, SSL_MODE_AUTO_RETRY); 562238106Sdes if(!SSL_set_fd(n->ssl, newfd)) { 563238106Sdes log_crypto_err("could not SSL_set_fd"); 564238106Sdes SSL_free(n->ssl); 565238106Sdes comm_point_delete(n->c); 566238106Sdes free(n); 567238106Sdes goto close_exit; 568238106Sdes } 569238106Sdes 570238106Sdes n->rc = rc; 571238106Sdes n->next = rc->busy_list; 572238106Sdes rc->busy_list = n; 573238106Sdes rc->active ++; 574238106Sdes 575238106Sdes /* perform the first nonblocking read already, for windows, 576238106Sdes * so it can return wouldblock. could be faster too. */ 577238106Sdes (void)remote_control_callback(n->c, n, NETEVENT_NOERROR, NULL); 578238106Sdes return 0; 579238106Sdes} 580238106Sdes 581238106Sdes/** delete from list */ 582238106Sdesstatic void 583238106Sdesstate_list_remove_elem(struct rc_state** list, struct comm_point* c) 584238106Sdes{ 585238106Sdes while(*list) { 586238106Sdes if( (*list)->c == c) { 587238106Sdes *list = (*list)->next; 588238106Sdes return; 589238106Sdes } 590238106Sdes list = &(*list)->next; 591238106Sdes } 592238106Sdes} 593238106Sdes 594238106Sdes/** decrease active count and remove commpoint from busy list */ 595238106Sdesstatic void 596238106Sdesclean_point(struct daemon_remote* rc, struct rc_state* s) 597238106Sdes{ 598238106Sdes state_list_remove_elem(&rc->busy_list, s->c); 599238106Sdes rc->active --; 600238106Sdes if(s->ssl) { 601238106Sdes SSL_shutdown(s->ssl); 602238106Sdes SSL_free(s->ssl); 603238106Sdes } 604238106Sdes comm_point_delete(s->c); 605238106Sdes free(s); 606238106Sdes} 607238106Sdes 608238106Sdesint 609238106Sdesssl_print_text(SSL* ssl, const char* text) 610238106Sdes{ 611238106Sdes int r; 612238106Sdes if(!ssl) 613238106Sdes return 0; 614238106Sdes ERR_clear_error(); 615238106Sdes if((r=SSL_write(ssl, text, (int)strlen(text))) <= 0) { 616238106Sdes if(SSL_get_error(ssl, r) == SSL_ERROR_ZERO_RETURN) { 617238106Sdes verbose(VERB_QUERY, "warning, in SSL_write, peer " 618238106Sdes "closed connection"); 619238106Sdes return 0; 620238106Sdes } 621238106Sdes log_crypto_err("could not SSL_write"); 622238106Sdes return 0; 623238106Sdes } 624238106Sdes return 1; 625238106Sdes} 626238106Sdes 627238106Sdes/** print text over the ssl connection */ 628238106Sdesstatic int 629238106Sdesssl_print_vmsg(SSL* ssl, const char* format, va_list args) 630238106Sdes{ 631238106Sdes char msg[1024]; 632238106Sdes vsnprintf(msg, sizeof(msg), format, args); 633238106Sdes return ssl_print_text(ssl, msg); 634238106Sdes} 635238106Sdes 636238106Sdes/** printf style printing to the ssl connection */ 637238106Sdesint ssl_printf(SSL* ssl, const char* format, ...) 638238106Sdes{ 639238106Sdes va_list args; 640238106Sdes int ret; 641238106Sdes va_start(args, format); 642238106Sdes ret = ssl_print_vmsg(ssl, format, args); 643238106Sdes va_end(args); 644238106Sdes return ret; 645238106Sdes} 646238106Sdes 647238106Sdesint 648238106Sdesssl_read_line(SSL* ssl, char* buf, size_t max) 649238106Sdes{ 650238106Sdes int r; 651238106Sdes size_t len = 0; 652238106Sdes if(!ssl) 653238106Sdes return 0; 654238106Sdes while(len < max) { 655238106Sdes ERR_clear_error(); 656238106Sdes if((r=SSL_read(ssl, buf+len, 1)) <= 0) { 657238106Sdes if(SSL_get_error(ssl, r) == SSL_ERROR_ZERO_RETURN) { 658238106Sdes buf[len] = 0; 659238106Sdes return 1; 660238106Sdes } 661238106Sdes log_crypto_err("could not SSL_read"); 662238106Sdes return 0; 663238106Sdes } 664238106Sdes if(buf[len] == '\n') { 665238106Sdes /* return string without \n */ 666238106Sdes buf[len] = 0; 667238106Sdes return 1; 668238106Sdes } 669238106Sdes len++; 670238106Sdes } 671238106Sdes buf[max-1] = 0; 672238106Sdes log_err("control line too long (%d): %s", (int)max, buf); 673238106Sdes return 0; 674238106Sdes} 675238106Sdes 676238106Sdes/** skip whitespace, return new pointer into string */ 677238106Sdesstatic char* 678238106Sdesskipwhite(char* str) 679238106Sdes{ 680238106Sdes /* EOS \0 is not a space */ 681285206Sdes while( isspace((unsigned char)*str) ) 682238106Sdes str++; 683238106Sdes return str; 684238106Sdes} 685238106Sdes 686238106Sdes/** send the OK to the control client */ 687238106Sdesstatic void send_ok(SSL* ssl) 688238106Sdes{ 689238106Sdes (void)ssl_printf(ssl, "ok\n"); 690238106Sdes} 691238106Sdes 692238106Sdes/** do the stop command */ 693238106Sdesstatic void 694238106Sdesdo_stop(SSL* ssl, struct daemon_remote* rc) 695238106Sdes{ 696238106Sdes rc->worker->need_to_exit = 1; 697238106Sdes comm_base_exit(rc->worker->base); 698238106Sdes send_ok(ssl); 699238106Sdes} 700238106Sdes 701238106Sdes/** do the reload command */ 702238106Sdesstatic void 703238106Sdesdo_reload(SSL* ssl, struct daemon_remote* rc) 704238106Sdes{ 705238106Sdes rc->worker->need_to_exit = 0; 706238106Sdes comm_base_exit(rc->worker->base); 707238106Sdes send_ok(ssl); 708238106Sdes} 709238106Sdes 710238106Sdes/** do the verbosity command */ 711238106Sdesstatic void 712238106Sdesdo_verbosity(SSL* ssl, char* str) 713238106Sdes{ 714238106Sdes int val = atoi(str); 715238106Sdes if(val == 0 && strcmp(str, "0") != 0) { 716238106Sdes ssl_printf(ssl, "error in verbosity number syntax: %s\n", str); 717238106Sdes return; 718238106Sdes } 719238106Sdes verbosity = val; 720238106Sdes send_ok(ssl); 721238106Sdes} 722238106Sdes 723238106Sdes/** print stats from statinfo */ 724238106Sdesstatic int 725238106Sdesprint_stats(SSL* ssl, const char* nm, struct stats_info* s) 726238106Sdes{ 727238106Sdes struct timeval avg; 728285206Sdes if(!ssl_printf(ssl, "%s.num.queries"SQ"%lu\n", nm, 729285206Sdes (unsigned long)s->svr.num_queries)) return 0; 730285206Sdes if(!ssl_printf(ssl, "%s.num.cachehits"SQ"%lu\n", nm, 731285206Sdes (unsigned long)(s->svr.num_queries 732238106Sdes - s->svr.num_queries_missed_cache))) return 0; 733285206Sdes if(!ssl_printf(ssl, "%s.num.cachemiss"SQ"%lu\n", nm, 734285206Sdes (unsigned long)s->svr.num_queries_missed_cache)) return 0; 735285206Sdes if(!ssl_printf(ssl, "%s.num.prefetch"SQ"%lu\n", nm, 736285206Sdes (unsigned long)s->svr.num_queries_prefetch)) return 0; 737285206Sdes if(!ssl_printf(ssl, "%s.num.recursivereplies"SQ"%lu\n", nm, 738285206Sdes (unsigned long)s->mesh_replies_sent)) return 0; 739238106Sdes if(!ssl_printf(ssl, "%s.requestlist.avg"SQ"%g\n", nm, 740238106Sdes (s->svr.num_queries_missed_cache+s->svr.num_queries_prefetch)? 741238106Sdes (double)s->svr.sum_query_list_size/ 742238106Sdes (s->svr.num_queries_missed_cache+ 743238106Sdes s->svr.num_queries_prefetch) : 0.0)) return 0; 744285206Sdes if(!ssl_printf(ssl, "%s.requestlist.max"SQ"%lu\n", nm, 745285206Sdes (unsigned long)s->svr.max_query_list_size)) return 0; 746285206Sdes if(!ssl_printf(ssl, "%s.requestlist.overwritten"SQ"%lu\n", nm, 747285206Sdes (unsigned long)s->mesh_jostled)) return 0; 748285206Sdes if(!ssl_printf(ssl, "%s.requestlist.exceeded"SQ"%lu\n", nm, 749285206Sdes (unsigned long)s->mesh_dropped)) return 0; 750285206Sdes if(!ssl_printf(ssl, "%s.requestlist.current.all"SQ"%lu\n", nm, 751285206Sdes (unsigned long)s->mesh_num_states)) return 0; 752285206Sdes if(!ssl_printf(ssl, "%s.requestlist.current.user"SQ"%lu\n", nm, 753285206Sdes (unsigned long)s->mesh_num_reply_states)) return 0; 754238106Sdes timeval_divide(&avg, &s->mesh_replies_sum_wait, s->mesh_replies_sent); 755269257Sdes if(!ssl_printf(ssl, "%s.recursion.time.avg"SQ ARG_LL "d.%6.6d\n", nm, 756269257Sdes (long long)avg.tv_sec, (int)avg.tv_usec)) return 0; 757238106Sdes if(!ssl_printf(ssl, "%s.recursion.time.median"SQ"%g\n", nm, 758238106Sdes s->mesh_time_median)) return 0; 759291767Sdes if(!ssl_printf(ssl, "%s.tcpusage"SQ"%lu\n", nm, 760291767Sdes (unsigned long)s->svr.tcp_accept_usage)) return 0; 761238106Sdes return 1; 762238106Sdes} 763238106Sdes 764238106Sdes/** print stats for one thread */ 765238106Sdesstatic int 766238106Sdesprint_thread_stats(SSL* ssl, int i, struct stats_info* s) 767238106Sdes{ 768238106Sdes char nm[16]; 769238106Sdes snprintf(nm, sizeof(nm), "thread%d", i); 770238106Sdes nm[sizeof(nm)-1]=0; 771238106Sdes return print_stats(ssl, nm, s); 772238106Sdes} 773238106Sdes 774238106Sdes/** print long number */ 775238106Sdesstatic int 776255579Sdesprint_longnum(SSL* ssl, const char* desc, size_t x) 777238106Sdes{ 778238106Sdes if(x > 1024*1024*1024) { 779238106Sdes /* more than a Gb */ 780238106Sdes size_t front = x / (size_t)1000000; 781238106Sdes size_t back = x % (size_t)1000000; 782238106Sdes return ssl_printf(ssl, "%s%u%6.6u\n", desc, 783238106Sdes (unsigned)front, (unsigned)back); 784238106Sdes } else { 785285206Sdes return ssl_printf(ssl, "%s%lu\n", desc, (unsigned long)x); 786238106Sdes } 787238106Sdes} 788238106Sdes 789238106Sdes/** print mem stats */ 790238106Sdesstatic int 791238106Sdesprint_mem(SSL* ssl, struct worker* worker, struct daemon* daemon) 792238106Sdes{ 793238106Sdes int m; 794238106Sdes size_t msg, rrset, val, iter; 795238106Sdes#ifdef HAVE_SBRK 796238106Sdes extern void* unbound_start_brk; 797238106Sdes void* cur = sbrk(0); 798238106Sdes if(!print_longnum(ssl, "mem.total.sbrk"SQ, 799238106Sdes (size_t)((char*)cur - (char*)unbound_start_brk))) return 0; 800238106Sdes#endif /* HAVE_SBRK */ 801238106Sdes msg = slabhash_get_mem(daemon->env->msg_cache); 802238106Sdes rrset = slabhash_get_mem(&daemon->env->rrset_cache->table); 803238106Sdes val=0; 804238106Sdes iter=0; 805238106Sdes m = modstack_find(&worker->env.mesh->mods, "validator"); 806238106Sdes if(m != -1) { 807238106Sdes fptr_ok(fptr_whitelist_mod_get_mem(worker->env.mesh-> 808238106Sdes mods.mod[m]->get_mem)); 809238106Sdes val = (*worker->env.mesh->mods.mod[m]->get_mem) 810238106Sdes (&worker->env, m); 811238106Sdes } 812238106Sdes m = modstack_find(&worker->env.mesh->mods, "iterator"); 813238106Sdes if(m != -1) { 814238106Sdes fptr_ok(fptr_whitelist_mod_get_mem(worker->env.mesh-> 815238106Sdes mods.mod[m]->get_mem)); 816238106Sdes iter = (*worker->env.mesh->mods.mod[m]->get_mem) 817238106Sdes (&worker->env, m); 818238106Sdes } 819238106Sdes 820238106Sdes if(!print_longnum(ssl, "mem.cache.rrset"SQ, rrset)) 821238106Sdes return 0; 822238106Sdes if(!print_longnum(ssl, "mem.cache.message"SQ, msg)) 823238106Sdes return 0; 824238106Sdes if(!print_longnum(ssl, "mem.mod.iterator"SQ, iter)) 825238106Sdes return 0; 826238106Sdes if(!print_longnum(ssl, "mem.mod.validator"SQ, val)) 827238106Sdes return 0; 828238106Sdes return 1; 829238106Sdes} 830238106Sdes 831238106Sdes/** print uptime stats */ 832238106Sdesstatic int 833238106Sdesprint_uptime(SSL* ssl, struct worker* worker, int reset) 834238106Sdes{ 835238106Sdes struct timeval now = *worker->env.now_tv; 836238106Sdes struct timeval up, dt; 837238106Sdes timeval_subtract(&up, &now, &worker->daemon->time_boot); 838238106Sdes timeval_subtract(&dt, &now, &worker->daemon->time_last_stat); 839238106Sdes if(reset) 840238106Sdes worker->daemon->time_last_stat = now; 841269257Sdes if(!ssl_printf(ssl, "time.now"SQ ARG_LL "d.%6.6d\n", 842269257Sdes (long long)now.tv_sec, (unsigned)now.tv_usec)) return 0; 843269257Sdes if(!ssl_printf(ssl, "time.up"SQ ARG_LL "d.%6.6d\n", 844269257Sdes (long long)up.tv_sec, (unsigned)up.tv_usec)) return 0; 845269257Sdes if(!ssl_printf(ssl, "time.elapsed"SQ ARG_LL "d.%6.6d\n", 846269257Sdes (long long)dt.tv_sec, (unsigned)dt.tv_usec)) return 0; 847238106Sdes return 1; 848238106Sdes} 849238106Sdes 850238106Sdes/** print extended histogram */ 851238106Sdesstatic int 852238106Sdesprint_hist(SSL* ssl, struct stats_info* s) 853238106Sdes{ 854238106Sdes struct timehist* hist; 855238106Sdes size_t i; 856238106Sdes hist = timehist_setup(); 857238106Sdes if(!hist) { 858238106Sdes log_err("out of memory"); 859238106Sdes return 0; 860238106Sdes } 861238106Sdes timehist_import(hist, s->svr.hist, NUM_BUCKETS_HIST); 862238106Sdes for(i=0; i<hist->num; i++) { 863238106Sdes if(!ssl_printf(ssl, 864285206Sdes "histogram.%6.6d.%6.6d.to.%6.6d.%6.6d=%lu\n", 865238106Sdes (int)hist->buckets[i].lower.tv_sec, 866238106Sdes (int)hist->buckets[i].lower.tv_usec, 867238106Sdes (int)hist->buckets[i].upper.tv_sec, 868238106Sdes (int)hist->buckets[i].upper.tv_usec, 869285206Sdes (unsigned long)hist->buckets[i].count)) { 870238106Sdes timehist_delete(hist); 871238106Sdes return 0; 872238106Sdes } 873238106Sdes } 874238106Sdes timehist_delete(hist); 875238106Sdes return 1; 876238106Sdes} 877238106Sdes 878238106Sdes/** print extended stats */ 879238106Sdesstatic int 880238106Sdesprint_ext(SSL* ssl, struct stats_info* s) 881238106Sdes{ 882238106Sdes int i; 883238106Sdes char nm[16]; 884269257Sdes const sldns_rr_descriptor* desc; 885269257Sdes const sldns_lookup_table* lt; 886238106Sdes /* TYPE */ 887238106Sdes for(i=0; i<STATS_QTYPE_NUM; i++) { 888238106Sdes if(inhibit_zero && s->svr.qtype[i] == 0) 889238106Sdes continue; 890269257Sdes desc = sldns_rr_descript((uint16_t)i); 891238106Sdes if(desc && desc->_name) { 892238106Sdes snprintf(nm, sizeof(nm), "%s", desc->_name); 893238106Sdes } else if (i == LDNS_RR_TYPE_IXFR) { 894238106Sdes snprintf(nm, sizeof(nm), "IXFR"); 895238106Sdes } else if (i == LDNS_RR_TYPE_AXFR) { 896238106Sdes snprintf(nm, sizeof(nm), "AXFR"); 897238106Sdes } else if (i == LDNS_RR_TYPE_MAILA) { 898238106Sdes snprintf(nm, sizeof(nm), "MAILA"); 899238106Sdes } else if (i == LDNS_RR_TYPE_MAILB) { 900238106Sdes snprintf(nm, sizeof(nm), "MAILB"); 901238106Sdes } else if (i == LDNS_RR_TYPE_ANY) { 902238106Sdes snprintf(nm, sizeof(nm), "ANY"); 903238106Sdes } else { 904238106Sdes snprintf(nm, sizeof(nm), "TYPE%d", i); 905238106Sdes } 906285206Sdes if(!ssl_printf(ssl, "num.query.type.%s"SQ"%lu\n", 907285206Sdes nm, (unsigned long)s->svr.qtype[i])) return 0; 908238106Sdes } 909238106Sdes if(!inhibit_zero || s->svr.qtype_big) { 910285206Sdes if(!ssl_printf(ssl, "num.query.type.other"SQ"%lu\n", 911285206Sdes (unsigned long)s->svr.qtype_big)) return 0; 912238106Sdes } 913238106Sdes /* CLASS */ 914238106Sdes for(i=0; i<STATS_QCLASS_NUM; i++) { 915238106Sdes if(inhibit_zero && s->svr.qclass[i] == 0) 916238106Sdes continue; 917269257Sdes lt = sldns_lookup_by_id(sldns_rr_classes, i); 918238106Sdes if(lt && lt->name) { 919238106Sdes snprintf(nm, sizeof(nm), "%s", lt->name); 920238106Sdes } else { 921238106Sdes snprintf(nm, sizeof(nm), "CLASS%d", i); 922238106Sdes } 923285206Sdes if(!ssl_printf(ssl, "num.query.class.%s"SQ"%lu\n", 924285206Sdes nm, (unsigned long)s->svr.qclass[i])) return 0; 925238106Sdes } 926238106Sdes if(!inhibit_zero || s->svr.qclass_big) { 927285206Sdes if(!ssl_printf(ssl, "num.query.class.other"SQ"%lu\n", 928285206Sdes (unsigned long)s->svr.qclass_big)) return 0; 929238106Sdes } 930238106Sdes /* OPCODE */ 931238106Sdes for(i=0; i<STATS_OPCODE_NUM; i++) { 932238106Sdes if(inhibit_zero && s->svr.qopcode[i] == 0) 933238106Sdes continue; 934269257Sdes lt = sldns_lookup_by_id(sldns_opcodes, i); 935238106Sdes if(lt && lt->name) { 936238106Sdes snprintf(nm, sizeof(nm), "%s", lt->name); 937238106Sdes } else { 938238106Sdes snprintf(nm, sizeof(nm), "OPCODE%d", i); 939238106Sdes } 940285206Sdes if(!ssl_printf(ssl, "num.query.opcode.%s"SQ"%lu\n", 941285206Sdes nm, (unsigned long)s->svr.qopcode[i])) return 0; 942238106Sdes } 943238106Sdes /* transport */ 944285206Sdes if(!ssl_printf(ssl, "num.query.tcp"SQ"%lu\n", 945285206Sdes (unsigned long)s->svr.qtcp)) return 0; 946285206Sdes if(!ssl_printf(ssl, "num.query.tcpout"SQ"%lu\n", 947285206Sdes (unsigned long)s->svr.qtcp_outgoing)) return 0; 948285206Sdes if(!ssl_printf(ssl, "num.query.ipv6"SQ"%lu\n", 949285206Sdes (unsigned long)s->svr.qipv6)) return 0; 950238106Sdes /* flags */ 951285206Sdes if(!ssl_printf(ssl, "num.query.flags.QR"SQ"%lu\n", 952285206Sdes (unsigned long)s->svr.qbit_QR)) return 0; 953285206Sdes if(!ssl_printf(ssl, "num.query.flags.AA"SQ"%lu\n", 954285206Sdes (unsigned long)s->svr.qbit_AA)) return 0; 955285206Sdes if(!ssl_printf(ssl, "num.query.flags.TC"SQ"%lu\n", 956285206Sdes (unsigned long)s->svr.qbit_TC)) return 0; 957285206Sdes if(!ssl_printf(ssl, "num.query.flags.RD"SQ"%lu\n", 958285206Sdes (unsigned long)s->svr.qbit_RD)) return 0; 959285206Sdes if(!ssl_printf(ssl, "num.query.flags.RA"SQ"%lu\n", 960285206Sdes (unsigned long)s->svr.qbit_RA)) return 0; 961285206Sdes if(!ssl_printf(ssl, "num.query.flags.Z"SQ"%lu\n", 962285206Sdes (unsigned long)s->svr.qbit_Z)) return 0; 963285206Sdes if(!ssl_printf(ssl, "num.query.flags.AD"SQ"%lu\n", 964285206Sdes (unsigned long)s->svr.qbit_AD)) return 0; 965285206Sdes if(!ssl_printf(ssl, "num.query.flags.CD"SQ"%lu\n", 966285206Sdes (unsigned long)s->svr.qbit_CD)) return 0; 967285206Sdes if(!ssl_printf(ssl, "num.query.edns.present"SQ"%lu\n", 968285206Sdes (unsigned long)s->svr.qEDNS)) return 0; 969285206Sdes if(!ssl_printf(ssl, "num.query.edns.DO"SQ"%lu\n", 970285206Sdes (unsigned long)s->svr.qEDNS_DO)) return 0; 971238106Sdes 972238106Sdes /* RCODE */ 973238106Sdes for(i=0; i<STATS_RCODE_NUM; i++) { 974285206Sdes /* Always include RCODEs 0-5 */ 975285206Sdes if(inhibit_zero && i > LDNS_RCODE_REFUSED && s->svr.ans_rcode[i] == 0) 976238106Sdes continue; 977269257Sdes lt = sldns_lookup_by_id(sldns_rcodes, i); 978238106Sdes if(lt && lt->name) { 979238106Sdes snprintf(nm, sizeof(nm), "%s", lt->name); 980238106Sdes } else { 981238106Sdes snprintf(nm, sizeof(nm), "RCODE%d", i); 982238106Sdes } 983285206Sdes if(!ssl_printf(ssl, "num.answer.rcode.%s"SQ"%lu\n", 984285206Sdes nm, (unsigned long)s->svr.ans_rcode[i])) return 0; 985238106Sdes } 986238106Sdes if(!inhibit_zero || s->svr.ans_rcode_nodata) { 987285206Sdes if(!ssl_printf(ssl, "num.answer.rcode.nodata"SQ"%lu\n", 988285206Sdes (unsigned long)s->svr.ans_rcode_nodata)) return 0; 989238106Sdes } 990238106Sdes /* validation */ 991285206Sdes if(!ssl_printf(ssl, "num.answer.secure"SQ"%lu\n", 992285206Sdes (unsigned long)s->svr.ans_secure)) return 0; 993285206Sdes if(!ssl_printf(ssl, "num.answer.bogus"SQ"%lu\n", 994285206Sdes (unsigned long)s->svr.ans_bogus)) return 0; 995285206Sdes if(!ssl_printf(ssl, "num.rrset.bogus"SQ"%lu\n", 996285206Sdes (unsigned long)s->svr.rrset_bogus)) return 0; 997238106Sdes /* threat detection */ 998285206Sdes if(!ssl_printf(ssl, "unwanted.queries"SQ"%lu\n", 999285206Sdes (unsigned long)s->svr.unwanted_queries)) return 0; 1000285206Sdes if(!ssl_printf(ssl, "unwanted.replies"SQ"%lu\n", 1001285206Sdes (unsigned long)s->svr.unwanted_replies)) return 0; 1002285206Sdes /* cache counts */ 1003285206Sdes if(!ssl_printf(ssl, "msg.cache.count"SQ"%u\n", 1004285206Sdes (unsigned)s->svr.msg_cache_count)) return 0; 1005285206Sdes if(!ssl_printf(ssl, "rrset.cache.count"SQ"%u\n", 1006285206Sdes (unsigned)s->svr.rrset_cache_count)) return 0; 1007285206Sdes if(!ssl_printf(ssl, "infra.cache.count"SQ"%u\n", 1008285206Sdes (unsigned)s->svr.infra_cache_count)) return 0; 1009285206Sdes if(!ssl_printf(ssl, "key.cache.count"SQ"%u\n", 1010285206Sdes (unsigned)s->svr.key_cache_count)) return 0; 1011238106Sdes return 1; 1012238106Sdes} 1013238106Sdes 1014238106Sdes/** do the stats command */ 1015238106Sdesstatic void 1016238106Sdesdo_stats(SSL* ssl, struct daemon_remote* rc, int reset) 1017238106Sdes{ 1018238106Sdes struct daemon* daemon = rc->worker->daemon; 1019238106Sdes struct stats_info total; 1020238106Sdes struct stats_info s; 1021238106Sdes int i; 1022238106Sdes log_assert(daemon->num > 0); 1023238106Sdes /* gather all thread statistics in one place */ 1024238106Sdes for(i=0; i<daemon->num; i++) { 1025238106Sdes server_stats_obtain(rc->worker, daemon->workers[i], &s, reset); 1026238106Sdes if(!print_thread_stats(ssl, i, &s)) 1027238106Sdes return; 1028238106Sdes if(i == 0) 1029238106Sdes total = s; 1030238106Sdes else server_stats_add(&total, &s); 1031238106Sdes } 1032238106Sdes /* print the thread statistics */ 1033238106Sdes total.mesh_time_median /= (double)daemon->num; 1034238106Sdes if(!print_stats(ssl, "total", &total)) 1035238106Sdes return; 1036238106Sdes if(!print_uptime(ssl, rc->worker, reset)) 1037238106Sdes return; 1038238106Sdes if(daemon->cfg->stat_extended) { 1039238106Sdes if(!print_mem(ssl, rc->worker, daemon)) 1040238106Sdes return; 1041238106Sdes if(!print_hist(ssl, &total)) 1042238106Sdes return; 1043238106Sdes if(!print_ext(ssl, &total)) 1044238106Sdes return; 1045238106Sdes } 1046238106Sdes} 1047238106Sdes 1048238106Sdes/** parse commandline argument domain name */ 1049238106Sdesstatic int 1050238106Sdesparse_arg_name(SSL* ssl, char* str, uint8_t** res, size_t* len, int* labs) 1051238106Sdes{ 1052269257Sdes uint8_t nm[LDNS_MAX_DOMAINLEN+1]; 1053269257Sdes size_t nmlen = sizeof(nm); 1054269257Sdes int status; 1055238106Sdes *res = NULL; 1056238106Sdes *len = 0; 1057238106Sdes *labs = 0; 1058269257Sdes status = sldns_str2wire_dname_buf(str, nm, &nmlen); 1059269257Sdes if(status != 0) { 1060269257Sdes ssl_printf(ssl, "error cannot parse name %s at %d: %s\n", str, 1061269257Sdes LDNS_WIREPARSE_OFFSET(status), 1062269257Sdes sldns_get_errorstr_parse(status)); 1063238106Sdes return 0; 1064238106Sdes } 1065269257Sdes *res = memdup(nm, nmlen); 1066238106Sdes if(!*res) { 1067238106Sdes ssl_printf(ssl, "error out of memory\n"); 1068238106Sdes return 0; 1069238106Sdes } 1070238106Sdes *labs = dname_count_size_labels(*res, len); 1071238106Sdes return 1; 1072238106Sdes} 1073238106Sdes 1074238106Sdes/** find second argument, modifies string */ 1075238106Sdesstatic int 1076238106Sdesfind_arg2(SSL* ssl, char* arg, char** arg2) 1077238106Sdes{ 1078238106Sdes char* as = strchr(arg, ' '); 1079238106Sdes char* at = strchr(arg, '\t'); 1080238106Sdes if(as && at) { 1081238106Sdes if(at < as) 1082238106Sdes as = at; 1083238106Sdes as[0]=0; 1084238106Sdes *arg2 = skipwhite(as+1); 1085238106Sdes } else if(as) { 1086238106Sdes as[0]=0; 1087238106Sdes *arg2 = skipwhite(as+1); 1088238106Sdes } else if(at) { 1089238106Sdes at[0]=0; 1090238106Sdes *arg2 = skipwhite(at+1); 1091238106Sdes } else { 1092238106Sdes ssl_printf(ssl, "error could not find next argument " 1093238106Sdes "after %s\n", arg); 1094238106Sdes return 0; 1095238106Sdes } 1096238106Sdes return 1; 1097238106Sdes} 1098238106Sdes 1099238106Sdes/** Add a new zone */ 1100238106Sdesstatic void 1101238106Sdesdo_zone_add(SSL* ssl, struct worker* worker, char* arg) 1102238106Sdes{ 1103238106Sdes uint8_t* nm; 1104238106Sdes int nmlabs; 1105238106Sdes size_t nmlen; 1106238106Sdes char* arg2; 1107238106Sdes enum localzone_type t; 1108238106Sdes struct local_zone* z; 1109238106Sdes if(!find_arg2(ssl, arg, &arg2)) 1110238106Sdes return; 1111238106Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1112238106Sdes return; 1113238106Sdes if(!local_zone_str2type(arg2, &t)) { 1114238106Sdes ssl_printf(ssl, "error not a zone type. %s\n", arg2); 1115238106Sdes free(nm); 1116238106Sdes return; 1117238106Sdes } 1118269257Sdes lock_rw_wrlock(&worker->daemon->local_zones->lock); 1119238106Sdes if((z=local_zones_find(worker->daemon->local_zones, nm, nmlen, 1120238106Sdes nmlabs, LDNS_RR_CLASS_IN))) { 1121238106Sdes /* already present in tree */ 1122238106Sdes lock_rw_wrlock(&z->lock); 1123238106Sdes z->type = t; /* update type anyway */ 1124238106Sdes lock_rw_unlock(&z->lock); 1125238106Sdes free(nm); 1126269257Sdes lock_rw_unlock(&worker->daemon->local_zones->lock); 1127238106Sdes send_ok(ssl); 1128238106Sdes return; 1129238106Sdes } 1130238106Sdes if(!local_zones_add_zone(worker->daemon->local_zones, nm, nmlen, 1131238106Sdes nmlabs, LDNS_RR_CLASS_IN, t)) { 1132269257Sdes lock_rw_unlock(&worker->daemon->local_zones->lock); 1133238106Sdes ssl_printf(ssl, "error out of memory\n"); 1134238106Sdes return; 1135238106Sdes } 1136269257Sdes lock_rw_unlock(&worker->daemon->local_zones->lock); 1137238106Sdes send_ok(ssl); 1138238106Sdes} 1139238106Sdes 1140238106Sdes/** Remove a zone */ 1141238106Sdesstatic void 1142238106Sdesdo_zone_remove(SSL* ssl, struct worker* worker, char* arg) 1143238106Sdes{ 1144238106Sdes uint8_t* nm; 1145238106Sdes int nmlabs; 1146238106Sdes size_t nmlen; 1147238106Sdes struct local_zone* z; 1148238106Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1149238106Sdes return; 1150269257Sdes lock_rw_wrlock(&worker->daemon->local_zones->lock); 1151238106Sdes if((z=local_zones_find(worker->daemon->local_zones, nm, nmlen, 1152238106Sdes nmlabs, LDNS_RR_CLASS_IN))) { 1153238106Sdes /* present in tree */ 1154238106Sdes local_zones_del_zone(worker->daemon->local_zones, z); 1155238106Sdes } 1156269257Sdes lock_rw_unlock(&worker->daemon->local_zones->lock); 1157238106Sdes free(nm); 1158238106Sdes send_ok(ssl); 1159238106Sdes} 1160238106Sdes 1161238106Sdes/** Add new RR data */ 1162238106Sdesstatic void 1163238106Sdesdo_data_add(SSL* ssl, struct worker* worker, char* arg) 1164238106Sdes{ 1165269257Sdes if(!local_zones_add_RR(worker->daemon->local_zones, arg)) { 1166238106Sdes ssl_printf(ssl,"error in syntax or out of memory, %s\n", arg); 1167238106Sdes return; 1168238106Sdes } 1169238106Sdes send_ok(ssl); 1170238106Sdes} 1171238106Sdes 1172238106Sdes/** Remove RR data */ 1173238106Sdesstatic void 1174238106Sdesdo_data_remove(SSL* ssl, struct worker* worker, char* arg) 1175238106Sdes{ 1176238106Sdes uint8_t* nm; 1177238106Sdes int nmlabs; 1178238106Sdes size_t nmlen; 1179238106Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1180238106Sdes return; 1181238106Sdes local_zones_del_data(worker->daemon->local_zones, nm, 1182238106Sdes nmlen, nmlabs, LDNS_RR_CLASS_IN); 1183238106Sdes free(nm); 1184238106Sdes send_ok(ssl); 1185238106Sdes} 1186238106Sdes 1187238106Sdes/** cache lookup of nameservers */ 1188238106Sdesstatic void 1189238106Sdesdo_lookup(SSL* ssl, struct worker* worker, char* arg) 1190238106Sdes{ 1191238106Sdes uint8_t* nm; 1192238106Sdes int nmlabs; 1193238106Sdes size_t nmlen; 1194238106Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1195238106Sdes return; 1196238106Sdes (void)print_deleg_lookup(ssl, worker, nm, nmlen, nmlabs); 1197238106Sdes free(nm); 1198238106Sdes} 1199238106Sdes 1200238106Sdes/** flush something from rrset and msg caches */ 1201238106Sdesstatic void 1202238106Sdesdo_cache_remove(struct worker* worker, uint8_t* nm, size_t nmlen, 1203238106Sdes uint16_t t, uint16_t c) 1204238106Sdes{ 1205238106Sdes hashvalue_t h; 1206238106Sdes struct query_info k; 1207238106Sdes rrset_cache_remove(worker->env.rrset_cache, nm, nmlen, t, c, 0); 1208238106Sdes if(t == LDNS_RR_TYPE_SOA) 1209238106Sdes rrset_cache_remove(worker->env.rrset_cache, nm, nmlen, t, c, 1210238106Sdes PACKED_RRSET_SOA_NEG); 1211238106Sdes k.qname = nm; 1212238106Sdes k.qname_len = nmlen; 1213238106Sdes k.qtype = t; 1214238106Sdes k.qclass = c; 1215285206Sdes h = query_info_hash(&k, 0); 1216238106Sdes slabhash_remove(worker->env.msg_cache, h, &k); 1217285206Sdes if(t == LDNS_RR_TYPE_AAAA) { 1218285206Sdes /* for AAAA also flush dns64 bit_cd packet */ 1219285206Sdes h = query_info_hash(&k, BIT_CD); 1220285206Sdes slabhash_remove(worker->env.msg_cache, h, &k); 1221285206Sdes } 1222238106Sdes} 1223238106Sdes 1224238106Sdes/** flush a type */ 1225238106Sdesstatic void 1226238106Sdesdo_flush_type(SSL* ssl, struct worker* worker, char* arg) 1227238106Sdes{ 1228238106Sdes uint8_t* nm; 1229238106Sdes int nmlabs; 1230238106Sdes size_t nmlen; 1231238106Sdes char* arg2; 1232238106Sdes uint16_t t; 1233238106Sdes if(!find_arg2(ssl, arg, &arg2)) 1234238106Sdes return; 1235238106Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1236238106Sdes return; 1237269257Sdes t = sldns_get_rr_type_by_name(arg2); 1238238106Sdes do_cache_remove(worker, nm, nmlen, t, LDNS_RR_CLASS_IN); 1239238106Sdes 1240238106Sdes free(nm); 1241238106Sdes send_ok(ssl); 1242238106Sdes} 1243238106Sdes 1244238106Sdes/** flush statistics */ 1245238106Sdesstatic void 1246238106Sdesdo_flush_stats(SSL* ssl, struct worker* worker) 1247238106Sdes{ 1248238106Sdes worker_stats_clear(worker); 1249238106Sdes send_ok(ssl); 1250238106Sdes} 1251238106Sdes 1252238106Sdes/** 1253238106Sdes * Local info for deletion functions 1254238106Sdes */ 1255238106Sdesstruct del_info { 1256238106Sdes /** worker */ 1257238106Sdes struct worker* worker; 1258238106Sdes /** name to delete */ 1259238106Sdes uint8_t* name; 1260238106Sdes /** length */ 1261238106Sdes size_t len; 1262238106Sdes /** labels */ 1263238106Sdes int labs; 1264238106Sdes /** time to invalidate to */ 1265269257Sdes time_t expired; 1266238106Sdes /** number of rrsets removed */ 1267238106Sdes size_t num_rrsets; 1268238106Sdes /** number of msgs removed */ 1269238106Sdes size_t num_msgs; 1270238106Sdes /** number of key entries removed */ 1271238106Sdes size_t num_keys; 1272238106Sdes /** length of addr */ 1273238106Sdes socklen_t addrlen; 1274238106Sdes /** socket address for host deletion */ 1275238106Sdes struct sockaddr_storage addr; 1276238106Sdes}; 1277238106Sdes 1278238106Sdes/** callback to delete hosts in infra cache */ 1279238106Sdesstatic void 1280238106Sdesinfra_del_host(struct lruhash_entry* e, void* arg) 1281238106Sdes{ 1282238106Sdes /* entry is locked */ 1283238106Sdes struct del_info* inf = (struct del_info*)arg; 1284238106Sdes struct infra_key* k = (struct infra_key*)e->key; 1285238106Sdes if(sockaddr_cmp(&inf->addr, inf->addrlen, &k->addr, k->addrlen) == 0) { 1286238106Sdes struct infra_data* d = (struct infra_data*)e->data; 1287238106Sdes d->probedelay = 0; 1288238106Sdes d->timeout_A = 0; 1289238106Sdes d->timeout_AAAA = 0; 1290238106Sdes d->timeout_other = 0; 1291238106Sdes rtt_init(&d->rtt); 1292291767Sdes if(d->ttl > inf->expired) { 1293238106Sdes d->ttl = inf->expired; 1294238106Sdes inf->num_keys++; 1295238106Sdes } 1296238106Sdes } 1297238106Sdes} 1298238106Sdes 1299238106Sdes/** flush infra cache */ 1300238106Sdesstatic void 1301238106Sdesdo_flush_infra(SSL* ssl, struct worker* worker, char* arg) 1302238106Sdes{ 1303238106Sdes struct sockaddr_storage addr; 1304238106Sdes socklen_t len; 1305238106Sdes struct del_info inf; 1306238106Sdes if(strcmp(arg, "all") == 0) { 1307238106Sdes slabhash_clear(worker->env.infra_cache->hosts); 1308238106Sdes send_ok(ssl); 1309238106Sdes return; 1310238106Sdes } 1311238106Sdes if(!ipstrtoaddr(arg, UNBOUND_DNS_PORT, &addr, &len)) { 1312238106Sdes (void)ssl_printf(ssl, "error parsing ip addr: '%s'\n", arg); 1313238106Sdes return; 1314238106Sdes } 1315238106Sdes /* delete all entries from cache */ 1316238106Sdes /* what we do is to set them all expired */ 1317238106Sdes inf.worker = worker; 1318238106Sdes inf.name = 0; 1319238106Sdes inf.len = 0; 1320238106Sdes inf.labs = 0; 1321238106Sdes inf.expired = *worker->env.now; 1322238106Sdes inf.expired -= 3; /* handle 3 seconds skew between threads */ 1323238106Sdes inf.num_rrsets = 0; 1324238106Sdes inf.num_msgs = 0; 1325238106Sdes inf.num_keys = 0; 1326238106Sdes inf.addrlen = len; 1327238106Sdes memmove(&inf.addr, &addr, len); 1328238106Sdes slabhash_traverse(worker->env.infra_cache->hosts, 1, &infra_del_host, 1329238106Sdes &inf); 1330238106Sdes send_ok(ssl); 1331238106Sdes} 1332238106Sdes 1333238106Sdes/** flush requestlist */ 1334238106Sdesstatic void 1335238106Sdesdo_flush_requestlist(SSL* ssl, struct worker* worker) 1336238106Sdes{ 1337238106Sdes mesh_delete_all(worker->env.mesh); 1338238106Sdes send_ok(ssl); 1339238106Sdes} 1340238106Sdes 1341238106Sdes/** callback to delete rrsets in a zone */ 1342238106Sdesstatic void 1343238106Sdeszone_del_rrset(struct lruhash_entry* e, void* arg) 1344238106Sdes{ 1345238106Sdes /* entry is locked */ 1346238106Sdes struct del_info* inf = (struct del_info*)arg; 1347238106Sdes struct ub_packed_rrset_key* k = (struct ub_packed_rrset_key*)e->key; 1348238106Sdes if(dname_subdomain_c(k->rk.dname, inf->name)) { 1349238106Sdes struct packed_rrset_data* d = 1350238106Sdes (struct packed_rrset_data*)e->data; 1351291767Sdes if(d->ttl > inf->expired) { 1352238106Sdes d->ttl = inf->expired; 1353238106Sdes inf->num_rrsets++; 1354238106Sdes } 1355238106Sdes } 1356238106Sdes} 1357238106Sdes 1358238106Sdes/** callback to delete messages in a zone */ 1359238106Sdesstatic void 1360238106Sdeszone_del_msg(struct lruhash_entry* e, void* arg) 1361238106Sdes{ 1362238106Sdes /* entry is locked */ 1363238106Sdes struct del_info* inf = (struct del_info*)arg; 1364238106Sdes struct msgreply_entry* k = (struct msgreply_entry*)e->key; 1365238106Sdes if(dname_subdomain_c(k->key.qname, inf->name)) { 1366238106Sdes struct reply_info* d = (struct reply_info*)e->data; 1367291767Sdes if(d->ttl > inf->expired) { 1368238106Sdes d->ttl = inf->expired; 1369238106Sdes inf->num_msgs++; 1370238106Sdes } 1371238106Sdes } 1372238106Sdes} 1373238106Sdes 1374238106Sdes/** callback to delete keys in zone */ 1375238106Sdesstatic void 1376238106Sdeszone_del_kcache(struct lruhash_entry* e, void* arg) 1377238106Sdes{ 1378238106Sdes /* entry is locked */ 1379238106Sdes struct del_info* inf = (struct del_info*)arg; 1380238106Sdes struct key_entry_key* k = (struct key_entry_key*)e->key; 1381238106Sdes if(dname_subdomain_c(k->name, inf->name)) { 1382238106Sdes struct key_entry_data* d = (struct key_entry_data*)e->data; 1383291767Sdes if(d->ttl > inf->expired) { 1384238106Sdes d->ttl = inf->expired; 1385238106Sdes inf->num_keys++; 1386238106Sdes } 1387238106Sdes } 1388238106Sdes} 1389238106Sdes 1390238106Sdes/** remove all rrsets and keys from zone from cache */ 1391238106Sdesstatic void 1392238106Sdesdo_flush_zone(SSL* ssl, struct worker* worker, char* arg) 1393238106Sdes{ 1394238106Sdes uint8_t* nm; 1395238106Sdes int nmlabs; 1396238106Sdes size_t nmlen; 1397238106Sdes struct del_info inf; 1398238106Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1399238106Sdes return; 1400238106Sdes /* delete all RRs and key entries from zone */ 1401238106Sdes /* what we do is to set them all expired */ 1402238106Sdes inf.worker = worker; 1403238106Sdes inf.name = nm; 1404238106Sdes inf.len = nmlen; 1405238106Sdes inf.labs = nmlabs; 1406238106Sdes inf.expired = *worker->env.now; 1407238106Sdes inf.expired -= 3; /* handle 3 seconds skew between threads */ 1408238106Sdes inf.num_rrsets = 0; 1409238106Sdes inf.num_msgs = 0; 1410238106Sdes inf.num_keys = 0; 1411238106Sdes slabhash_traverse(&worker->env.rrset_cache->table, 1, 1412238106Sdes &zone_del_rrset, &inf); 1413238106Sdes 1414238106Sdes slabhash_traverse(worker->env.msg_cache, 1, &zone_del_msg, &inf); 1415238106Sdes 1416238106Sdes /* and validator cache */ 1417238106Sdes if(worker->env.key_cache) { 1418238106Sdes slabhash_traverse(worker->env.key_cache->slab, 1, 1419238106Sdes &zone_del_kcache, &inf); 1420238106Sdes } 1421238106Sdes 1422238106Sdes free(nm); 1423238106Sdes 1424285206Sdes (void)ssl_printf(ssl, "ok removed %lu rrsets, %lu messages " 1425285206Sdes "and %lu key entries\n", (unsigned long)inf.num_rrsets, 1426285206Sdes (unsigned long)inf.num_msgs, (unsigned long)inf.num_keys); 1427238106Sdes} 1428238106Sdes 1429249141Sdes/** callback to delete bogus rrsets */ 1430249141Sdesstatic void 1431249141Sdesbogus_del_rrset(struct lruhash_entry* e, void* arg) 1432249141Sdes{ 1433249141Sdes /* entry is locked */ 1434249141Sdes struct del_info* inf = (struct del_info*)arg; 1435249141Sdes struct packed_rrset_data* d = (struct packed_rrset_data*)e->data; 1436249141Sdes if(d->security == sec_status_bogus) { 1437249141Sdes d->ttl = inf->expired; 1438249141Sdes inf->num_rrsets++; 1439249141Sdes } 1440249141Sdes} 1441249141Sdes 1442249141Sdes/** callback to delete bogus messages */ 1443249141Sdesstatic void 1444249141Sdesbogus_del_msg(struct lruhash_entry* e, void* arg) 1445249141Sdes{ 1446249141Sdes /* entry is locked */ 1447249141Sdes struct del_info* inf = (struct del_info*)arg; 1448249141Sdes struct reply_info* d = (struct reply_info*)e->data; 1449249141Sdes if(d->security == sec_status_bogus) { 1450249141Sdes d->ttl = inf->expired; 1451249141Sdes inf->num_msgs++; 1452249141Sdes } 1453249141Sdes} 1454249141Sdes 1455249141Sdes/** callback to delete bogus keys */ 1456249141Sdesstatic void 1457249141Sdesbogus_del_kcache(struct lruhash_entry* e, void* arg) 1458249141Sdes{ 1459249141Sdes /* entry is locked */ 1460249141Sdes struct del_info* inf = (struct del_info*)arg; 1461249141Sdes struct key_entry_data* d = (struct key_entry_data*)e->data; 1462249141Sdes if(d->isbad) { 1463249141Sdes d->ttl = inf->expired; 1464249141Sdes inf->num_keys++; 1465249141Sdes } 1466249141Sdes} 1467249141Sdes 1468285206Sdes/** remove all bogus rrsets, msgs and keys from cache */ 1469249141Sdesstatic void 1470249141Sdesdo_flush_bogus(SSL* ssl, struct worker* worker) 1471249141Sdes{ 1472249141Sdes struct del_info inf; 1473249141Sdes /* what we do is to set them all expired */ 1474249141Sdes inf.worker = worker; 1475249141Sdes inf.expired = *worker->env.now; 1476249141Sdes inf.expired -= 3; /* handle 3 seconds skew between threads */ 1477249141Sdes inf.num_rrsets = 0; 1478249141Sdes inf.num_msgs = 0; 1479249141Sdes inf.num_keys = 0; 1480249141Sdes slabhash_traverse(&worker->env.rrset_cache->table, 1, 1481249141Sdes &bogus_del_rrset, &inf); 1482249141Sdes 1483249141Sdes slabhash_traverse(worker->env.msg_cache, 1, &bogus_del_msg, &inf); 1484249141Sdes 1485249141Sdes /* and validator cache */ 1486249141Sdes if(worker->env.key_cache) { 1487249141Sdes slabhash_traverse(worker->env.key_cache->slab, 1, 1488249141Sdes &bogus_del_kcache, &inf); 1489249141Sdes } 1490249141Sdes 1491285206Sdes (void)ssl_printf(ssl, "ok removed %lu rrsets, %lu messages " 1492285206Sdes "and %lu key entries\n", (unsigned long)inf.num_rrsets, 1493285206Sdes (unsigned long)inf.num_msgs, (unsigned long)inf.num_keys); 1494249141Sdes} 1495249141Sdes 1496285206Sdes/** callback to delete negative and servfail rrsets */ 1497285206Sdesstatic void 1498285206Sdesnegative_del_rrset(struct lruhash_entry* e, void* arg) 1499285206Sdes{ 1500285206Sdes /* entry is locked */ 1501285206Sdes struct del_info* inf = (struct del_info*)arg; 1502285206Sdes struct ub_packed_rrset_key* k = (struct ub_packed_rrset_key*)e->key; 1503285206Sdes struct packed_rrset_data* d = (struct packed_rrset_data*)e->data; 1504285206Sdes /* delete the parentside negative cache rrsets, 1505285206Sdes * these are namerserver rrsets that failed lookup, rdata empty */ 1506285206Sdes if((k->rk.flags & PACKED_RRSET_PARENT_SIDE) && d->count == 1 && 1507285206Sdes d->rrsig_count == 0 && d->rr_len[0] == 0) { 1508285206Sdes d->ttl = inf->expired; 1509285206Sdes inf->num_rrsets++; 1510285206Sdes } 1511285206Sdes} 1512285206Sdes 1513285206Sdes/** callback to delete negative and servfail messages */ 1514285206Sdesstatic void 1515285206Sdesnegative_del_msg(struct lruhash_entry* e, void* arg) 1516285206Sdes{ 1517285206Sdes /* entry is locked */ 1518285206Sdes struct del_info* inf = (struct del_info*)arg; 1519285206Sdes struct reply_info* d = (struct reply_info*)e->data; 1520285206Sdes /* rcode not NOERROR: NXDOMAIN, SERVFAIL, ..: an nxdomain or error 1521285206Sdes * or NOERROR rcode with ANCOUNT==0: a NODATA answer */ 1522285206Sdes if(FLAGS_GET_RCODE(d->flags) != 0 || d->an_numrrsets == 0) { 1523285206Sdes d->ttl = inf->expired; 1524285206Sdes inf->num_msgs++; 1525285206Sdes } 1526285206Sdes} 1527285206Sdes 1528285206Sdes/** callback to delete negative key entries */ 1529285206Sdesstatic void 1530285206Sdesnegative_del_kcache(struct lruhash_entry* e, void* arg) 1531285206Sdes{ 1532285206Sdes /* entry is locked */ 1533285206Sdes struct del_info* inf = (struct del_info*)arg; 1534285206Sdes struct key_entry_data* d = (struct key_entry_data*)e->data; 1535285206Sdes /* could be bad because of lookup failure on the DS, DNSKEY, which 1536285206Sdes * was nxdomain or servfail, and thus a result of negative lookups */ 1537285206Sdes if(d->isbad) { 1538285206Sdes d->ttl = inf->expired; 1539285206Sdes inf->num_keys++; 1540285206Sdes } 1541285206Sdes} 1542285206Sdes 1543285206Sdes/** remove all negative(NODATA,NXDOMAIN), and servfail messages from cache */ 1544285206Sdesstatic void 1545285206Sdesdo_flush_negative(SSL* ssl, struct worker* worker) 1546285206Sdes{ 1547285206Sdes struct del_info inf; 1548285206Sdes /* what we do is to set them all expired */ 1549285206Sdes inf.worker = worker; 1550285206Sdes inf.expired = *worker->env.now; 1551285206Sdes inf.expired -= 3; /* handle 3 seconds skew between threads */ 1552285206Sdes inf.num_rrsets = 0; 1553285206Sdes inf.num_msgs = 0; 1554285206Sdes inf.num_keys = 0; 1555285206Sdes slabhash_traverse(&worker->env.rrset_cache->table, 1, 1556285206Sdes &negative_del_rrset, &inf); 1557285206Sdes 1558285206Sdes slabhash_traverse(worker->env.msg_cache, 1, &negative_del_msg, &inf); 1559285206Sdes 1560285206Sdes /* and validator cache */ 1561285206Sdes if(worker->env.key_cache) { 1562285206Sdes slabhash_traverse(worker->env.key_cache->slab, 1, 1563285206Sdes &negative_del_kcache, &inf); 1564285206Sdes } 1565285206Sdes 1566285206Sdes (void)ssl_printf(ssl, "ok removed %lu rrsets, %lu messages " 1567285206Sdes "and %lu key entries\n", (unsigned long)inf.num_rrsets, 1568285206Sdes (unsigned long)inf.num_msgs, (unsigned long)inf.num_keys); 1569285206Sdes} 1570285206Sdes 1571238106Sdes/** remove name rrset from cache */ 1572238106Sdesstatic void 1573238106Sdesdo_flush_name(SSL* ssl, struct worker* w, char* arg) 1574238106Sdes{ 1575238106Sdes uint8_t* nm; 1576238106Sdes int nmlabs; 1577238106Sdes size_t nmlen; 1578238106Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1579238106Sdes return; 1580238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_A, LDNS_RR_CLASS_IN); 1581238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_AAAA, LDNS_RR_CLASS_IN); 1582238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_NS, LDNS_RR_CLASS_IN); 1583238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_SOA, LDNS_RR_CLASS_IN); 1584238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_CNAME, LDNS_RR_CLASS_IN); 1585238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_DNAME, LDNS_RR_CLASS_IN); 1586238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_MX, LDNS_RR_CLASS_IN); 1587238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_PTR, LDNS_RR_CLASS_IN); 1588238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_SRV, LDNS_RR_CLASS_IN); 1589238106Sdes do_cache_remove(w, nm, nmlen, LDNS_RR_TYPE_NAPTR, LDNS_RR_CLASS_IN); 1590238106Sdes 1591238106Sdes free(nm); 1592238106Sdes send_ok(ssl); 1593238106Sdes} 1594238106Sdes 1595238106Sdes/** printout a delegation point info */ 1596238106Sdesstatic int 1597255579Sdesssl_print_name_dp(SSL* ssl, const char* str, uint8_t* nm, uint16_t dclass, 1598238106Sdes struct delegpt* dp) 1599238106Sdes{ 1600238106Sdes char buf[257]; 1601238106Sdes struct delegpt_ns* ns; 1602238106Sdes struct delegpt_addr* a; 1603238106Sdes int f = 0; 1604238106Sdes if(str) { /* print header for forward, stub */ 1605269257Sdes char* c = sldns_wire2str_class(dclass); 1606238106Sdes dname_str(nm, buf); 1607285206Sdes if(!ssl_printf(ssl, "%s %s %s ", buf, (c?c:"CLASS??"), str)) { 1608238106Sdes free(c); 1609238106Sdes return 0; 1610238106Sdes } 1611238106Sdes free(c); 1612238106Sdes } 1613238106Sdes for(ns = dp->nslist; ns; ns = ns->next) { 1614238106Sdes dname_str(ns->name, buf); 1615238106Sdes if(!ssl_printf(ssl, "%s%s", (f?" ":""), buf)) 1616238106Sdes return 0; 1617238106Sdes f = 1; 1618238106Sdes } 1619238106Sdes for(a = dp->target_list; a; a = a->next_target) { 1620238106Sdes addr_to_str(&a->addr, a->addrlen, buf, sizeof(buf)); 1621238106Sdes if(!ssl_printf(ssl, "%s%s", (f?" ":""), buf)) 1622238106Sdes return 0; 1623238106Sdes f = 1; 1624238106Sdes } 1625238106Sdes return ssl_printf(ssl, "\n"); 1626238106Sdes} 1627238106Sdes 1628238106Sdes 1629238106Sdes/** print root forwards */ 1630238106Sdesstatic int 1631238106Sdesprint_root_fwds(SSL* ssl, struct iter_forwards* fwds, uint8_t* root) 1632238106Sdes{ 1633238106Sdes struct delegpt* dp; 1634238106Sdes dp = forwards_lookup(fwds, root, LDNS_RR_CLASS_IN); 1635238106Sdes if(!dp) 1636238106Sdes return ssl_printf(ssl, "off (using root hints)\n"); 1637238106Sdes /* if dp is returned it must be the root */ 1638238106Sdes log_assert(query_dname_compare(dp->name, root)==0); 1639238106Sdes return ssl_print_name_dp(ssl, NULL, root, LDNS_RR_CLASS_IN, dp); 1640238106Sdes} 1641238106Sdes 1642238106Sdes/** parse args into delegpt */ 1643238106Sdesstatic struct delegpt* 1644238106Sdesparse_delegpt(SSL* ssl, char* args, uint8_t* nm, int allow_names) 1645238106Sdes{ 1646238106Sdes /* parse args and add in */ 1647238106Sdes char* p = args; 1648238106Sdes char* todo; 1649238106Sdes struct delegpt* dp = delegpt_create_mlc(nm); 1650238106Sdes struct sockaddr_storage addr; 1651238106Sdes socklen_t addrlen; 1652238106Sdes if(!dp) { 1653238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1654238106Sdes return NULL; 1655238106Sdes } 1656238106Sdes while(p) { 1657238106Sdes todo = p; 1658238106Sdes p = strchr(p, ' '); /* find next spot, if any */ 1659238106Sdes if(p) { 1660238106Sdes *p++ = 0; /* end this spot */ 1661238106Sdes p = skipwhite(p); /* position at next spot */ 1662238106Sdes } 1663238106Sdes /* parse address */ 1664238106Sdes if(!extstrtoaddr(todo, &addr, &addrlen)) { 1665238106Sdes if(allow_names) { 1666238106Sdes uint8_t* n = NULL; 1667238106Sdes size_t ln; 1668238106Sdes int lb; 1669238106Sdes if(!parse_arg_name(ssl, todo, &n, &ln, &lb)) { 1670238106Sdes (void)ssl_printf(ssl, "error cannot " 1671238106Sdes "parse IP address or name " 1672238106Sdes "'%s'\n", todo); 1673238106Sdes delegpt_free_mlc(dp); 1674238106Sdes return NULL; 1675238106Sdes } 1676238106Sdes if(!delegpt_add_ns_mlc(dp, n, 0)) { 1677238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1678249141Sdes free(n); 1679238106Sdes delegpt_free_mlc(dp); 1680238106Sdes return NULL; 1681238106Sdes } 1682238106Sdes free(n); 1683238106Sdes 1684238106Sdes } else { 1685238106Sdes (void)ssl_printf(ssl, "error cannot parse" 1686238106Sdes " IP address '%s'\n", todo); 1687238106Sdes delegpt_free_mlc(dp); 1688238106Sdes return NULL; 1689238106Sdes } 1690238106Sdes } else { 1691238106Sdes /* add address */ 1692238106Sdes if(!delegpt_add_addr_mlc(dp, &addr, addrlen, 0, 0)) { 1693238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1694238106Sdes delegpt_free_mlc(dp); 1695238106Sdes return NULL; 1696238106Sdes } 1697238106Sdes } 1698238106Sdes } 1699291767Sdes dp->has_parent_side_NS = 1; 1700238106Sdes return dp; 1701238106Sdes} 1702238106Sdes 1703238106Sdes/** do the status command */ 1704238106Sdesstatic void 1705238106Sdesdo_forward(SSL* ssl, struct worker* worker, char* args) 1706238106Sdes{ 1707238106Sdes struct iter_forwards* fwd = worker->env.fwds; 1708238106Sdes uint8_t* root = (uint8_t*)"\000"; 1709238106Sdes if(!fwd) { 1710238106Sdes (void)ssl_printf(ssl, "error: structure not allocated\n"); 1711238106Sdes return; 1712238106Sdes } 1713238106Sdes if(args == NULL || args[0] == 0) { 1714238106Sdes (void)print_root_fwds(ssl, fwd, root); 1715238106Sdes return; 1716238106Sdes } 1717238106Sdes /* set root forwards for this thread. since we are in remote control 1718238106Sdes * the actual mesh is not running, so we can freely edit it. */ 1719238106Sdes /* delete all the existing queries first */ 1720238106Sdes mesh_delete_all(worker->env.mesh); 1721238106Sdes if(strcmp(args, "off") == 0) { 1722238106Sdes forwards_delete_zone(fwd, LDNS_RR_CLASS_IN, root); 1723238106Sdes } else { 1724238106Sdes struct delegpt* dp; 1725238106Sdes if(!(dp = parse_delegpt(ssl, args, root, 0))) 1726238106Sdes return; 1727238106Sdes if(!forwards_add_zone(fwd, LDNS_RR_CLASS_IN, dp)) { 1728238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1729238106Sdes return; 1730238106Sdes } 1731238106Sdes } 1732238106Sdes send_ok(ssl); 1733238106Sdes} 1734238106Sdes 1735238106Sdesstatic int 1736238106Sdesparse_fs_args(SSL* ssl, char* args, uint8_t** nm, struct delegpt** dp, 1737238106Sdes int* insecure, int* prime) 1738238106Sdes{ 1739238106Sdes char* zonename; 1740238106Sdes char* rest; 1741238106Sdes size_t nmlen; 1742238106Sdes int nmlabs; 1743238106Sdes /* parse all -x args */ 1744238106Sdes while(args[0] == '+') { 1745238106Sdes if(!find_arg2(ssl, args, &rest)) 1746238106Sdes return 0; 1747238106Sdes while(*(++args) != 0) { 1748238106Sdes if(*args == 'i' && insecure) 1749238106Sdes *insecure = 1; 1750238106Sdes else if(*args == 'p' && prime) 1751238106Sdes *prime = 1; 1752238106Sdes else { 1753238106Sdes (void)ssl_printf(ssl, "error: unknown option %s\n", args); 1754238106Sdes return 0; 1755238106Sdes } 1756238106Sdes } 1757238106Sdes args = rest; 1758238106Sdes } 1759238106Sdes /* parse name */ 1760238106Sdes if(dp) { 1761238106Sdes if(!find_arg2(ssl, args, &rest)) 1762238106Sdes return 0; 1763238106Sdes zonename = args; 1764238106Sdes args = rest; 1765238106Sdes } else zonename = args; 1766238106Sdes if(!parse_arg_name(ssl, zonename, nm, &nmlen, &nmlabs)) 1767238106Sdes return 0; 1768238106Sdes 1769238106Sdes /* parse dp */ 1770238106Sdes if(dp) { 1771238106Sdes if(!(*dp = parse_delegpt(ssl, args, *nm, 1))) { 1772238106Sdes free(*nm); 1773238106Sdes return 0; 1774238106Sdes } 1775238106Sdes } 1776238106Sdes return 1; 1777238106Sdes} 1778238106Sdes 1779238106Sdes/** do the forward_add command */ 1780238106Sdesstatic void 1781238106Sdesdo_forward_add(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 struct delegpt* dp = NULL; 1787238106Sdes if(!parse_fs_args(ssl, args, &nm, &dp, &insecure, NULL)) 1788238106Sdes return; 1789269257Sdes if(insecure && worker->env.anchors) { 1790238106Sdes if(!anchors_add_insecure(worker->env.anchors, LDNS_RR_CLASS_IN, 1791238106Sdes nm)) { 1792238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1793238106Sdes delegpt_free_mlc(dp); 1794238106Sdes free(nm); 1795238106Sdes return; 1796238106Sdes } 1797238106Sdes } 1798238106Sdes if(!forwards_add_zone(fwd, LDNS_RR_CLASS_IN, dp)) { 1799238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1800238106Sdes free(nm); 1801238106Sdes return; 1802238106Sdes } 1803238106Sdes free(nm); 1804238106Sdes send_ok(ssl); 1805238106Sdes} 1806238106Sdes 1807238106Sdes/** do the forward_remove command */ 1808238106Sdesstatic void 1809238106Sdesdo_forward_remove(SSL* ssl, struct worker* worker, char* args) 1810238106Sdes{ 1811238106Sdes struct iter_forwards* fwd = worker->env.fwds; 1812238106Sdes int insecure = 0; 1813238106Sdes uint8_t* nm = NULL; 1814238106Sdes if(!parse_fs_args(ssl, args, &nm, NULL, &insecure, NULL)) 1815238106Sdes return; 1816269257Sdes if(insecure && worker->env.anchors) 1817238106Sdes anchors_delete_insecure(worker->env.anchors, LDNS_RR_CLASS_IN, 1818238106Sdes nm); 1819238106Sdes forwards_delete_zone(fwd, LDNS_RR_CLASS_IN, nm); 1820238106Sdes free(nm); 1821238106Sdes send_ok(ssl); 1822238106Sdes} 1823238106Sdes 1824238106Sdes/** do the stub_add command */ 1825238106Sdesstatic void 1826238106Sdesdo_stub_add(SSL* ssl, struct worker* worker, char* args) 1827238106Sdes{ 1828238106Sdes struct iter_forwards* fwd = worker->env.fwds; 1829238106Sdes int insecure = 0, prime = 0; 1830238106Sdes uint8_t* nm = NULL; 1831238106Sdes struct delegpt* dp = NULL; 1832238106Sdes if(!parse_fs_args(ssl, args, &nm, &dp, &insecure, &prime)) 1833238106Sdes return; 1834269257Sdes if(insecure && worker->env.anchors) { 1835238106Sdes if(!anchors_add_insecure(worker->env.anchors, LDNS_RR_CLASS_IN, 1836238106Sdes nm)) { 1837238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1838238106Sdes delegpt_free_mlc(dp); 1839238106Sdes free(nm); 1840238106Sdes return; 1841238106Sdes } 1842238106Sdes } 1843238106Sdes if(!forwards_add_stub_hole(fwd, LDNS_RR_CLASS_IN, nm)) { 1844269257Sdes if(insecure && worker->env.anchors) 1845269257Sdes anchors_delete_insecure(worker->env.anchors, 1846269257Sdes LDNS_RR_CLASS_IN, nm); 1847238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1848238106Sdes delegpt_free_mlc(dp); 1849238106Sdes free(nm); 1850238106Sdes return; 1851238106Sdes } 1852238106Sdes if(!hints_add_stub(worker->env.hints, LDNS_RR_CLASS_IN, dp, !prime)) { 1853238106Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1854238106Sdes forwards_delete_stub_hole(fwd, LDNS_RR_CLASS_IN, nm); 1855269257Sdes if(insecure && worker->env.anchors) 1856269257Sdes anchors_delete_insecure(worker->env.anchors, 1857269257Sdes LDNS_RR_CLASS_IN, nm); 1858238106Sdes free(nm); 1859238106Sdes return; 1860238106Sdes } 1861238106Sdes free(nm); 1862238106Sdes send_ok(ssl); 1863238106Sdes} 1864238106Sdes 1865238106Sdes/** do the stub_remove command */ 1866238106Sdesstatic void 1867238106Sdesdo_stub_remove(SSL* ssl, struct worker* worker, char* args) 1868238106Sdes{ 1869238106Sdes struct iter_forwards* fwd = worker->env.fwds; 1870238106Sdes int insecure = 0; 1871238106Sdes uint8_t* nm = NULL; 1872238106Sdes if(!parse_fs_args(ssl, args, &nm, NULL, &insecure, NULL)) 1873238106Sdes return; 1874269257Sdes if(insecure && worker->env.anchors) 1875238106Sdes anchors_delete_insecure(worker->env.anchors, LDNS_RR_CLASS_IN, 1876238106Sdes nm); 1877238106Sdes forwards_delete_stub_hole(fwd, LDNS_RR_CLASS_IN, nm); 1878238106Sdes hints_delete_stub(worker->env.hints, LDNS_RR_CLASS_IN, nm); 1879238106Sdes free(nm); 1880238106Sdes send_ok(ssl); 1881238106Sdes} 1882238106Sdes 1883269257Sdes/** do the insecure_add command */ 1884269257Sdesstatic void 1885269257Sdesdo_insecure_add(SSL* ssl, struct worker* worker, char* arg) 1886269257Sdes{ 1887269257Sdes size_t nmlen; 1888269257Sdes int nmlabs; 1889269257Sdes uint8_t* nm = NULL; 1890269257Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1891269257Sdes return; 1892269257Sdes if(worker->env.anchors) { 1893269257Sdes if(!anchors_add_insecure(worker->env.anchors, 1894269257Sdes LDNS_RR_CLASS_IN, nm)) { 1895269257Sdes (void)ssl_printf(ssl, "error out of memory\n"); 1896269257Sdes free(nm); 1897269257Sdes return; 1898269257Sdes } 1899269257Sdes } 1900269257Sdes free(nm); 1901269257Sdes send_ok(ssl); 1902269257Sdes} 1903269257Sdes 1904269257Sdes/** do the insecure_remove command */ 1905269257Sdesstatic void 1906269257Sdesdo_insecure_remove(SSL* ssl, struct worker* worker, char* arg) 1907269257Sdes{ 1908269257Sdes size_t nmlen; 1909269257Sdes int nmlabs; 1910269257Sdes uint8_t* nm = NULL; 1911269257Sdes if(!parse_arg_name(ssl, arg, &nm, &nmlen, &nmlabs)) 1912269257Sdes return; 1913269257Sdes if(worker->env.anchors) 1914269257Sdes anchors_delete_insecure(worker->env.anchors, 1915269257Sdes LDNS_RR_CLASS_IN, nm); 1916269257Sdes free(nm); 1917269257Sdes send_ok(ssl); 1918269257Sdes} 1919269257Sdes 1920291767Sdesstatic void 1921291767Sdesdo_insecure_list(SSL* ssl, struct worker* worker) 1922291767Sdes{ 1923291767Sdes char buf[257]; 1924291767Sdes struct trust_anchor* a; 1925291767Sdes if(worker->env.anchors) { 1926291767Sdes RBTREE_FOR(a, struct trust_anchor*, worker->env.anchors->tree) { 1927291767Sdes if(a->numDS == 0 && a->numDNSKEY == 0) { 1928291767Sdes dname_str(a->name, buf); 1929291767Sdes ssl_printf(ssl, "%s\n", buf); 1930291767Sdes } 1931291767Sdes } 1932291767Sdes } 1933291767Sdes} 1934291767Sdes 1935238106Sdes/** do the status command */ 1936238106Sdesstatic void 1937238106Sdesdo_status(SSL* ssl, struct worker* worker) 1938238106Sdes{ 1939238106Sdes int i; 1940238106Sdes time_t uptime; 1941238106Sdes if(!ssl_printf(ssl, "version: %s\n", PACKAGE_VERSION)) 1942238106Sdes return; 1943238106Sdes if(!ssl_printf(ssl, "verbosity: %d\n", verbosity)) 1944238106Sdes return; 1945238106Sdes if(!ssl_printf(ssl, "threads: %d\n", worker->daemon->num)) 1946238106Sdes return; 1947238106Sdes if(!ssl_printf(ssl, "modules: %d [", worker->daemon->mods.num)) 1948238106Sdes return; 1949238106Sdes for(i=0; i<worker->daemon->mods.num; i++) { 1950238106Sdes if(!ssl_printf(ssl, " %s", worker->daemon->mods.mod[i]->name)) 1951238106Sdes return; 1952238106Sdes } 1953238106Sdes if(!ssl_printf(ssl, " ]\n")) 1954238106Sdes return; 1955238106Sdes uptime = (time_t)time(NULL) - (time_t)worker->daemon->time_boot.tv_sec; 1956269257Sdes if(!ssl_printf(ssl, "uptime: " ARG_LL "d seconds\n", (long long)uptime)) 1957238106Sdes return; 1958285206Sdes if(!ssl_printf(ssl, "options:%s%s\n" , 1959285206Sdes (worker->daemon->reuseport?" reuseport":""), 1960285206Sdes (worker->daemon->rc->accept_list?" control(ssl)":""))) 1961285206Sdes return; 1962238106Sdes if(!ssl_printf(ssl, "unbound (pid %d) is running...\n", 1963238106Sdes (int)getpid())) 1964238106Sdes return; 1965238106Sdes} 1966238106Sdes 1967238106Sdes/** get age for the mesh state */ 1968238106Sdesstatic void 1969238106Sdesget_mesh_age(struct mesh_state* m, char* buf, size_t len, 1970238106Sdes struct module_env* env) 1971238106Sdes{ 1972238106Sdes if(m->reply_list) { 1973238106Sdes struct timeval d; 1974238106Sdes struct mesh_reply* r = m->reply_list; 1975238106Sdes /* last reply is the oldest */ 1976238106Sdes while(r && r->next) 1977238106Sdes r = r->next; 1978238106Sdes timeval_subtract(&d, env->now_tv, &r->start_time); 1979269257Sdes snprintf(buf, len, ARG_LL "d.%6.6d", 1980269257Sdes (long long)d.tv_sec, (int)d.tv_usec); 1981238106Sdes } else { 1982238106Sdes snprintf(buf, len, "-"); 1983238106Sdes } 1984238106Sdes} 1985238106Sdes 1986238106Sdes/** get status of a mesh state */ 1987238106Sdesstatic void 1988238106Sdesget_mesh_status(struct mesh_area* mesh, struct mesh_state* m, 1989238106Sdes char* buf, size_t len) 1990238106Sdes{ 1991238106Sdes enum module_ext_state s = m->s.ext_state[m->s.curmod]; 1992238106Sdes const char *modname = mesh->mods.mod[m->s.curmod]->name; 1993238106Sdes size_t l; 1994238106Sdes if(strcmp(modname, "iterator") == 0 && s == module_wait_reply && 1995238106Sdes m->s.minfo[m->s.curmod]) { 1996238106Sdes /* break into iterator to find out who its waiting for */ 1997238106Sdes struct iter_qstate* qstate = (struct iter_qstate*) 1998238106Sdes m->s.minfo[m->s.curmod]; 1999238106Sdes struct outbound_list* ol = &qstate->outlist; 2000238106Sdes struct outbound_entry* e; 2001238106Sdes snprintf(buf, len, "%s wait for", modname); 2002238106Sdes l = strlen(buf); 2003238106Sdes buf += l; len -= l; 2004238106Sdes if(ol->first == NULL) 2005238106Sdes snprintf(buf, len, " (empty_list)"); 2006238106Sdes for(e = ol->first; e; e = e->next) { 2007238106Sdes snprintf(buf, len, " "); 2008238106Sdes l = strlen(buf); 2009238106Sdes buf += l; len -= l; 2010238106Sdes addr_to_str(&e->qsent->addr, e->qsent->addrlen, 2011238106Sdes buf, len); 2012238106Sdes l = strlen(buf); 2013238106Sdes buf += l; len -= l; 2014238106Sdes } 2015238106Sdes } else if(s == module_wait_subquery) { 2016238106Sdes /* look in subs from mesh state to see what */ 2017238106Sdes char nm[257]; 2018238106Sdes struct mesh_state_ref* sub; 2019238106Sdes snprintf(buf, len, "%s wants", modname); 2020238106Sdes l = strlen(buf); 2021238106Sdes buf += l; len -= l; 2022238106Sdes if(m->sub_set.count == 0) 2023238106Sdes snprintf(buf, len, " (empty_list)"); 2024238106Sdes RBTREE_FOR(sub, struct mesh_state_ref*, &m->sub_set) { 2025269257Sdes char* t = sldns_wire2str_type(sub->s->s.qinfo.qtype); 2026269257Sdes char* c = sldns_wire2str_class(sub->s->s.qinfo.qclass); 2027238106Sdes dname_str(sub->s->s.qinfo.qname, nm); 2028269257Sdes snprintf(buf, len, " %s %s %s", (t?t:"TYPE??"), 2029269257Sdes (c?c:"CLASS??"), nm); 2030238106Sdes l = strlen(buf); 2031238106Sdes buf += l; len -= l; 2032238106Sdes free(t); 2033238106Sdes free(c); 2034238106Sdes } 2035238106Sdes } else { 2036238106Sdes snprintf(buf, len, "%s is %s", modname, strextstate(s)); 2037238106Sdes } 2038238106Sdes} 2039238106Sdes 2040238106Sdes/** do the dump_requestlist command */ 2041238106Sdesstatic void 2042238106Sdesdo_dump_requestlist(SSL* ssl, struct worker* worker) 2043238106Sdes{ 2044238106Sdes struct mesh_area* mesh; 2045238106Sdes struct mesh_state* m; 2046238106Sdes int num = 0; 2047238106Sdes char buf[257]; 2048238106Sdes char timebuf[32]; 2049238106Sdes char statbuf[10240]; 2050238106Sdes if(!ssl_printf(ssl, "thread #%d\n", worker->thread_num)) 2051238106Sdes return; 2052238106Sdes if(!ssl_printf(ssl, "# type cl name seconds module status\n")) 2053238106Sdes return; 2054238106Sdes /* show worker mesh contents */ 2055238106Sdes mesh = worker->env.mesh; 2056238106Sdes if(!mesh) return; 2057238106Sdes RBTREE_FOR(m, struct mesh_state*, &mesh->all) { 2058269257Sdes char* t = sldns_wire2str_type(m->s.qinfo.qtype); 2059269257Sdes char* c = sldns_wire2str_class(m->s.qinfo.qclass); 2060238106Sdes dname_str(m->s.qinfo.qname, buf); 2061238106Sdes get_mesh_age(m, timebuf, sizeof(timebuf), &worker->env); 2062238106Sdes get_mesh_status(mesh, m, statbuf, sizeof(statbuf)); 2063238106Sdes if(!ssl_printf(ssl, "%3d %4s %2s %s %s %s\n", 2064269257Sdes num, (t?t:"TYPE??"), (c?c:"CLASS??"), buf, timebuf, 2065269257Sdes statbuf)) { 2066238106Sdes free(t); 2067238106Sdes free(c); 2068238106Sdes return; 2069238106Sdes } 2070238106Sdes num++; 2071238106Sdes free(t); 2072238106Sdes free(c); 2073238106Sdes } 2074238106Sdes} 2075238106Sdes 2076238106Sdes/** structure for argument data for dump infra host */ 2077238106Sdesstruct infra_arg { 2078238106Sdes /** the infra cache */ 2079238106Sdes struct infra_cache* infra; 2080238106Sdes /** the SSL connection */ 2081238106Sdes SSL* ssl; 2082238106Sdes /** the time now */ 2083269257Sdes time_t now; 2084285206Sdes /** ssl failure? stop writing and skip the rest. If the tcp 2085285206Sdes * connection is broken, and writes fail, we then stop writing. */ 2086285206Sdes int ssl_failed; 2087238106Sdes}; 2088238106Sdes 2089238106Sdes/** callback for every host element in the infra cache */ 2090238106Sdesstatic void 2091238106Sdesdump_infra_host(struct lruhash_entry* e, void* arg) 2092238106Sdes{ 2093238106Sdes struct infra_arg* a = (struct infra_arg*)arg; 2094238106Sdes struct infra_key* k = (struct infra_key*)e->key; 2095238106Sdes struct infra_data* d = (struct infra_data*)e->data; 2096238106Sdes char ip_str[1024]; 2097238106Sdes char name[257]; 2098285206Sdes if(a->ssl_failed) 2099285206Sdes return; 2100238106Sdes addr_to_str(&k->addr, k->addrlen, ip_str, sizeof(ip_str)); 2101238106Sdes dname_str(k->zonename, name); 2102238106Sdes /* skip expired stuff (only backed off) */ 2103238106Sdes if(d->ttl < a->now) { 2104238106Sdes if(d->rtt.rto >= USEFUL_SERVER_TOP_TIMEOUT) { 2105238106Sdes if(!ssl_printf(a->ssl, "%s %s expired rto %d\n", ip_str, 2106285206Sdes name, d->rtt.rto)) { 2107285206Sdes a->ssl_failed = 1; 2108285206Sdes return; 2109285206Sdes } 2110238106Sdes } 2111238106Sdes return; 2112238106Sdes } 2113285206Sdes if(!ssl_printf(a->ssl, "%s %s ttl %lu ping %d var %d rtt %d rto %d " 2114238106Sdes "tA %d tAAAA %d tother %d " 2115238106Sdes "ednsknown %d edns %d delay %d lame dnssec %d rec %d A %d " 2116285206Sdes "other %d\n", ip_str, name, (unsigned long)(d->ttl - a->now), 2117238106Sdes d->rtt.srtt, d->rtt.rttvar, rtt_notimeout(&d->rtt), d->rtt.rto, 2118238106Sdes d->timeout_A, d->timeout_AAAA, d->timeout_other, 2119238106Sdes (int)d->edns_lame_known, (int)d->edns_version, 2120291767Sdes (int)(a->now<d->probedelay?(d->probedelay - a->now):0), 2121238106Sdes (int)d->isdnsseclame, (int)d->rec_lame, (int)d->lame_type_A, 2122285206Sdes (int)d->lame_other)) { 2123285206Sdes a->ssl_failed = 1; 2124238106Sdes return; 2125285206Sdes } 2126238106Sdes} 2127238106Sdes 2128238106Sdes/** do the dump_infra command */ 2129238106Sdesstatic void 2130238106Sdesdo_dump_infra(SSL* ssl, struct worker* worker) 2131238106Sdes{ 2132238106Sdes struct infra_arg arg; 2133238106Sdes arg.infra = worker->env.infra_cache; 2134238106Sdes arg.ssl = ssl; 2135238106Sdes arg.now = *worker->env.now; 2136285206Sdes arg.ssl_failed = 0; 2137238106Sdes slabhash_traverse(arg.infra->hosts, 0, &dump_infra_host, (void*)&arg); 2138238106Sdes} 2139238106Sdes 2140238106Sdes/** do the log_reopen command */ 2141238106Sdesstatic void 2142238106Sdesdo_log_reopen(SSL* ssl, struct worker* worker) 2143238106Sdes{ 2144238106Sdes struct config_file* cfg = worker->env.cfg; 2145238106Sdes send_ok(ssl); 2146238106Sdes log_init(cfg->logfile, cfg->use_syslog, cfg->chrootdir); 2147238106Sdes} 2148238106Sdes 2149238106Sdes/** do the set_option command */ 2150238106Sdesstatic void 2151238106Sdesdo_set_option(SSL* ssl, struct worker* worker, char* arg) 2152238106Sdes{ 2153238106Sdes char* arg2; 2154238106Sdes if(!find_arg2(ssl, arg, &arg2)) 2155238106Sdes return; 2156238106Sdes if(!config_set_option(worker->env.cfg, arg, arg2)) { 2157238106Sdes (void)ssl_printf(ssl, "error setting option\n"); 2158238106Sdes return; 2159238106Sdes } 2160238106Sdes send_ok(ssl); 2161238106Sdes} 2162238106Sdes 2163238106Sdes/* routine to printout option values over SSL */ 2164238106Sdesvoid remote_get_opt_ssl(char* line, void* arg) 2165238106Sdes{ 2166238106Sdes SSL* ssl = (SSL*)arg; 2167238106Sdes (void)ssl_printf(ssl, "%s\n", line); 2168238106Sdes} 2169238106Sdes 2170238106Sdes/** do the get_option command */ 2171238106Sdesstatic void 2172238106Sdesdo_get_option(SSL* ssl, struct worker* worker, char* arg) 2173238106Sdes{ 2174238106Sdes int r; 2175238106Sdes r = config_get_option(worker->env.cfg, arg, remote_get_opt_ssl, ssl); 2176238106Sdes if(!r) { 2177238106Sdes (void)ssl_printf(ssl, "error unknown option\n"); 2178238106Sdes return; 2179238106Sdes } 2180238106Sdes} 2181238106Sdes 2182238106Sdes/** do the list_forwards command */ 2183238106Sdesstatic void 2184238106Sdesdo_list_forwards(SSL* ssl, struct worker* worker) 2185238106Sdes{ 2186238106Sdes /* since its a per-worker structure no locks needed */ 2187238106Sdes struct iter_forwards* fwds = worker->env.fwds; 2188238106Sdes struct iter_forward_zone* z; 2189285206Sdes struct trust_anchor* a; 2190285206Sdes int insecure; 2191238106Sdes RBTREE_FOR(z, struct iter_forward_zone*, fwds->tree) { 2192238106Sdes if(!z->dp) continue; /* skip empty marker for stub */ 2193285206Sdes 2194285206Sdes /* see if it is insecure */ 2195285206Sdes insecure = 0; 2196285206Sdes if(worker->env.anchors && 2197285206Sdes (a=anchor_find(worker->env.anchors, z->name, 2198285206Sdes z->namelabs, z->namelen, z->dclass))) { 2199285206Sdes if(!a->keylist && !a->numDS && !a->numDNSKEY) 2200285206Sdes insecure = 1; 2201285206Sdes lock_basic_unlock(&a->lock); 2202285206Sdes } 2203285206Sdes 2204285206Sdes if(!ssl_print_name_dp(ssl, (insecure?"forward +i":"forward"), 2205285206Sdes z->name, z->dclass, z->dp)) 2206238106Sdes return; 2207238106Sdes } 2208238106Sdes} 2209238106Sdes 2210238106Sdes/** do the list_stubs command */ 2211238106Sdesstatic void 2212238106Sdesdo_list_stubs(SSL* ssl, struct worker* worker) 2213238106Sdes{ 2214238106Sdes struct iter_hints_stub* z; 2215285206Sdes struct trust_anchor* a; 2216285206Sdes int insecure; 2217285206Sdes char str[32]; 2218238106Sdes RBTREE_FOR(z, struct iter_hints_stub*, &worker->env.hints->tree) { 2219285206Sdes 2220285206Sdes /* see if it is insecure */ 2221285206Sdes insecure = 0; 2222285206Sdes if(worker->env.anchors && 2223285206Sdes (a=anchor_find(worker->env.anchors, z->node.name, 2224285206Sdes z->node.labs, z->node.len, z->node.dclass))) { 2225285206Sdes if(!a->keylist && !a->numDS && !a->numDNSKEY) 2226285206Sdes insecure = 1; 2227285206Sdes lock_basic_unlock(&a->lock); 2228285206Sdes } 2229285206Sdes 2230285206Sdes snprintf(str, sizeof(str), "stub %sprime%s", 2231285206Sdes (z->noprime?"no":""), (insecure?" +i":"")); 2232285206Sdes if(!ssl_print_name_dp(ssl, str, z->node.name, 2233238106Sdes z->node.dclass, z->dp)) 2234238106Sdes return; 2235238106Sdes } 2236238106Sdes} 2237238106Sdes 2238238106Sdes/** do the list_local_zones command */ 2239238106Sdesstatic void 2240238106Sdesdo_list_local_zones(SSL* ssl, struct worker* worker) 2241238106Sdes{ 2242238106Sdes struct local_zones* zones = worker->daemon->local_zones; 2243238106Sdes struct local_zone* z; 2244238106Sdes char buf[257]; 2245269257Sdes lock_rw_rdlock(&zones->lock); 2246238106Sdes RBTREE_FOR(z, struct local_zone*, &zones->ztree) { 2247238106Sdes lock_rw_rdlock(&z->lock); 2248238106Sdes dname_str(z->name, buf); 2249285206Sdes if(!ssl_printf(ssl, "%s %s\n", buf, 2250285206Sdes local_zone_type2str(z->type))) { 2251285206Sdes /* failure to print */ 2252285206Sdes lock_rw_unlock(&z->lock); 2253285206Sdes lock_rw_unlock(&zones->lock); 2254285206Sdes return; 2255285206Sdes } 2256238106Sdes lock_rw_unlock(&z->lock); 2257238106Sdes } 2258269257Sdes lock_rw_unlock(&zones->lock); 2259238106Sdes} 2260238106Sdes 2261238106Sdes/** do the list_local_data command */ 2262238106Sdesstatic void 2263238106Sdesdo_list_local_data(SSL* ssl, struct worker* worker) 2264238106Sdes{ 2265238106Sdes struct local_zones* zones = worker->daemon->local_zones; 2266238106Sdes struct local_zone* z; 2267238106Sdes struct local_data* d; 2268238106Sdes struct local_rrset* p; 2269269257Sdes char* s = (char*)sldns_buffer_begin(worker->env.scratch_buffer); 2270269257Sdes size_t slen = sldns_buffer_capacity(worker->env.scratch_buffer); 2271269257Sdes lock_rw_rdlock(&zones->lock); 2272238106Sdes RBTREE_FOR(z, struct local_zone*, &zones->ztree) { 2273238106Sdes lock_rw_rdlock(&z->lock); 2274238106Sdes RBTREE_FOR(d, struct local_data*, &z->data) { 2275238106Sdes for(p = d->rrsets; p; p = p->next) { 2276269257Sdes struct packed_rrset_data* d = 2277269257Sdes (struct packed_rrset_data*)p->rrset->entry.data; 2278269257Sdes size_t i; 2279269257Sdes for(i=0; i<d->count + d->rrsig_count; i++) { 2280269257Sdes if(!packed_rr_to_string(p->rrset, i, 2281269257Sdes 0, s, slen)) { 2282291767Sdes if(!ssl_printf(ssl, "BADRR\n")) { 2283291767Sdes lock_rw_unlock(&z->lock); 2284291767Sdes lock_rw_unlock(&zones->lock); 2285269257Sdes return; 2286291767Sdes } 2287269257Sdes } 2288291767Sdes if(!ssl_printf(ssl, "%s\n", s)) { 2289291767Sdes lock_rw_unlock(&z->lock); 2290291767Sdes lock_rw_unlock(&zones->lock); 2291269257Sdes return; 2292291767Sdes } 2293269257Sdes } 2294238106Sdes } 2295238106Sdes } 2296238106Sdes lock_rw_unlock(&z->lock); 2297238106Sdes } 2298269257Sdes lock_rw_unlock(&zones->lock); 2299238106Sdes} 2300238106Sdes 2301291767Sdes/** struct for user arg ratelimit list */ 2302291767Sdesstruct ratelimit_list_arg { 2303291767Sdes /** the infra cache */ 2304291767Sdes struct infra_cache* infra; 2305291767Sdes /** the SSL to print to */ 2306291767Sdes SSL* ssl; 2307291767Sdes /** all or only ratelimited */ 2308291767Sdes int all; 2309291767Sdes /** current time */ 2310291767Sdes time_t now; 2311291767Sdes}; 2312291767Sdes 2313291767Sdes/** list items in the ratelimit table */ 2314291767Sdesstatic void 2315291767Sdesrate_list(struct lruhash_entry* e, void* arg) 2316291767Sdes{ 2317291767Sdes struct ratelimit_list_arg* a = (struct ratelimit_list_arg*)arg; 2318291767Sdes struct rate_key* k = (struct rate_key*)e->key; 2319291767Sdes struct rate_data* d = (struct rate_data*)e->data; 2320291767Sdes char buf[257]; 2321291767Sdes int lim = infra_find_ratelimit(a->infra, k->name, k->namelen); 2322291767Sdes int max = infra_rate_max(d, a->now); 2323291767Sdes if(a->all == 0) { 2324291767Sdes if(max < lim) 2325291767Sdes return; 2326291767Sdes } 2327291767Sdes dname_str(k->name, buf); 2328291767Sdes ssl_printf(a->ssl, "%s %d limit %d\n", buf, max, lim); 2329291767Sdes} 2330291767Sdes 2331291767Sdes/** do the ratelimit_list command */ 2332291767Sdesstatic void 2333291767Sdesdo_ratelimit_list(SSL* ssl, struct worker* worker, char* arg) 2334291767Sdes{ 2335291767Sdes struct ratelimit_list_arg a; 2336291767Sdes a.all = 0; 2337291767Sdes a.infra = worker->env.infra_cache; 2338291767Sdes a.now = *worker->env.now; 2339291767Sdes a.ssl = ssl; 2340291767Sdes arg = skipwhite(arg); 2341291767Sdes if(strcmp(arg, "+a") == 0) 2342291767Sdes a.all = 1; 2343291767Sdes if(a.infra->domain_rates==NULL || 2344291767Sdes (a.all == 0 && infra_dp_ratelimit == 0)) 2345291767Sdes return; 2346291767Sdes slabhash_traverse(a.infra->domain_rates, 0, rate_list, &a); 2347291767Sdes} 2348291767Sdes 2349238106Sdes/** tell other processes to execute the command */ 2350238106Sdesstatic void 2351238106Sdesdistribute_cmd(struct daemon_remote* rc, SSL* ssl, char* cmd) 2352238106Sdes{ 2353238106Sdes int i; 2354238106Sdes if(!cmd || !ssl) 2355238106Sdes return; 2356238106Sdes /* skip i=0 which is me */ 2357238106Sdes for(i=1; i<rc->worker->daemon->num; i++) { 2358238106Sdes worker_send_cmd(rc->worker->daemon->workers[i], 2359238106Sdes worker_cmd_remote); 2360238106Sdes if(!tube_write_msg(rc->worker->daemon->workers[i]->cmd, 2361238106Sdes (uint8_t*)cmd, strlen(cmd)+1, 0)) { 2362238106Sdes ssl_printf(ssl, "error could not distribute cmd\n"); 2363238106Sdes return; 2364238106Sdes } 2365238106Sdes } 2366238106Sdes} 2367238106Sdes 2368238106Sdes/** check for name with end-of-string, space or tab after it */ 2369238106Sdesstatic int 2370238106Sdescmdcmp(char* p, const char* cmd, size_t len) 2371238106Sdes{ 2372238106Sdes return strncmp(p,cmd,len)==0 && (p[len]==0||p[len]==' '||p[len]=='\t'); 2373238106Sdes} 2374238106Sdes 2375238106Sdes/** execute a remote control command */ 2376238106Sdesstatic void 2377238106Sdesexecute_cmd(struct daemon_remote* rc, SSL* ssl, char* cmd, 2378238106Sdes struct worker* worker) 2379238106Sdes{ 2380238106Sdes char* p = skipwhite(cmd); 2381238106Sdes /* compare command */ 2382238106Sdes if(cmdcmp(p, "stop", 4)) { 2383238106Sdes do_stop(ssl, rc); 2384238106Sdes return; 2385238106Sdes } else if(cmdcmp(p, "reload", 6)) { 2386238106Sdes do_reload(ssl, rc); 2387238106Sdes return; 2388238106Sdes } else if(cmdcmp(p, "stats_noreset", 13)) { 2389238106Sdes do_stats(ssl, rc, 0); 2390238106Sdes return; 2391238106Sdes } else if(cmdcmp(p, "stats", 5)) { 2392238106Sdes do_stats(ssl, rc, 1); 2393238106Sdes return; 2394238106Sdes } else if(cmdcmp(p, "status", 6)) { 2395238106Sdes do_status(ssl, worker); 2396238106Sdes return; 2397238106Sdes } else if(cmdcmp(p, "dump_cache", 10)) { 2398238106Sdes (void)dump_cache(ssl, worker); 2399238106Sdes return; 2400238106Sdes } else if(cmdcmp(p, "load_cache", 10)) { 2401238106Sdes if(load_cache(ssl, worker)) send_ok(ssl); 2402238106Sdes return; 2403238106Sdes } else if(cmdcmp(p, "list_forwards", 13)) { 2404238106Sdes do_list_forwards(ssl, worker); 2405238106Sdes return; 2406238106Sdes } else if(cmdcmp(p, "list_stubs", 10)) { 2407238106Sdes do_list_stubs(ssl, worker); 2408238106Sdes return; 2409291767Sdes } else if(cmdcmp(p, "list_insecure", 13)) { 2410291767Sdes do_insecure_list(ssl, worker); 2411291767Sdes return; 2412238106Sdes } else if(cmdcmp(p, "list_local_zones", 16)) { 2413238106Sdes do_list_local_zones(ssl, worker); 2414238106Sdes return; 2415238106Sdes } else if(cmdcmp(p, "list_local_data", 15)) { 2416238106Sdes do_list_local_data(ssl, worker); 2417238106Sdes return; 2418291767Sdes } else if(cmdcmp(p, "ratelimit_list", 14)) { 2419291767Sdes do_ratelimit_list(ssl, worker, p+14); 2420291767Sdes return; 2421238106Sdes } else if(cmdcmp(p, "stub_add", 8)) { 2422238106Sdes /* must always distribute this cmd */ 2423238106Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2424238106Sdes do_stub_add(ssl, worker, skipwhite(p+8)); 2425238106Sdes return; 2426238106Sdes } else if(cmdcmp(p, "stub_remove", 11)) { 2427238106Sdes /* must always distribute this cmd */ 2428238106Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2429238106Sdes do_stub_remove(ssl, worker, skipwhite(p+11)); 2430238106Sdes return; 2431238106Sdes } else if(cmdcmp(p, "forward_add", 11)) { 2432238106Sdes /* must always distribute this cmd */ 2433238106Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2434238106Sdes do_forward_add(ssl, worker, skipwhite(p+11)); 2435238106Sdes return; 2436238106Sdes } else if(cmdcmp(p, "forward_remove", 14)) { 2437238106Sdes /* must always distribute this cmd */ 2438238106Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2439238106Sdes do_forward_remove(ssl, worker, skipwhite(p+14)); 2440238106Sdes return; 2441269257Sdes } else if(cmdcmp(p, "insecure_add", 12)) { 2442269257Sdes /* must always distribute this cmd */ 2443269257Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2444269257Sdes do_insecure_add(ssl, worker, skipwhite(p+12)); 2445269257Sdes return; 2446269257Sdes } else if(cmdcmp(p, "insecure_remove", 15)) { 2447269257Sdes /* must always distribute this cmd */ 2448269257Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2449269257Sdes do_insecure_remove(ssl, worker, skipwhite(p+15)); 2450269257Sdes return; 2451238106Sdes } else if(cmdcmp(p, "forward", 7)) { 2452238106Sdes /* must always distribute this cmd */ 2453238106Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2454238106Sdes do_forward(ssl, worker, skipwhite(p+7)); 2455238106Sdes return; 2456238106Sdes } else if(cmdcmp(p, "flush_stats", 11)) { 2457238106Sdes /* must always distribute this cmd */ 2458238106Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2459238106Sdes do_flush_stats(ssl, worker); 2460238106Sdes return; 2461238106Sdes } else if(cmdcmp(p, "flush_requestlist", 17)) { 2462238106Sdes /* must always distribute this cmd */ 2463238106Sdes if(rc) distribute_cmd(rc, ssl, cmd); 2464238106Sdes do_flush_requestlist(ssl, worker); 2465238106Sdes return; 2466238106Sdes } else if(cmdcmp(p, "lookup", 6)) { 2467238106Sdes do_lookup(ssl, worker, skipwhite(p+6)); 2468238106Sdes return; 2469238106Sdes } 2470238106Sdes 2471238106Sdes#ifdef THREADS_DISABLED 2472238106Sdes /* other processes must execute the command as well */ 2473238106Sdes /* commands that should not be distributed, returned above. */ 2474238106Sdes if(rc) { /* only if this thread is the master (rc) thread */ 2475238106Sdes /* done before the code below, which may split the string */ 2476238106Sdes distribute_cmd(rc, ssl, cmd); 2477238106Sdes } 2478238106Sdes#endif 2479238106Sdes if(cmdcmp(p, "verbosity", 9)) { 2480238106Sdes do_verbosity(ssl, skipwhite(p+9)); 2481238106Sdes } else if(cmdcmp(p, "local_zone_remove", 17)) { 2482238106Sdes do_zone_remove(ssl, worker, skipwhite(p+17)); 2483238106Sdes } else if(cmdcmp(p, "local_zone", 10)) { 2484238106Sdes do_zone_add(ssl, worker, skipwhite(p+10)); 2485238106Sdes } else if(cmdcmp(p, "local_data_remove", 17)) { 2486238106Sdes do_data_remove(ssl, worker, skipwhite(p+17)); 2487238106Sdes } else if(cmdcmp(p, "local_data", 10)) { 2488238106Sdes do_data_add(ssl, worker, skipwhite(p+10)); 2489238106Sdes } else if(cmdcmp(p, "flush_zone", 10)) { 2490238106Sdes do_flush_zone(ssl, worker, skipwhite(p+10)); 2491238106Sdes } else if(cmdcmp(p, "flush_type", 10)) { 2492238106Sdes do_flush_type(ssl, worker, skipwhite(p+10)); 2493238106Sdes } else if(cmdcmp(p, "flush_infra", 11)) { 2494238106Sdes do_flush_infra(ssl, worker, skipwhite(p+11)); 2495238106Sdes } else if(cmdcmp(p, "flush", 5)) { 2496238106Sdes do_flush_name(ssl, worker, skipwhite(p+5)); 2497238106Sdes } else if(cmdcmp(p, "dump_requestlist", 16)) { 2498238106Sdes do_dump_requestlist(ssl, worker); 2499238106Sdes } else if(cmdcmp(p, "dump_infra", 10)) { 2500238106Sdes do_dump_infra(ssl, worker); 2501238106Sdes } else if(cmdcmp(p, "log_reopen", 10)) { 2502238106Sdes do_log_reopen(ssl, worker); 2503238106Sdes } else if(cmdcmp(p, "set_option", 10)) { 2504238106Sdes do_set_option(ssl, worker, skipwhite(p+10)); 2505238106Sdes } else if(cmdcmp(p, "get_option", 10)) { 2506238106Sdes do_get_option(ssl, worker, skipwhite(p+10)); 2507249141Sdes } else if(cmdcmp(p, "flush_bogus", 11)) { 2508249141Sdes do_flush_bogus(ssl, worker); 2509285206Sdes } else if(cmdcmp(p, "flush_negative", 14)) { 2510285206Sdes do_flush_negative(ssl, worker); 2511238106Sdes } else { 2512238106Sdes (void)ssl_printf(ssl, "error unknown command '%s'\n", p); 2513238106Sdes } 2514238106Sdes} 2515238106Sdes 2516238106Sdesvoid 2517238106Sdesdaemon_remote_exec(struct worker* worker) 2518238106Sdes{ 2519238106Sdes /* read the cmd string */ 2520238106Sdes uint8_t* msg = NULL; 2521238106Sdes uint32_t len = 0; 2522238106Sdes if(!tube_read_msg(worker->cmd, &msg, &len, 0)) { 2523238106Sdes log_err("daemon_remote_exec: tube_read_msg failed"); 2524238106Sdes return; 2525238106Sdes } 2526238106Sdes verbose(VERB_ALGO, "remote exec distributed: %s", (char*)msg); 2527238106Sdes execute_cmd(NULL, NULL, (char*)msg, worker); 2528238106Sdes free(msg); 2529238106Sdes} 2530238106Sdes 2531238106Sdes/** handle remote control request */ 2532238106Sdesstatic void 2533238106Sdeshandle_req(struct daemon_remote* rc, struct rc_state* s, SSL* ssl) 2534238106Sdes{ 2535238106Sdes int r; 2536238106Sdes char pre[10]; 2537238106Sdes char magic[7]; 2538238106Sdes char buf[1024]; 2539238106Sdes#ifdef USE_WINSOCK 2540238106Sdes /* makes it possible to set the socket blocking again. */ 2541238106Sdes /* basically removes it from winsock_event ... */ 2542238106Sdes WSAEventSelect(s->c->fd, NULL, 0); 2543238106Sdes#endif 2544238106Sdes fd_set_block(s->c->fd); 2545238106Sdes 2546238106Sdes /* try to read magic UBCT[version]_space_ string */ 2547238106Sdes ERR_clear_error(); 2548238106Sdes if((r=SSL_read(ssl, magic, (int)sizeof(magic)-1)) <= 0) { 2549238106Sdes if(SSL_get_error(ssl, r) == SSL_ERROR_ZERO_RETURN) 2550238106Sdes return; 2551238106Sdes log_crypto_err("could not SSL_read"); 2552238106Sdes return; 2553238106Sdes } 2554238106Sdes magic[6] = 0; 2555238106Sdes if( r != 6 || strncmp(magic, "UBCT", 4) != 0) { 2556238106Sdes verbose(VERB_QUERY, "control connection has bad magic string"); 2557238106Sdes /* probably wrong tool connected, ignore it completely */ 2558238106Sdes return; 2559238106Sdes } 2560238106Sdes 2561238106Sdes /* read the command line */ 2562238106Sdes if(!ssl_read_line(ssl, buf, sizeof(buf))) { 2563238106Sdes return; 2564238106Sdes } 2565238106Sdes snprintf(pre, sizeof(pre), "UBCT%d ", UNBOUND_CONTROL_VERSION); 2566238106Sdes if(strcmp(magic, pre) != 0) { 2567238106Sdes verbose(VERB_QUERY, "control connection had bad " 2568238106Sdes "version %s, cmd: %s", magic, buf); 2569238106Sdes ssl_printf(ssl, "error version mismatch\n"); 2570238106Sdes return; 2571238106Sdes } 2572238106Sdes verbose(VERB_DETAIL, "control cmd: %s", buf); 2573238106Sdes 2574238106Sdes /* figure out what to do */ 2575238106Sdes execute_cmd(rc, ssl, buf, rc->worker); 2576238106Sdes} 2577238106Sdes 2578238106Sdesint remote_control_callback(struct comm_point* c, void* arg, int err, 2579238106Sdes struct comm_reply* ATTR_UNUSED(rep)) 2580238106Sdes{ 2581238106Sdes struct rc_state* s = (struct rc_state*)arg; 2582238106Sdes struct daemon_remote* rc = s->rc; 2583238106Sdes int r; 2584238106Sdes if(err != NETEVENT_NOERROR) { 2585238106Sdes if(err==NETEVENT_TIMEOUT) 2586238106Sdes log_err("remote control timed out"); 2587238106Sdes clean_point(rc, s); 2588238106Sdes return 0; 2589238106Sdes } 2590238106Sdes /* (continue to) setup the SSL connection */ 2591238106Sdes ERR_clear_error(); 2592238106Sdes r = SSL_do_handshake(s->ssl); 2593238106Sdes if(r != 1) { 2594238106Sdes int r2 = SSL_get_error(s->ssl, r); 2595238106Sdes if(r2 == SSL_ERROR_WANT_READ) { 2596238106Sdes if(s->shake_state == rc_hs_read) { 2597238106Sdes /* try again later */ 2598238106Sdes return 0; 2599238106Sdes } 2600238106Sdes s->shake_state = rc_hs_read; 2601238106Sdes comm_point_listen_for_rw(c, 1, 0); 2602238106Sdes return 0; 2603238106Sdes } else if(r2 == SSL_ERROR_WANT_WRITE) { 2604238106Sdes if(s->shake_state == rc_hs_write) { 2605238106Sdes /* try again later */ 2606238106Sdes return 0; 2607238106Sdes } 2608238106Sdes s->shake_state = rc_hs_write; 2609238106Sdes comm_point_listen_for_rw(c, 0, 1); 2610238106Sdes return 0; 2611238106Sdes } else { 2612238106Sdes if(r == 0) 2613238106Sdes log_err("remote control connection closed prematurely"); 2614238106Sdes log_addr(1, "failed connection from", 2615238106Sdes &s->c->repinfo.addr, s->c->repinfo.addrlen); 2616238106Sdes log_crypto_err("remote control failed ssl"); 2617238106Sdes clean_point(rc, s); 2618238106Sdes return 0; 2619238106Sdes } 2620238106Sdes } 2621238106Sdes s->shake_state = rc_none; 2622238106Sdes 2623238106Sdes /* once handshake has completed, check authentication */ 2624285206Sdes if (!rc->use_cert) { 2625285206Sdes verbose(VERB_ALGO, "unauthenticated remote control connection"); 2626285206Sdes } else if(SSL_get_verify_result(s->ssl) == X509_V_OK) { 2627238106Sdes X509* x = SSL_get_peer_certificate(s->ssl); 2628238106Sdes if(!x) { 2629238106Sdes verbose(VERB_DETAIL, "remote control connection " 2630238106Sdes "provided no client certificate"); 2631238106Sdes clean_point(rc, s); 2632238106Sdes return 0; 2633238106Sdes } 2634238106Sdes verbose(VERB_ALGO, "remote control connection authenticated"); 2635238106Sdes X509_free(x); 2636238106Sdes } else { 2637238106Sdes verbose(VERB_DETAIL, "remote control connection failed to " 2638238106Sdes "authenticate with client certificate"); 2639238106Sdes clean_point(rc, s); 2640238106Sdes return 0; 2641238106Sdes } 2642238106Sdes 2643238106Sdes /* if OK start to actually handle the request */ 2644238106Sdes handle_req(rc, s, s->ssl); 2645238106Sdes 2646238106Sdes verbose(VERB_ALGO, "remote control operation completed"); 2647238106Sdes clean_point(rc, s); 2648238106Sdes return 0; 2649238106Sdes} 2650