diff options
66 files changed, 15885 insertions, 3040 deletions
diff --git a/usr.sbin/nsd/LICENSE b/usr.sbin/nsd/LICENSE index 955c3665a36..55faacfc49b 100644 --- a/usr.sbin/nsd/LICENSE +++ b/usr.sbin/nsd/LICENSE @@ -1,4 +1,4 @@ -Copyright (c) 2001-2011, NLnet Labs. All rights reserved. +Copyright (c) 2001-2006, NLnet Labs. All rights reserved. This software is open source. diff --git a/usr.sbin/nsd/acx_nlnetlabs.m4 b/usr.sbin/nsd/acx_nlnetlabs.m4 index 719112645aa..e1cf83a70bd 100644 --- a/usr.sbin/nsd/acx_nlnetlabs.m4 +++ b/usr.sbin/nsd/acx_nlnetlabs.m4 @@ -2,7 +2,9 @@ # Copyright 2009, Wouter Wijngaards, NLnet Labs. # BSD licensed. # -# Version 24 +# Version 26 +# 2013-09-19 FLTO help text improved. +# 2013-07-18 Enable ACX_CHECK_COMPILER_FLAG to test for -Wstrict-prototypes # 2013-06-25 FLTO has --disable-flto option. # 2013-05-03 Update W32_SLEEP for newer mingw that links but not defines it. # 2013-03-22 Fix ACX_RSRC_VERSION for long version numbers. @@ -119,7 +121,7 @@ AC_MSG_CHECKING(whether $CC supports -$1) cache=`echo $1 | sed 'y%.=/+-%___p_%'` AC_CACHE_VAL(cv_prog_cc_flag_$cache, [ -echo 'void f(){}' >conftest.c +echo 'void f(void){}' >conftest.c if test -z "`$CC $CPPFLAGS $CFLAGS -$1 -c conftest.c 2>&1`"; then eval "cv_prog_cc_flag_$cache=yes" else @@ -409,7 +411,7 @@ dnl Check if CC supports -flto. dnl in a way that supports clang and suncc (that flag does something else, dnl but fails to link). It sets it in CFLAGS if it works. AC_DEFUN([ACX_CHECK_FLTO], [ - AC_ARG_ENABLE([flto], AS_HELP_STRING([--disable-flto], [Disable link-time optimization])) + AC_ARG_ENABLE([flto], AS_HELP_STRING([--disable-flto], [Disable link-time optimization (gcc specific option)])) AS_IF([test "x$enable_flto" != "xno"], [ AC_MSG_CHECKING([if $CC supports -flto]) BAKCFLAGS="$CFLAGS" diff --git a/usr.sbin/nsd/answer.c b/usr.sbin/nsd/answer.c index 8fa4ab16821..0377f0b5859 100644 --- a/usr.sbin/nsd/answer.c +++ b/usr.sbin/nsd/answer.c @@ -1,7 +1,7 @@ /* * answer.c -- manipulating query answers and encoding them. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * diff --git a/usr.sbin/nsd/answer.h b/usr.sbin/nsd/answer.h index 85d349f438d..acb3665af11 100644 --- a/usr.sbin/nsd/answer.h +++ b/usr.sbin/nsd/answer.h @@ -1,7 +1,7 @@ /* * answer.h -- manipulating query answers and encoding them. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * diff --git a/usr.sbin/nsd/axfr.h b/usr.sbin/nsd/axfr.h index b5d7afc29fd..33a68629523 100644 --- a/usr.sbin/nsd/axfr.h +++ b/usr.sbin/nsd/axfr.h @@ -1,7 +1,7 @@ /* * axfr.h -- generating AXFR responses. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * diff --git a/usr.sbin/nsd/buffer.c b/usr.sbin/nsd/buffer.c index 49151018fa9..d71fa15e3f3 100644 --- a/usr.sbin/nsd/buffer.c +++ b/usr.sbin/nsd/buffer.c @@ -1,7 +1,7 @@ /* * buffer.c -- generic memory buffer . * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * diff --git a/usr.sbin/nsd/buffer.h b/usr.sbin/nsd/buffer.h index 28610fe9310..bee7d8b29eb 100644 --- a/usr.sbin/nsd/buffer.h +++ b/usr.sbin/nsd/buffer.h @@ -1,7 +1,7 @@ /* * buffer.h -- generic memory buffer. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * diff --git a/usr.sbin/nsd/compat/memcmp.c b/usr.sbin/nsd/compat/memcmp.c index 6d3d27ac9e7..371b3d11baf 100644 --- a/usr.sbin/nsd/compat/memcmp.c +++ b/usr.sbin/nsd/compat/memcmp.c @@ -1,7 +1,7 @@ /* - * memcmp.c: memcmp compat implementation. + * memcmp.c: memcmp compat implementation. * - * Copyright (c) 2010-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2010, NLnet Labs. All rights reserved. * * See LICENSE for the license. */ diff --git a/usr.sbin/nsd/compat/memmove.c b/usr.sbin/nsd/compat/memmove.c index fd65a93f84e..f83996684fe 100644 --- a/usr.sbin/nsd/compat/memmove.c +++ b/usr.sbin/nsd/compat/memmove.c @@ -1,7 +1,7 @@ /* - * memmove.c: memmove compat implementation. + * memmove.c: memmove compat implementation. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. */ diff --git a/usr.sbin/nsd/compat/strptime.c b/usr.sbin/nsd/compat/strptime.c index 6986d35ce73..4ec96c12cef 100644 --- a/usr.sbin/nsd/compat/strptime.c +++ b/usr.sbin/nsd/compat/strptime.c @@ -10,7 +10,7 @@ * - Does not properly processes year day * * LICENSE - * Copyright (c) 2008-2011, NLnet Labs, Matthijs Mekking. + * Copyright (c) 2008, NLnet Labs, Matthijs Mekking. * All rights reserved. * * Redistribution and use in source and binary forms, with or without diff --git a/usr.sbin/nsd/configlexer.lex b/usr.sbin/nsd/configlexer.lex index 55bf4cfe62a..ee4ad1522d9 100644 --- a/usr.sbin/nsd/configlexer.lex +++ b/usr.sbin/nsd/configlexer.lex @@ -2,7 +2,7 @@ /* * configlexer.lex - lexical analyzer for NSD config file * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved * * See LICENSE for the license. * @@ -20,8 +20,6 @@ #include "configparser.h" void c_error(const char *message); -#define YY_NO_UNPUT - #if 0 #define LEXOUT(s) printf s /* used ONLY when debugging */ #else @@ -47,6 +45,15 @@ static void config_start_include(const char* filename) c_error_msg("includes nested too deeply, skipped (>%d)", MAXINCLUDES); return; } + if (cfg_parser->chroot) { + int l = strlen(cfg_parser->chroot); /* chroot has trailing slash */ + if (strncmp(cfg_parser->chroot, filename, l) != 0) { + c_error_msg("include file '%s' is not relative to chroot '%s'", + filename, cfg_parser->chroot); + return; + } + filename += l - 1; /* strip chroot without trailing slash */ + } input = fopen(filename, "r"); if(!input) { c_error_msg("cannot open include file '%s': %s", @@ -82,6 +89,16 @@ static void config_end_include(void) #endif %} +%option noinput +%option nounput +%{ +#ifndef YY_NO_UNPUT +#define YY_NO_UNPUT 1 +#endif +#ifndef YY_NO_INPUT +#define YY_NO_INPUT 1 +#endif +%} SPACE [ \t] LETTER [a-zA-Z] @@ -104,6 +121,8 @@ debug-mode{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_DEBUG_MODE;} hide-version{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_HIDE_VERSION;} ip4-only{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_IP4_ONLY;} ip6-only{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_IP6_ONLY;} +do-ip4{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_DO_IP4;} +do-ip6{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_DO_IP6;} database{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_DATABASE;} identity{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_IDENTITY;} nsid{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_NSID;} @@ -117,12 +136,13 @@ ipv6-edns-size{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_IPV6_EDNS_SIZE;} pidfile{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_PIDFILE;} port{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_PORT;} statistics{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_STATISTICS;} -zone-stats-file{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_ZONESTATSFILE;} chroot{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_CHROOT;} username{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_USERNAME;} zonesdir{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_ZONESDIR;} +zonelistfile{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_ZONELISTFILE;} difffile{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_DIFFFILE;} xfrdfile{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_XFRDFILE;} +xfrdir{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_XFRDIR;} xfrd-reload-timeout{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_XFRD_RELOAD_TIMEOUT;} verbosity{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_VERBOSITY;} zone{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_ZONE;} @@ -137,6 +157,16 @@ allow-axfr-fallback{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_ALLOW_AXFR_F key{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_KEY;} algorithm{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_ALGORITHM;} secret{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_SECRET;} +pattern{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_PATTERN;} +include-pattern{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_INCLUDEPATTERN;} +remote-control{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_REMOTE_CONTROL;} +control-enable{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_CONTROL_ENABLE;} +control-interface{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_CONTROL_INTERFACE;} +control-port{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_CONTROL_PORT;} +server-key-file{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_SERVER_KEY_FILE;} +server-cert-file{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_SERVER_CERT_FILE;} +control-key-file{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_CONTROL_KEY_FILE;} +control-cert-file{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_CONTROL_CERT_FILE;} AXFR { LEXOUT(("v(%s) ", yytext)); return VAR_AXFR;} UDP { LEXOUT(("v(%s) ", yytext)); return VAR_UDP;} rrl-size{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_RRL_SIZE;} @@ -146,6 +176,7 @@ rrl-ipv4-prefix-length{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_RRL_IPV4_ rrl-ipv6-prefix-length{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_RRL_IPV6_PREFIX_LENGTH;} rrl-whitelist-ratelimit{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_RRL_WHITELIST_RATELIMIT;} rrl-whitelist{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_RRL_WHITELIST;} +zonefiles-check{COLON} { LEXOUT(("v(%s) ", yytext)); return VAR_ZONEFILES_CHECK;} {NEWLINE} { LEXOUT(("NL\n")); cfg_parser->line++;} /* Quoted strings. Strip leading and ending quotes */ diff --git a/usr.sbin/nsd/configyyrename.h b/usr.sbin/nsd/configyyrename.h index 856dfe96d3e..6beb810aa8e 100644 --- a/usr.sbin/nsd/configyyrename.h +++ b/usr.sbin/nsd/configyyrename.h @@ -1,7 +1,7 @@ /* * configyyrename.h -- renames for config file yy values to avoid conflicts. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -32,6 +32,7 @@ #define yyps c_ps #define yypv c_pv #define yys c_s +#define yyss c_ss #define yy_yys c_yys #define yystate c_state #define yytmp c_tmp @@ -85,5 +86,34 @@ #define yyget_leng c_get_leng #define yylineno c_lineno #define yyget_text c_get_text +#define yyvsp c_vsp +#define yyvs c_vs +#define yytext c_text +#define yyleng c_leng +#define yy_meta c__meta +#define yy_start c__start +#define yy_nxt c__nxt +#define yy_n_chars c__n_chars +#define yy_more_flag c__more_flag +#define yy_more_len c__more_len +#define yy_try_NUL_trans c__try_NUL_trans +#define yy_last_accepting_cpos c__last_accepting_cpos +#define yy_last_accepting_state c__last_accepting_state +#define yy_init c__init +#define yy_base c__base +#define yy_accept c__accept +#define yy_c_buf_p c__c_buf_p +#define yy_chk c__chk +#define yy_current_buffer c__current_buffer +#define yy_def c__def +#define yy_did_buffer_switch_on_eof c__did_buffer_switch_on_eof +#define yy_ec c__ec +#define yy_fatal_error c__fatal_error +#define yy_flex_alloc c__flex_alloc +#define yy_flex_free c__flex_free +#define yy_flex_realloc c__flex_realloc +#define yy_get_next_buffer c__get_next_buffer +#define yy_get_previous_state c__get_previous_state +#define yy_hold_char c__hold_char #endif /* CONFIGYYRENAME_H */ diff --git a/usr.sbin/nsd/dbaccess.c b/usr.sbin/nsd/dbaccess.c index abecce7a1f5..866c762ea70 100644 --- a/usr.sbin/nsd/dbaccess.c +++ b/usr.sbin/nsd/dbaccess.c @@ -1,7 +1,7 @@ /* * dbaccess.c -- access methods for nsd(8) database * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -17,467 +17,569 @@ #include <string.h> #include <unistd.h> #include <fcntl.h> -#include <stdio.h> /* DEBUG */ #include "dns.h" #include "namedb.h" #include "util.h" #include "options.h" +#include "rdata.h" +#include "udb.h" +#include "udbradtree.h" +#include "udbzone.h" +#include "zonec.h" +#include "nsec3.h" +#include "difffile.h" + +static time_t udb_time = 0; +static unsigned udb_rrsets = 0; +static unsigned udb_rrset_count = 0; -int -namedb_lookup(struct namedb *db, - const dname_type *dname, - domain_type **closest_match, - domain_type **closest_encloser) +void +namedb_close(struct namedb* db) { - return domain_table_search( - db->domains, dname, closest_match, closest_encloser); + if(db) { + if(db->udb) { + udb_base_close(db->udb); + udb_base_free(db->udb); + } + zonec_desetup_parser(); + region_destroy(db->region); + } } -static int -read_magic(namedb_type *db) +void +namedb_close_udb(struct namedb* db) { - char buf[NAMEDB_MAGIC_SIZE]; - - if (fread(buf, sizeof(char), sizeof(buf), db->fd) != sizeof(buf)) - return 0; - - return memcmp(buf, NAMEDB_MAGIC, NAMEDB_MAGIC_SIZE) == 0; + if(db) { + /* we cannot actually munmap the data, because other + * processes still need to access the udb, so cleanup the + * udb */ + udb_base_free_keep_mmap(db->udb); + db->udb = NULL; + } } -static const dname_type * -read_dname(FILE *fd, region_type *region) +void +apex_rrset_checks(namedb_type* db, rrset_type* rrset, domain_type* domain) { - uint8_t size; - uint8_t temp[MAXDOMAINLEN]; + uint32_t soa_minimum; + unsigned i; + zone_type* zone = rrset->zone; + assert(domain == zone->apex); + (void)domain; + if (rrset_rrtype(rrset) == TYPE_SOA) { + zone->soa_rrset = rrset; - if (fread(&size, sizeof(uint8_t), 1, fd) != 1) - return NULL; - if (fread(temp, sizeof(uint8_t), size, fd) != size) - return NULL; + /* BUG #103 add another soa with a tweaked ttl */ + if(zone->soa_nx_rrset == 0) { + zone->soa_nx_rrset = region_alloc(db->region, + sizeof(rrset_type)); + zone->soa_nx_rrset->rr_count = 1; + zone->soa_nx_rrset->next = 0; + zone->soa_nx_rrset->zone = zone; + zone->soa_nx_rrset->rrs = region_alloc(db->region, + sizeof(rr_type)); + } + memcpy(zone->soa_nx_rrset->rrs, rrset->rrs, sizeof(rr_type)); - return dname_make(region, temp, 1); + /* check the ttl and MINIMUM value and set accordinly */ + memcpy(&soa_minimum, rdata_atom_data(rrset->rrs->rdatas[6]), + rdata_atom_size(rrset->rrs->rdatas[6])); + if (rrset->rrs->ttl > ntohl(soa_minimum)) { + zone->soa_nx_rrset->rrs[0].ttl = ntohl(soa_minimum); + } + } else if (rrset_rrtype(rrset) == TYPE_NS) { + zone->ns_rrset = rrset; + } else if (rrset_rrtype(rrset) == TYPE_RRSIG) { + for (i = 0; i < rrset->rr_count; ++i) { + if(rr_rrsig_type_covered(&rrset->rrs[i])==TYPE_DNSKEY){ + zone->is_secure = 1; + break; + } + } + } } -static int -read_size(namedb_type *db, uint32_t *result) +/** read rr */ +static void +read_rr(namedb_type* db, rr_type* rr, udb_ptr* urr, domain_type* domain) { - if (fread(result, sizeof(*result), 1, db->fd) == 1) { - *result = ntohl(*result); - return 1; - } else { - return 0; + buffer_type buffer; + ssize_t c; + assert(udb_ptr_get_type(urr) == udb_chunk_type_rr); + rr->owner = domain; + rr->type = RR(urr)->type; + rr->klass = RR(urr)->klass; + rr->ttl = RR(urr)->ttl; + + buffer_create_from(&buffer, RR(urr)->wire, RR(urr)->len); + c = rdata_wireformat_to_rdata_atoms(db->region, db->domains, + rr->type, RR(urr)->len, &buffer, &rr->rdatas); + if(c == -1) { + /* safe on error */ + rr->rdata_count = 0; + rr->rdatas = NULL; + return; } + rr->rdata_count = c; } -static domain_type * -read_domain(namedb_type *db, uint32_t domain_count, domain_type **domains) +/** calculate rr count */ +static uint16_t +calculate_rr_count(udb_base* udb, udb_ptr* rrset) { - uint32_t domain_number; - - if (!read_size(db, &domain_number)) - return NULL; - - if (domain_number == 0 || domain_number > domain_count) - return NULL; - - return domains[domain_number - 1]; + udb_ptr rr; + uint16_t num = 0; + udb_ptr_new(&rr, udb, &RRSET(rrset)->rrs); + while(rr.data) { + num++; + udb_ptr_set_rptr(&rr, udb, &RR(&rr)->next); + } + udb_ptr_unlink(&rr, udb); + return num; } -static zone_type * -read_zone(namedb_type *db, uint32_t zone_count, zone_type **zones) +/** read rrset */ +static void +read_rrset(udb_base* udb, namedb_type* db, zone_type* zone, + domain_type* domain, udb_ptr* urrset) { - uint32_t zone_number; - - if (!read_size(db, &zone_number)) - return NULL; - - if (zone_number == 0 || zone_number > zone_count) - return NULL; - - return zones[zone_number - 1]; + rrset_type* rrset; + udb_ptr urr; + unsigned i; + assert(udb_ptr_get_type(urrset) == udb_chunk_type_rrset); + /* if no RRs, do not create anything (robust) */ + if(RRSET(urrset)->rrs.data == 0) + return; + rrset = (rrset_type *) region_alloc(db->region, sizeof(rrset_type)); + rrset->zone = zone; + rrset->rr_count = calculate_rr_count(udb, urrset); + rrset->rrs = (rr_type *) region_alloc( + db->region, rrset->rr_count * sizeof(rr_type)); + /* add the RRs */ + udb_ptr_new(&urr, udb, &RRSET(urrset)->rrs); + for(i=0; i<rrset->rr_count; i++) { + read_rr(db, &rrset->rrs[i], &urr, domain); + udb_ptr_set_rptr(&urr, udb, &RR(&urr)->next); + } + udb_ptr_unlink(&urr, udb); + domain_add_rrset(domain, rrset); + if(domain == zone->apex) + apex_rrset_checks(db, rrset, domain); } -static int -read_rdata_atom(namedb_type *db, uint16_t type, int index, uint32_t domain_count, domain_type **domains, rdata_atom_type *result) +/** read one elem from db, of type domain_d */ +static void read_node_elem(udb_base* udb, namedb_type* db, + region_type* dname_region, zone_type* zone, struct domain_d* d) { - uint8_t data[65536]; - - if (rdata_atom_is_domain(type, index)) { - result->domain = read_domain(db, domain_count, domains); - if (!result->domain) - return 0; - } else { - uint16_t size; - - if (fread(&size, sizeof(size), 1, db->fd) != 1) - return 0; - size = ntohs(size); - if (fread(data, sizeof(uint8_t), size, db->fd) != size) - return 0; - - result->data = (uint16_t *) region_alloc( - db->region, sizeof(uint16_t) + size); - memcpy(result->data, &size, sizeof(uint16_t)); - memcpy((uint8_t *) result->data + sizeof(uint16_t), data, size); + const dname_type* dname; + domain_type* domain; + udb_ptr urrset; + + dname = dname_make(dname_region, d->name, 0); + if(!dname) return; + domain = domain_table_insert(db->domains, dname); + assert(domain); /* domain_table_insert should always return non-NULL */ + + /* add rrsets */ + udb_ptr_init(&urrset, udb); + udb_ptr_set_rptr(&urrset, udb, &d->rrsets); + while(urrset.data) { + read_rrset(udb, db, zone, domain, &urrset); + udb_ptr_set_rptr(&urrset, udb, &RRSET(&urrset)->next); + + if(++udb_rrsets % ZONEC_PCT_COUNT == 0 && time(NULL) > udb_time + ZONEC_PCT_TIME) { + udb_time = time(NULL); + VERBOSITY(1, (LOG_INFO, "read %s %d %%", + zone->opts->name, udb_rrsets*100/udb_rrset_count)); + } } - - return 1; + region_free_all(dname_region); + udb_ptr_unlink(&urrset, udb); } -static rrset_type * -read_rrset(namedb_type *db, - uint32_t domain_count, domain_type **domains, - uint32_t zone_count, zone_type **zones) +/** recurse read radix from disk. This radix tree is by domain name, so max of + * 256 depth, and thus the stack usage is small. */ +static void read_zone_recurse(udb_base* udb, namedb_type* db, + region_type* dname_region, zone_type* zone, struct udb_radnode_d* node) { - rrset_type *rrset; - int i, j; - domain_type *owner; - uint16_t type; - uint16_t klass; - uint32_t soa_minimum; - - owner = read_domain(db, domain_count, domains); - if (!owner) - return NULL; - - rrset = (rrset_type *) region_alloc(db->region, sizeof(rrset_type)); - - rrset->zone = read_zone(db, zone_count, zones); - if (!rrset->zone) - return NULL; - - if (fread(&type, sizeof(type), 1, db->fd) != 1) - return NULL; - type = ntohs(type); - - if (fread(&klass, sizeof(klass), 1, db->fd) != 1) - return NULL; - klass = ntohs(klass); - - if (fread(&rrset->rr_count, sizeof(rrset->rr_count), 1, db->fd) != 1) - return NULL; - rrset->rr_count = ntohs(rrset->rr_count); - rrset->rrs = (rr_type *) region_alloc( - db->region, rrset->rr_count * sizeof(rr_type)); - - assert(rrset->rr_count > 0); - - for (i = 0; i < rrset->rr_count; ++i) { - rr_type *rr = &rrset->rrs[i]; - - rr->owner = owner; - rr->type = type; - rr->klass = klass; - - if (fread(&rr->rdata_count, sizeof(rr->rdata_count), 1, db->fd) != 1) - return NULL; - rr->rdata_count = ntohs(rr->rdata_count); - rr->rdatas = (rdata_atom_type *) region_alloc( - db->region, rr->rdata_count * sizeof(rdata_atom_type)); - - if (fread(&rr->ttl, sizeof(rr->ttl), 1, db->fd) != 1) - return NULL; - rr->ttl = ntohl(rr->ttl); - - for (j = 0; j < rr->rdata_count; ++j) { - if (!read_rdata_atom(db, rr->type, j, domain_count, domains, &rr->rdatas[j])) - return NULL; + if(node->elem.data) { + /* pre-order process of node->elem, for radix tree this is + * also in-order processing (identical to order tree_next()) */ + read_node_elem(udb, db, dname_region, zone, (struct domain_d*) + (udb->base + node->elem.data)); + } + if(node->lookup.data) { + uint16_t i; + struct udb_radarray_d* a = (struct udb_radarray_d*) + (udb->base + node->lookup.data); + /* we do not care for what the exact radix key is, we want + * to add all of them and the read routine does not need + * the radix-key, it has it stored */ + for(i=0; i<a->len; i++) { + if(a->array[i].node.data) { + read_zone_recurse(udb, db, dname_region, zone, + (struct udb_radnode_d*)(udb->base + + a->array[i].node.data)); + } } } +} - domain_add_rrset(owner, rrset); - - if (rrset_rrtype(rrset) == TYPE_SOA) { - assert(owner == rrset->zone->apex); - rrset->zone->soa_rrset = rrset; - - /* BUG #103 add another soa with a tweaked ttl */ - rrset->zone->soa_nx_rrset = region_alloc(db->region, sizeof(rrset_type)); - rrset->zone->soa_nx_rrset->rrs = - region_alloc(db->region, rrset->rr_count * sizeof(rr_type)); - - memcpy(rrset->zone->soa_nx_rrset->rrs, rrset->rrs, sizeof(rr_type)); - rrset->zone->soa_nx_rrset->rr_count = 1; - rrset->zone->soa_nx_rrset->next = 0; +/** read zone data */ +static void +read_zone_data(udb_base* udb, namedb_type* db, region_type* dname_region, + udb_ptr* z, zone_type* zone) +{ + udb_ptr dtree; + /* recursively read domains, we only read so ptrs stay valid */ + udb_ptr_new(&dtree, udb, &ZONE(z)->domains); + if(RADTREE(&dtree)->root.data) + read_zone_recurse(udb, db, dname_region, zone, + (struct udb_radnode_d*) + (udb->base + RADTREE(&dtree)->root.data)); + udb_ptr_unlink(&dtree, udb); +} - /* also add a link to the zone */ - rrset->zone->soa_nx_rrset->zone = rrset->zone; +/** create a zone */ +zone_type* +namedb_zone_create(namedb_type* db, const dname_type* dname, + zone_options_t* zo) +{ + zone_type* zone = (zone_type *) region_alloc(db->region, + sizeof(zone_type)); + zone->node = radname_insert(db->zonetree, dname_name(dname), + dname->name_size, zone); + assert(zone->node); + zone->apex = domain_table_insert(db->domains, dname); + zone->apex->usage++; /* the zone.apex reference */ + zone->apex->is_apex = 1; + zone->soa_rrset = NULL; + zone->soa_nx_rrset = NULL; + zone->ns_rrset = NULL; +#ifdef NSEC3 + zone->nsec3_param = NULL; + zone->nsec3_last = NULL; + zone->nsec3tree = NULL; + zone->hashtree = NULL; + zone->wchashtree = NULL; + zone->dshashtree = NULL; +#endif + zone->opts = zo; + zone->is_secure = 0; + zone->is_changed = 0; + zone->is_ok = 1; + return zone; +} - /* check the ttl and MINIMUM value and set accordinly */ - memcpy(&soa_minimum, rdata_atom_data(rrset->rrs->rdatas[6]), - rdata_atom_size(rrset->rrs->rdatas[6])); - if (rrset->rrs->ttl > ntohl(soa_minimum)) { - rrset->zone->soa_nx_rrset->rrs[0].ttl = ntohl(soa_minimum); +void +namedb_zone_delete(namedb_type* db, zone_type* zone) +{ + /* RRs and UDB and NSEC3 and so on must be already deleted */ + radix_delete(db->zonetree, zone->node); + + /* see if apex can be deleted */ + if(zone->apex) { + zone->apex->usage --; + if(zone->apex->usage == 0) { + /* delete the apex, possibly */ + domain_table_deldomain(db, zone->apex); } - owner->has_SOA = 1; + } - } else if (owner == rrset->zone->apex - && rrset_rrtype(rrset) == TYPE_NS) - { - rrset->zone->ns_rrset = rrset; + /* soa_rrset is freed when the SOA was deleted */ + if(zone->soa_nx_rrset) { + region_recycle(db->region, zone->soa_nx_rrset->rrs, + sizeof(rr_type)); + region_recycle(db->region, zone->soa_nx_rrset, + sizeof(rrset_type)); } #ifdef NSEC3 -#ifndef FULL_PREHASH - else if (type == TYPE_NSEC3) { - if (0 != namedb_add_nsec3_domain(db, owner, rrset->zone)) { - return NULL; - } - } -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ - if (rrset_rrtype(rrset) == TYPE_RRSIG && owner == rrset->zone->apex) { - for (i = 0; i < rrset->rr_count; ++i) { - if (rr_rrsig_type_covered(&rrset->rrs[i]) == TYPE_DNSKEY) { - rrset->zone->is_secure = 1; - break; - } - } + hash_tree_delete(db->region, zone->nsec3tree); + hash_tree_delete(db->region, zone->hashtree); + hash_tree_delete(db->region, zone->wchashtree); + hash_tree_delete(db->region, zone->dshashtree); +#endif + region_recycle(db->region, zone, sizeof(zone_type)); +} + +/** read a zone */ +static void +read_zone(udb_base* udb, namedb_type* db, nsd_options_t* opt, + region_type* dname_region, udb_ptr* z) +{ + /* construct dname */ + const dname_type* dname = dname_make(dname_region, ZONE(z)->name, 0); + zone_options_t* zo = dname?zone_options_find(opt, dname):NULL; + zone_type* zone; + if(!dname) return; + if(!zo) { + /* deleted from the options, remove it from the nsd.db too */ + VERBOSITY(2, (LOG_WARNING, "zone %s is deleted", + dname_to_string(dname, NULL))); + udb_zone_delete(udb, z); + region_free_all(dname_region); + return; } - return rrset; + assert(udb_ptr_get_type(z) == udb_chunk_type_zone); + udb_rrsets = 0; + udb_rrset_count = ZONE(z)->rrset_count; + zone = namedb_zone_create(db, dname, zo); + region_free_all(dname_region); + read_zone_data(udb, db, dname_region, z, zone); + zone->is_changed = (ZONE(z)->is_changed != 0); +#ifdef NSEC3 + prehash_zone_complete(db, zone); +#endif } -struct namedb * -namedb_open (const char *filename, nsd_options_t* opt, size_t num_children) +/** read zones from nsd.db */ +static void +read_zones(udb_base* udb, namedb_type* db, nsd_options_t* opt, + region_type* dname_region) { - namedb_type *db; + udb_ptr ztree, n, z; + udb_ptr_init(&z, udb); + udb_ptr_new(&ztree, udb, udb_base_get_userdata(udb)); + udb_radix_first(udb,&ztree,&n); + udb_time = time(NULL); + while(n.data) { + udb_ptr_set_rptr(&z, udb, &RADNODE(&n)->elem); + udb_radix_next(udb, &n); /* store in case n is deleted */ + read_zone(udb, db, opt, dname_region, &z); + udb_ptr_zero(&z, udb); + } + udb_ptr_unlink(&ztree, udb); + udb_ptr_unlink(&n, udb); + udb_ptr_unlink(&z, udb); +} +/** try to read the udb file or fail */ +static int +try_read_udb(namedb_type* db, int fd, const char* filename, + nsd_options_t* opt) +{ /* * Temporary region used while loading domain names from the * database. The region is freed after each time a dname is * read from the database. */ - region_type *dname_region; + region_type* dname_region; + + assert(fd != -1); + if(!(db->udb=udb_base_create_fd(filename, fd, &namedb_walkfunc, + NULL))) { + /* fd is closed by failed udb create call */ + VERBOSITY(1, (LOG_WARNING, "can not use %s, " + "will create anew", filename)); + return 0; + } + /* sanity check if can be opened */ + if(udb_base_get_userflags(db->udb) != 0) { + log_msg(LOG_WARNING, "%s was not closed properly, it might " + "be corrupted, will create anew", filename); + udb_base_free(db->udb); + db->udb = NULL; + return 0; + } + /* read if it can be opened */ + dname_region = region_create(xalloc, free); + /* this operation does not fail, we end up with + * something, even if that is an empty namedb */ + read_zones(db->udb, db, opt, dname_region); + region_destroy(dname_region); + return 1; +} + +struct namedb * +namedb_open (const char* filename, nsd_options_t* opt) +{ + namedb_type* db; /* - * Temporary region used to store array of domains and zones - * while loading the database. The region is freed before - * returning. + * Region used to store the loaded database. The region is + * freed in namedb_close. */ - region_type *temp_region; - - uint32_t dname_count; - domain_type **domains; /* Indexed by domain number. */ - - uint32_t zone_count; - zone_type **zones; /* Indexed by zone number. */ - - uint32_t i; - uint32_t rrset_count = 0; - uint32_t rr_count = 0; - - rrset_type *rrset; - - DEBUG(DEBUG_DBACCESS, 2, - (LOG_INFO, "sizeof(namedb_type) = %lu\n", (unsigned long) sizeof(namedb_type))); - DEBUG(DEBUG_DBACCESS, 2, - (LOG_INFO, "sizeof(zone_type) = %lu\n", (unsigned long) sizeof(zone_type))); - DEBUG(DEBUG_DBACCESS, 2, - (LOG_INFO, "sizeof(domain_type) = %lu\n", (unsigned long) sizeof(domain_type))); - DEBUG(DEBUG_DBACCESS, 2, - (LOG_INFO, "sizeof(rrset_type) = %lu\n", (unsigned long) sizeof(rrset_type))); - DEBUG(DEBUG_DBACCESS, 2, - (LOG_INFO, "sizeof(rr_type) = %lu\n", (unsigned long) sizeof(rr_type))); - DEBUG(DEBUG_DBACCESS, 2, - (LOG_INFO, "sizeof(rdata_atom_type) = %lu\n", (unsigned long) sizeof(rdata_atom_type))); - DEBUG(DEBUG_DBACCESS, 2, - (LOG_INFO, "sizeof(rbnode_t) = %lu\n", (unsigned long) sizeof(rbnode_t))); - - if ((db = namedb_create()) == NULL) { - log_msg(LOG_ERR, - "insufficient memory to create database"); - return NULL; + region_type* db_region; + int fd; + + /* attempt to open, if does not exist, create a new one */ + fd = open(filename, O_RDWR); + if(fd == -1) { + if(errno != ENOENT) { + log_msg(LOG_ERR, "%s: %s", filename, strerror(errno)); + return NULL; + } } - db->filename = region_strdup(db->region, filename); + +#ifdef USE_MMAP_ALLOC + db_region = region_create_custom(mmap_alloc, mmap_free, MMAP_ALLOC_CHUNK_SIZE, + MMAP_ALLOC_LARGE_OBJECT_SIZE, MMAP_ALLOC_INITIAL_CLEANUP_SIZE, 1); +#else /* !USE_MMAP_ALLOC */ + db_region = region_create_custom(xalloc, free, DEFAULT_CHUNK_SIZE, + DEFAULT_LARGE_OBJECT_SIZE, DEFAULT_INITIAL_CLEANUP_SIZE, 1); +#endif /* !USE_MMAP_ALLOC */ + db = (namedb_type *) region_alloc(db_region, sizeof(struct namedb)); + db->region = db_region; + db->domains = domain_table_create(db->region); + db->zonetree = radix_tree_create(db->region); + db->diff_skip = 0; + db->diff_pos = 0; if (gettimeofday(&(db->diff_timestamp), NULL) != 0) { log_msg(LOG_ERR, "unable to load %s: cannot initialize" - "timestamp", db->filename); - namedb_destroy(db); - return NULL; - } - - /* Open it... */ - db->fd = fopen(db->filename, "r"); - if (db->fd == NULL) { - log_msg(LOG_ERR, "unable to load %s: %s", - db->filename, strerror(errno)); - namedb_destroy(db); - return NULL; - } - - if (!read_magic(db)) { - log_msg(LOG_ERR, "corrupted database (read magic): %s", db->filename); - log_msg(LOG_ERR, "cannot load database, incompatible version " - "number. Please rebuild database and " - "start again."); - namedb_close(db); + "timestamp", filename); + region_destroy(db_region); + close(fd); return NULL; - } + } - if (!read_size(db, &zone_count)) { - log_msg(LOG_ERR, "corrupted database (read size): %s", db->filename); - namedb_close(db); - return NULL; + /* attempt to read the file (if it exists) */ + if(fd != -1) { + if(!try_read_udb(db, fd, filename, opt)) + fd = -1; } - - DEBUG(DEBUG_DBACCESS, 1, - (LOG_INFO, "Retrieving %lu zones\n", (unsigned long) zone_count)); - - temp_region = region_create(xalloc, free); - dname_region = region_create(xalloc, free); - - db->zone_count = zone_count; - zones = (zone_type **) region_alloc(temp_region, - zone_count * sizeof(zone_type *)); - for (i = 0; i < zone_count; ++i) { - const dname_type *dname = read_dname(db->fd, dname_region); - if (!dname) { - log_msg(LOG_ERR, "corrupted database (read dname): %s", db->filename); - region_destroy(dname_region); - region_destroy(temp_region); - namedb_close(db); - return NULL; - } - zones[i] = (zone_type *) region_alloc(db->region, - sizeof(zone_type)); - zones[i]->next = db->zones; - db->zones = zones[i]; - zones[i]->apex = domain_table_insert(db->domains, dname); - zones[i]->soa_rrset = NULL; - zones[i]->soa_nx_rrset = NULL; - zones[i]->ns_rrset = NULL; -#ifdef NSEC3 - zones[i]->nsec3_soa_rr = NULL; - zones[i]->nsec3_last = NULL; -#endif - zones[i]->opts = zone_options_find(opt, domain_dname(zones[i]->apex)); - zones[i]->number = i + 1; - zones[i]->is_secure = 0; - zones[i]->updated = 1; - zones[i]->is_ok = 0; - zones[i]->dirty = region_alloc(db->region, sizeof(uint8_t)*num_children); - memset(zones[i]->dirty, 0, sizeof(uint8_t)*num_children); - if(!zones[i]->opts) { - log_msg(LOG_ERR, "cannot load database. Zone %s in db " - "%s, but not in config file (might " - "happen if you edited the config " - "file). Please rebuild database and " - "start again.", - dname_to_string(dname, NULL), db->filename); - region_destroy(dname_region); - region_destroy(temp_region); - namedb_close(db); + /* attempt to create the file (if necessary or failed read) */ + if(fd == -1) { + if(!(db->udb=udb_base_create_new(filename, &namedb_walkfunc, + NULL))) { + region_destroy(db_region); return NULL; } -#ifdef NSEC3 -#ifndef FULL_PREHASH - zones[i]->nsec3_domains = NULL; - if (0 != zone_nsec3_domains_create(db, zones[i])) { - log_msg(LOG_ERR, - "insufficient memory for NSEC3 tree, " - "unable to read database"); - region_destroy(dname_region); - region_destroy(temp_region); - namedb_close(db); + if(!udb_dns_init_file(db->udb)) { + region_destroy(db->region); return NULL; } -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ - region_free_all(dname_region); } + zonec_setup_parser(db); + return db; +} - if (!read_size(db, &dname_count)) { - log_msg(LOG_ERR, "corrupted database (read size): %s", db->filename); - region_destroy(dname_region); - region_destroy(temp_region); - namedb_close(db); - return NULL; +/** the the file mtime stat (or nonexist or error) */ +static int +file_get_mtime(const char* file, time_t* mtime, int* nonexist) +{ + struct stat s; + if(stat(file, &s) != 0) { + *mtime = 0; + *nonexist = (errno == ENOENT); + return 0; } + *nonexist = 0; + *mtime = s.st_mtime; + return 1; +} - DEBUG(DEBUG_DBACCESS, 1, - (LOG_INFO, "Retrieving %lu domain names\n", (unsigned long) dname_count)); - - domains = (domain_type **) region_alloc( - temp_region, dname_count * sizeof(domain_type *)); - for (i = 0; i < dname_count; ++i) { - const dname_type *dname = read_dname(db->fd, dname_region); - if (!dname) { - log_msg(LOG_ERR, "corrupted database (read dname): %s", db->filename); - region_destroy(dname_region); - region_destroy(temp_region); - namedb_close(db); - return NULL; +void +namedb_read_zonefile(struct namedb* db, struct zone* zone, udb_base* taskudb, + udb_ptr* last_task) +{ + time_t mtime = 0; + int nonexist = 0; + unsigned int errors; + const char* fname; + if(!db || !db->udb || !zone || !zone->opts || !zone->opts->pattern->zonefile) + return; + fname = config_make_zonefile(zone->opts); + if(!file_get_mtime(fname, &mtime, &nonexist)) { + if(nonexist) { + VERBOSITY(2, (LOG_INFO, "zonefile %s does not exist", + fname)); + } else + log_msg(LOG_ERR, "zonefile %s: %s", + fname, strerror(errno)); + if(taskudb) task_new_soainfo(taskudb, last_task, zone); + return; + } else { + /* check the mtime */ + if(udb_zone_get_mtime(db->udb, dname_name(domain_dname( + zone->apex)), domain_dname(zone->apex)->name_size) + >= (uint64_t)mtime) { + VERBOSITY(3, (LOG_INFO, "zonefile %s is not modified", + fname)); + return; } - domains[i] = domain_table_insert(db->domains, dname); - region_free_all(dname_region); } - region_destroy(dname_region); - -#ifndef NDEBUG - fprintf(stderr, "database region after loading domain names: "); - region_dump_stats(db->region, stderr); - fprintf(stderr, "\n"); + assert(parser); + /* wipe zone from memory */ +#ifdef NSEC3 + nsec3_hash_tree_clear(zone); #endif - - while ((rrset = read_rrset(db, dname_count, domains, zone_count, zones))) { - ++rrset_count; - rr_count += rrset->rr_count; - } - - DEBUG(DEBUG_DBACCESS, 1, - (LOG_INFO, "Retrieved %lu RRs in %lu RRsets\n", - (unsigned long) rr_count, (unsigned long) rrset_count)); - - region_destroy(temp_region); - - if ((db->crc_pos = ftello(db->fd)) == -1) { - log_msg(LOG_ERR, "ftello %s failed: %s", - db->filename, strerror(errno)); - namedb_close(db); - return NULL; - } - if (!read_size(db, &db->crc)) { - log_msg(LOG_ERR, "corrupted database (read size): %s", db->filename); - namedb_close(db); - return NULL; - } - if (!read_magic(db)) { - log_msg(LOG_ERR, "corrupted database (read magic): %s", db->filename); - log_msg(LOG_ERR, "cannot load database, incompatible version " - "number. Please rebuild database and " - "start again."); - namedb_close(db); - return NULL; + delete_zone_rrs(db, zone); +#ifdef NSEC3 + nsec3_clear_precompile(db, zone); + zone->nsec3_param = NULL; +#endif /* NSEC3 */ + errors = zonec_read(zone->opts->name, fname, zone); + if(errors > 0) { + region_type* dname_region; + udb_ptr z; + log_msg(LOG_ERR, "zone %s file %s read with %u errors", + zone->opts->name, fname, errors); + /* wipe (partial) zone from memory */ + zone->is_ok = 1; +#ifdef NSEC3 + nsec3_hash_tree_clear(zone); +#endif + delete_zone_rrs(db, zone); +#ifdef NSEC3 + nsec3_clear_precompile(db, zone); + zone->nsec3_param = NULL; +#endif /* NSEC3 */ + /* see if we can revert to the udb stored version */ + if(!udb_zone_search(db->udb, &z, dname_name(domain_dname( + zone->apex)), domain_dname(zone->apex)->name_size)) { + /* tell that zone contents has been lost */ + if(taskudb) task_new_soainfo(taskudb, last_task, zone); + return; + } + /* read from udb */ + dname_region = region_create(xalloc, free); + udb_rrsets = 0; + udb_rrset_count = ZONE(&z)->rrset_count; + udb_time = time(NULL); + read_zone_data(db->udb, db, dname_region, &z, zone); + region_destroy(dname_region); + udb_ptr_unlink(&z, db->udb); + } else { + VERBOSITY(1, (LOG_INFO, "zone %s read with no errors", + zone->opts->name)); + zone->is_ok = 1; + zone->is_changed = 0; + /* store zone into udb */ + if(!write_zone_to_udb(db->udb, zone, mtime)) { + log_msg(LOG_ERR, "failed to store zone in db"); + } else { + VERBOSITY(2, (LOG_INFO, "zone %s written to db", + zone->opts->name)); + } } - - fclose(db->fd); - db->fd = NULL; - -#ifndef NDEBUG - fprintf(stderr, "database region after loading database: "); - region_dump_stats(db->region, stderr); - fprintf(stderr, "\n"); + if(taskudb) task_new_soainfo(taskudb, last_task, zone); +#ifdef NSEC3 + prehash_zone_complete(db, zone); #endif - - return db; } -void -namedb_close (struct namedb *db) +void namedb_check_zonefile(struct namedb* db, udb_base* taskudb, + udb_ptr* last_task, zone_options_t* zopt) { - namedb_fd_close(db); - if (db) { - namedb_destroy(db); + zone_type* zone; + const dname_type* dname = (const dname_type*)zopt->node.key; + /* find zone to go with it, or create it */ + zone = namedb_find_zone(db, dname); + if(!zone) { + zone = namedb_zone_create(db, dname, zopt); } + namedb_read_zonefile(db, zone, taskudb, last_task); } -void -namedb_fd_close (struct namedb *db) +void namedb_check_zonefiles(struct namedb* db, nsd_options_t* opt, + udb_base* taskudb, udb_ptr* last_task) { - if (db && db->fd) { - fclose(db->fd); + zone_options_t* zo; + /* check all zones in opt, create if not exist in main db */ + RBTREE_FOR(zo, zone_options_t*, opt->zone_options) { + namedb_check_zonefile(db, taskudb, last_task, zo); } } - diff --git a/usr.sbin/nsd/dbcreate.c b/usr.sbin/nsd/dbcreate.c index f193792debb..f0fbb112784 100644 --- a/usr.sbin/nsd/dbcreate.c +++ b/usr.sbin/nsd/dbcreate.c @@ -1,7 +1,7 @@ /* * dbcreate.c -- routines to create an nsd(8) name database * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -9,6 +9,7 @@ #include "config.h" +#include <sys/stat.h> #include <sys/types.h> #include <errno.h> #include <fcntl.h> @@ -17,266 +18,362 @@ #include <unistd.h> #include "namedb.h" +#include "udb.h" +#include "udbradtree.h" +#include "udbzone.h" +#include "options.h" -static int write_db (namedb_type *db); -static int write_number(struct namedb *db, uint32_t number); +/* pathname directory separator character */ +#define PATHSEP '/' -struct namedb * -namedb_new (const char *filename) +/** add an rdata (uncompressed) to the destination */ +static size_t +add_rdata(rr_type* rr, unsigned i, uint8_t* buf, size_t buflen) { - namedb_type *db; - /* Make a new structure... */ - if ((db = namedb_create()) == NULL) { - log_msg(LOG_ERR, - "insufficient memory to create database"); - return NULL; - } - db->filename = region_strdup(db->region, filename); - db->crc = 0xffffffff; - db->diff_skip = 0; - db->fd = NULL; - - if (gettimeofday(&(db->diff_timestamp), NULL) != 0) { - log_msg(LOG_ERR, "unable to load %s: cannot initialize " - "timestamp", db->filename); - namedb_destroy(db); - return NULL; - } - - /* - * Unlink the old database, if it exists. This is useful to - * ensure that NSD doesn't see the changes until a reload is done. - */ - if (unlink(db->filename) == -1 && errno != ENOENT) { - namedb_destroy(db); - return NULL; - } - - /* Create the database */ - if ((db->fd = fopen(db->filename, "w")) == NULL) { - namedb_destroy(db); - return NULL; - } - - if (!write_data_crc(db->fd, NAMEDB_MAGIC, NAMEDB_MAGIC_SIZE, &db->crc)) { - fclose(db->fd); - namedb_discard(db); - return NULL; + switch(rdata_atom_wireformat_type(rr->type, i)) { + case RDATA_WF_COMPRESSED_DNAME: + case RDATA_WF_UNCOMPRESSED_DNAME: + { + const dname_type* dname = domain_dname( + rdata_atom_domain(rr->rdatas[i])); + if(dname->name_size > buflen) + return 0; + memmove(buf, dname_name(dname), dname->name_size); + return dname->name_size; + } + default: + break; } - - return db; + memmove(buf, rdata_atom_data(rr->rdatas[i]), + rdata_atom_size(rr->rdatas[i])); + return rdata_atom_size(rr->rdatas[i]); } - -int -namedb_save (struct namedb *db) +/* marshal rdata into buffer, must be MAX_RDLENGTH in size */ +size_t +rr_marshal_rdata(rr_type* rr, uint8_t* rdata, size_t sz) { - if (write_db(db) != 0) { - return -1; - } - - /* Finish up and write the crc */ - if (!write_number(db, ~db->crc)) { - fclose(db->fd); - return -1; + size_t len = 0; + unsigned i; + assert(rr); + for(i=0; i<rr->rdata_count; i++) { + len += add_rdata(rr, i, rdata+len, sz-len); } - - /* Write the magic... */ - if (!write_data_crc(db->fd, NAMEDB_MAGIC, NAMEDB_MAGIC_SIZE, &db->crc)) { - fclose(db->fd); - return -1; - } - - /* Close the database */ - fclose(db->fd); - namedb_destroy(db); - return 0; + return len; } - +/** delete an RR */ void -namedb_discard (struct namedb *db) +udb_del_rr(udb_base* udb, udb_ptr* z, rr_type* rr) { - unlink(db->filename); - namedb_destroy(db); + /* marshal the rdata (uncompressed) into a buffer */ + uint8_t rdata[MAX_RDLENGTH]; + size_t rdatalen = rr_marshal_rdata(rr, rdata, sizeof(rdata)); + assert(udb); + udb_zone_del_rr(udb, z, dname_name(domain_dname(rr->owner)), + domain_dname(rr->owner)->name_size, rr->type, rr->klass, + rdata, rdatalen); } -static int -write_dname(struct namedb *db, domain_type *domain) +/** write rr */ +int +udb_write_rr(udb_base* udb, udb_ptr* z, rr_type* rr) { - const dname_type *dname = domain_dname(domain); - - if (!write_data_crc(db->fd, &dname->name_size, sizeof(dname->name_size), &db->crc)) - return -1; - - if (!write_data_crc(db->fd, dname_name(dname), dname->name_size, &db->crc)) - return -1; - - return 0; + /* marshal the rdata (uncompressed) into a buffer */ + uint8_t rdata[MAX_RDLENGTH]; + size_t rdatalen = 0; + unsigned i; + assert(rr); + for(i=0; i<rr->rdata_count; i++) { + rdatalen += add_rdata(rr, i, rdata+rdatalen, + sizeof(rdata)-rdatalen); + } + assert(udb); + return udb_zone_add_rr(udb, z, dname_name(domain_dname(rr->owner)), + domain_dname(rr->owner)->name_size, rr->type, rr->klass, + rr->ttl, rdata, rdatalen); } +/** write rrset */ static int -write_number(struct namedb *db, uint32_t number) +write_rrset(udb_base* udb, udb_ptr* z, rrset_type* rrset) { - number = htonl(number); - return write_data_crc(db->fd, &number, sizeof(number), &db->crc); + unsigned i; + for(i=0; i<rrset->rr_count; i++) { + if(!udb_write_rr(udb, z, &rrset->rrs[i])) + return 0; + } + return 1; } +/** write a zone */ static int -write_rrset(struct namedb *db, domain_type *domain, rrset_type *rrset) +write_zone(udb_base* udb, udb_ptr* z, zone_type* zone) { - uint16_t rr_count; - int i, j; - uint16_t type; - uint16_t klass; - - assert(db); - assert(domain); - assert(rrset); - - rr_count = htons(rrset->rr_count); - - if (!write_number(db, domain->number)) - return 1; - - if (!write_number(db, rrset->zone->number)) - return 1; - - type = htons(rrset_rrtype(rrset)); - if (!write_data_crc(db->fd, &type, sizeof(type), &db->crc)) - return 1; - - klass = htons(rrset_rrclass(rrset)); - if (!write_data_crc(db->fd, &klass, sizeof(klass), &db->crc)) - return 1; - - if (!write_data_crc(db->fd, &rr_count, sizeof(rr_count), &db->crc)) - return 1; - - for (i = 0; i < rrset->rr_count; ++i) { - rr_type *rr = &rrset->rrs[i]; - uint32_t ttl; - uint16_t rdata_count; - - rdata_count = htons(rr->rdata_count); - if (!write_data_crc(db->fd, &rdata_count, sizeof(rdata_count), &db->crc)) - return 1; - - ttl = htonl(rr->ttl); - if (!write_data_crc(db->fd, &ttl, sizeof(ttl), &db->crc)) - return 1; - - for (j = 0; j < rr->rdata_count; ++j) { - rdata_atom_type atom = rr->rdatas[j]; - if (rdata_atom_is_domain(rr->type, j)) { - if (!write_number(db, rdata_atom_domain(atom)->number)) - return 1; - - } else { - uint16_t size = htons(rdata_atom_size(atom)); - if (!write_data_crc(db->fd, &size, sizeof(size), &db->crc)) - return 1; - - if (!write_data_crc(db->fd, - rdata_atom_data(atom), - rdata_atom_size(atom), &db->crc)) - return 1; - + /* write all domains in the zone */ + domain_type* walk; + rrset_type* rrset; + int n = 0, c = 0; + time_t t = time(NULL); + + /* count domains: for pct logging */ + for(walk=zone->apex; walk && domain_is_subdomain(walk, zone->apex); + walk=domain_next(walk)) { + n++; + } + /* write them */ + for(walk=zone->apex; walk && domain_is_subdomain(walk, zone->apex); + walk=domain_next(walk)) { + /* write all rrsets (in the zone) for this domain */ + for(rrset=walk->rrsets; rrset; rrset=rrset->next) { + if(rrset->zone == zone) { + if(!write_rrset(udb, z, rrset)) + return 0; } } + /* only check every ... domains, and print pct */ + if(++c % ZONEC_PCT_COUNT == 0 && time(NULL) > t + ZONEC_PCT_TIME) { + t = time(NULL); + VERBOSITY(1, (LOG_INFO, "write %s %d %%", + zone->opts->name, c*100/n)); + } } + return 1; +} - return 0; +/** create and write a zone */ +int +write_zone_to_udb(udb_base* udb, zone_type* zone, time_t mtime) +{ + udb_ptr z; + /* make udb dirty */ + udb_base_set_userflags(udb, 1); + /* find or create zone */ + if(udb_zone_search(udb, &z, dname_name(domain_dname(zone->apex)), + domain_dname(zone->apex)->name_size)) { + /* wipe existing contents */ + udb_zone_clear(udb, &z); + } else { + if(!udb_zone_create(udb, &z, dname_name(domain_dname( + zone->apex)), domain_dname(zone->apex)->name_size)) { + udb_base_set_userflags(udb, 0); + return 0; + } + } + /* set mtime */ + ZONE(&z)->mtime = (uint64_t)mtime; + ZONE(&z)->is_changed = 0; + udb_zone_set_log_str(udb, &z, NULL); + /* write zone */ + if(!write_zone(udb, &z, zone)) { + udb_base_set_userflags(udb, 0); + return 0; + } + udb_ptr_unlink(&z, udb); + udb_base_set_userflags(udb, 0); + return 1; } static int -number_dnames_iterator(domain_type *node, void *user_data) +print_rrs(FILE* out, struct zone* zone) { - uint32_t *current_number = (uint32_t *) user_data; - - node->number = *current_number; - ++*current_number; - - return 0; + rrset_type *rrset; + domain_type *domain = zone->apex; + region_type* region = region_create(xalloc, free); + struct state_pretty_rr* state = create_pretty_rr(region); + /* first print the SOA record for the zone */ + if(zone->soa_rrset) { + size_t i; + for(i=0; i < zone->soa_rrset->rr_count; i++) { + if(!print_rr(out, state, &zone->soa_rrset->rrs[i])){ + log_msg(LOG_ERR, "There was an error " + "printing SOARR to zone %s", + zone->opts->name); + region_destroy(region); + return 0; + } + } + } + /* go through entire tree below the zone apex (incl subzones) */ + while(domain && domain_is_subdomain(domain, zone->apex)) + { + for(rrset = domain->rrsets; rrset; rrset=rrset->next) + { + size_t i; + if(rrset->zone != zone || rrset == zone->soa_rrset) + continue; + for(i=0; i < rrset->rr_count; i++) { + if(!print_rr(out, state, &rrset->rrs[i])){ + log_msg(LOG_ERR, "There was an error " + "printing RR to zone %s", + zone->opts->name); + region_destroy(region); + return 0; + } + } + } + domain = domain_next(domain); + } + region_destroy(region); + return 1; } static int -write_dname_iterator(domain_type *node, void *user_data) +print_header(zone_type* zone, FILE* out, time_t* now, const char* logs) { - namedb_type *db = (namedb_type *) user_data; - - return write_dname(db, node); + char buf[4096]; + /* ctime prints newline at end of this line */ + snprintf(buf, sizeof(buf), "; zone %s written by NSD %s on %s", + zone->opts->name, PACKAGE_VERSION, ctime(now)); + if(!write_data(out, buf, strlen(buf))) + return 0; + if(!logs || logs[0] == 0) return 1; + snprintf(buf, sizeof(buf), "; %s\n", logs); + return write_data(out, buf, strlen(buf)); } static int -write_domain_iterator(domain_type *node, void *user_data) +write_to_zonefile(zone_type* zone, const char* filename, const char* logs) { - namedb_type *db = (namedb_type *) user_data; - rrset_type *rrset; - int error = 0; - - for (rrset = node->rrsets; rrset; rrset = rrset->next) { - error += write_rrset(db, node, rrset); + time_t now = time(0); + FILE *out; + VERBOSITY(1, (LOG_INFO, "writing zone %s to file %s", + zone->opts->name, filename)); + + out = fopen(filename, "w"); + if(!out) { + log_msg(LOG_ERR, "cannot write zone %s file %s: %s", + zone->opts->name, filename, strerror(errno)); + return 0; + } + if(!print_header(zone, out, &now, logs)) { + fclose(out); + log_msg(LOG_ERR, "There was an error printing " + "the header to zone %s", zone->opts->name); + return 0; + } + if(!print_rrs(out, zone)) { + fclose(out); + return 0; } + fclose(out); + return 1; +} - return error; +/** create directories above this file, .../dir/dir/dir/file */ +int +create_dirs(const char* path) +{ + char dir[4096]; + char* p; + strlcpy(dir, path, sizeof(dir)); + /* if we start with / then do not try to create '' */ + if(dir[0] == PATHSEP) + p = strchr(dir+1, PATHSEP); + else p = strchr(dir, PATHSEP); + /* create each directory component from the left */ + while(p) { + assert(*p == PATHSEP); + *p = 0; /* end the directory name here */ + if(mkdir(dir +#ifndef MKDIR_HAS_ONE_ARG + , 0750 +#endif + ) == -1) { + if(errno != EEXIST) { + log_msg(LOG_ERR, "create dir %s: %s", + dir, strerror(errno)); + return 0; + } + /* it already exists, OK, continue */ + } + *p = PATHSEP; + p = strchr(p+1, PATHSEP); + } + return 1; } -/* - * Writes databse data into open database *db - * - * Returns zero if success. - */ +/** create pathname components and check if file exists */ static int -write_db(namedb_type *db) +create_path_components(const char* path, int* notexist) { - zone_type *zone; - uint32_t terminator = 0; - uint32_t dname_count = 1; - uint32_t zone_count = 1; - int errors = 0; - - for (zone = db->zones; zone; zone = zone->next) { - zone->number = zone_count; - ++zone_count; - - if (!zone->soa_rrset) { - fprintf(stderr, "SOA record not present in %s\n", - dname_to_string(domain_dname(zone->apex), - NULL)); - ++errors; + /* stat the file, to see if it exists, and if its directories exist */ + struct stat s; + if(stat(path, &s) != 0) { + if(errno == ENOENT) { + *notexist = 1; + /* see if we need to create pathname components */ + return create_dirs(path); } + log_msg(LOG_ERR, "cannot stat %s: %s", path, strerror(errno)); + return 0; } + *notexist = 0; + return 1; +} - if (errors > 0) - return -1; - - --zone_count; - if (!write_number(db, zone_count)) - return -1; - for (zone = db->zones; zone; zone = zone->next) { - if (write_dname(db, zone->apex)) - return -1; +void +namedb_write_zonefile(namedb_type* db, zone_options_t* zopt) +{ + const char* zfile; + int notexist = 0; + zone_type* zone; + /* if no zone exists, it has no contents or it has no zonefile + * configured, then no need to write data to disk */ + if(!zopt->pattern->zonefile) + return; + zone = namedb_find_zone(db, (const dname_type*)zopt->node.key); + if(!zone || !zone->apex) + return; + /* write if file does not exist, or if changed */ + /* so, determine filename, create directory components, check exist*/ + zfile = config_make_zonefile(zopt); + if(!create_path_components(zfile, ¬exist)) { + log_msg(LOG_ERR, "could not write zone %s to file %s because " + "the path could not be created", zopt->name, zfile); + return; } - if (domain_table_iterate(db->domains, number_dnames_iterator, &dname_count)) - return -1; - - --dname_count; - if (!write_number(db, dname_count)) - return -1; - - DEBUG(DEBUG_ZONEC, 1, - (LOG_INFO, "Storing %lu domain names\n", (unsigned long) dname_count)); - - if (domain_table_iterate(db->domains, write_dname_iterator, db)) - return -1; - - if (domain_table_iterate(db->domains, write_domain_iterator, db)) - return -1; - - if (!write_data_crc(db->fd, &terminator, sizeof(terminator), &db->crc)) - return -1; + /* if not changed, do not write. */ + if(notexist || zone->is_changed) { + char logs[4096]; + char bakfile[4096]; + udb_ptr zudb; + if(!udb_zone_search(db->udb, &zudb, + dname_name(domain_dname(zone->apex)), + domain_dname(zone->apex)->name_size)) + return; /* zone does not exist in db */ + /* write to zfile~ first, then rename if that works */ + snprintf(bakfile, sizeof(bakfile), "%s~", zfile); + if(ZONE(&zudb)->log_str.data) { + udb_ptr s; + udb_ptr_new(&s, db->udb, &ZONE(&zudb)->log_str); + strlcpy(logs, (char*)udb_ptr_data(&s), sizeof(logs)); + udb_ptr_unlink(&s, db->udb); + } else logs[0] = 0; + if(!write_to_zonefile(zone, bakfile, logs)) { + udb_ptr_unlink(&zudb, db->udb); + return; /* error already printed */ + } + if(rename(bakfile, zfile) == -1) { + log_msg(LOG_ERR, "rename(%s to %s) failed: %s", + bakfile, zfile, strerror(errno)); + udb_ptr_unlink(&zudb, db->udb); + return; + } + zone->is_changed = 0; + ZONE(&zudb)->mtime = (uint64_t)time(0); + ZONE(&zudb)->is_changed = 0; + udb_zone_set_log_str(db->udb, &zudb, NULL); + udb_ptr_unlink(&zudb, db->udb); + } +} - return 0; +void +namedb_write_zonefiles(namedb_type* db, nsd_options_t* options) +{ + zone_options_t* zo; + RBTREE_FOR(zo, zone_options_t*, options->zone_options) { + namedb_write_zonefile(db, zo); + } } diff --git a/usr.sbin/nsd/difffile.c b/usr.sbin/nsd/difffile.c index 2b6d721d878..0719cf6f9dc 100644 --- a/usr.sbin/nsd/difffile.c +++ b/usr.sbin/nsd/difffile.c @@ -1,7 +1,7 @@ /* * difffile.c - DIFF file handling source code. Read and write diff files. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -14,22 +14,26 @@ #include <stdlib.h> #include <errno.h> #include "difffile.h" +#include "xfrd-disk.h" #include "util.h" #include "packet.h" #include "rdata.h" +#include "udb.h" +#include "udbzone.h" #include "nsec3.h" +#include "nsd.h" +#include "rrl.h" static int -write_32(FILE *out, uint32_t val) +write_64(FILE *out, uint64_t val) { - val = htonl(val); return write_data(out, &val, sizeof(val)); } static int -write_16(FILE *out, uint16_t val) +write_32(FILE *out, uint32_t val) { - val = htons(val); + val = htonl(val); return write_data(out, &val, sizeof(val)); } @@ -49,142 +53,117 @@ write_str(FILE *out, const char* str) } void -diff_write_packet(const char* zone, uint32_t new_serial, uint16_t id, - uint32_t seq_nr, uint8_t* data, size_t len, nsd_options_t* opt) +diff_write_packet(const char* zone, const char* pat, uint32_t old_serial, + uint32_t new_serial, uint32_t seq_nr, uint8_t* data, size_t len, + struct nsd* nsd, uint64_t filenumber) { - const char* filename = opt->difffile; - struct timeval tv; - FILE *df; - uint32_t file_len = sizeof(uint32_t) + strlen(zone) + - sizeof(new_serial) + sizeof(id) + sizeof(seq_nr) + len; - - if (gettimeofday(&tv, NULL) != 0) { - log_msg(LOG_ERR, "could not set timestamp for %s: %s", - filename, strerror(errno)); + FILE* df = xfrd_open_xfrfile(nsd, filenumber, seq_nr?"a":"w"); + if(!df) { + log_msg(LOG_ERR, "could not open transfer %s file %lld: %s", + zone, (long long)filenumber, strerror(errno)); return; } - df = fopen(filename, "a"); - if(!df) { - log_msg(LOG_ERR, "could not open file %s for append: %s", - filename, strerror(errno)); - return; + /* if first part, first write the header */ + if(seq_nr == 0) { + struct timeval tv; + if (gettimeofday(&tv, NULL) != 0) { + log_msg(LOG_ERR, "could not get timestamp for %s: %s", + zone, strerror(errno)); + } + if(!write_32(df, DIFF_PART_XFRF) || + !write_8(df, 0) /* notcommitted(yet) */ || + !write_32(df, 0) /* numberofparts when done */ || + !write_64(df, (uint64_t) tv.tv_sec) || + !write_32(df, (uint32_t) tv.tv_usec) || + !write_32(df, old_serial) || + !write_32(df, new_serial) || + !write_64(df, (uint64_t) tv.tv_sec) || + !write_32(df, (uint32_t) tv.tv_usec) || + !write_str(df, zone) || + !write_str(df, pat)) { + log_msg(LOG_ERR, "could not write transfer %s file %lld: %s", + zone, (long long)filenumber, strerror(errno)); + fclose(df); + return; + } } - if(!write_32(df, DIFF_PART_IXFR) || - !write_32(df, (uint32_t) tv.tv_sec) || - !write_32(df, (uint32_t) tv.tv_usec) || - !write_32(df, file_len) || - !write_str(df, zone) || - !write_32(df, new_serial) || - !write_16(df, id) || - !write_32(df, seq_nr) || + if(!write_32(df, DIFF_PART_XXFR) || + !write_32(df, len) || !write_data(df, data, len) || - !write_32(df, file_len)) + !write_32(df, len)) { - log_msg(LOG_ERR, "could not write to file %s: %s", - filename, strerror(errno)); + log_msg(LOG_ERR, "could not write transfer %s file %lld: %s", + zone, (long long)filenumber, strerror(errno)); } fclose(df); } void -diff_write_commit(const char* zone, uint32_t old_serial, - uint32_t new_serial, uint16_t id, uint32_t num_parts, - uint8_t commit, const char* log_str, nsd_options_t* opt) +diff_write_commit(const char* zone, uint32_t old_serial, uint32_t new_serial, + uint32_t num_parts, uint8_t commit, const char* log_str, + struct nsd* nsd, uint64_t filenumber) { - const char* filename = opt->difffile; struct timeval tv; - FILE *df; - uint32_t len; + FILE* df; if (gettimeofday(&tv, NULL) != 0) { log_msg(LOG_ERR, "could not set timestamp for %s: %s", - filename, strerror(errno)); - return; + zone, strerror(errno)); } - df = fopen(filename, "a"); + /* overwrite the first part of the file with 'committed = 1', + * as well as the end_time and number of parts. + * also write old_serial and new_serial, so that a bad file mixup + * will result in unusable serial numbers. */ + + df = xfrd_open_xfrfile(nsd, filenumber, "r+"); if(!df) { - log_msg(LOG_ERR, "could not open file %s for append: %s", - filename, strerror(errno)); + log_msg(LOG_ERR, "could not open transfer %s file %lld: %s", + zone, (long long)filenumber, strerror(errno)); return; } - - len = strlen(zone) + sizeof(len) + sizeof(old_serial) + - sizeof(new_serial) + sizeof(id) + sizeof(num_parts) + - sizeof(commit) + strlen(log_str) + sizeof(len); - - if(!write_32(df, DIFF_PART_SURE) || - !write_32(df, (uint32_t) tv.tv_sec) || + if(!write_32(df, DIFF_PART_XFRF) || + !write_8(df, commit) /* committed */ || + !write_32(df, num_parts) || + !write_64(df, (uint64_t) tv.tv_sec) || !write_32(df, (uint32_t) tv.tv_usec) || - !write_32(df, len) || - !write_str(df, zone) || !write_32(df, old_serial) || - !write_32(df, new_serial) || - !write_16(df, id) || - !write_32(df, num_parts) || - !write_8(df, commit) || - !write_str(df, log_str) || - !write_32(df, len)) + !write_32(df, new_serial)) { - log_msg(LOG_ERR, "could not write to file %s: %s", - filename, strerror(errno)); + log_msg(LOG_ERR, "could not write transfer %s file %lld: %s", + zone, (long long)filenumber, strerror(errno)); + fclose(df); + return; + } + + /* append the log_str to the end of the file */ + if(fseek(df, 0, SEEK_END) == -1) { + log_msg(LOG_ERR, "could not fseek transfer %s file %lld: %s", + zone, (long long)filenumber, strerror(errno)); + fclose(df); + return; + } + if(!write_str(df, log_str)) { + log_msg(LOG_ERR, "could not write transfer %s file %lld: %s", + zone, (long long)filenumber, strerror(errno)); + fclose(df); + return; + } fflush(df); fclose(df); } -/* - * Checksum to signal no data change occured (for example, by a - * zonec run. - */ int -db_crc_different(namedb_type* db) +diff_read_64(FILE *in, uint64_t* result) { - FILE *fd = fopen(db->filename, "r"); - uint32_t crc_file; - char buf[NAMEDB_MAGIC_SIZE]; - if(fd == NULL) { - log_msg(LOG_ERR, "unable to load %s: %s", - db->filename, strerror(errno)); - return -1; - } - - /* seek to position of CRC, check it and magic no */ - if(fseeko(fd, db->crc_pos, SEEK_SET)==-1) { - log_msg(LOG_ERR, "unable to fseeko %s: %s. db changed?", - db->filename, strerror(errno)); - fclose(fd); - return -1; - } - - if(fread(&crc_file, sizeof(crc_file), 1, fd) != 1) { - if(!feof(fd)) - log_msg(LOG_ERR, "could not read %s CRC: %s. " - "db changed?", db->filename, strerror(errno)); - fclose(fd); - return -1; - } - crc_file = ntohl(crc_file); - - if(fread(buf, sizeof(char), sizeof(buf), fd) != sizeof(buf)) { - if(!feof(fd)) - log_msg(LOG_ERR, "could not read %s magic: %s. " - "db changed?", db->filename, strerror(errno)); - fclose(fd); - return -1; - } - if(memcmp(buf, NAMEDB_MAGIC, NAMEDB_MAGIC_SIZE) != 0) { - fclose(fd); - return -1; - } - - fclose(fd); - - if(db->crc == crc_file) + if (fread(result, sizeof(*result), 1, in) == 1) { + return 1; + } else { return 0; - return 1; + } } int @@ -199,17 +178,6 @@ diff_read_32(FILE *in, uint32_t* result) } int -diff_read_16(FILE *in, uint16_t* result) -{ - if (fread(result, sizeof(*result), 1, in) == 1) { - *result = ntohs(*result); - return 1; - } else { - return 0; - } -} - -int diff_read_8(FILE *in, uint8_t* result) { if (fread(result, sizeof(*result), 1, in) == 1) { @@ -259,7 +227,7 @@ has_data_below(domain_type* top) assert(d != NULL); /* in the canonical ordering subdomains are after this name */ d = domain_next(d); - while(d != NULL && dname_is_subdomain(domain_dname(d), domain_dname(top))) { + while(d != NULL && domain_is_subdomain(d, top)) { if(d->is_existing) return 1; d = domain_next(d); @@ -267,35 +235,8 @@ has_data_below(domain_type* top) return 0; } - -/* this routine makes empty terminals non-existent. - * @domain the lowest empty terminal - * @ce the closest encloser - */ -static domain_type* -rrset_delete_empty_terminals(domain_type* domain, domain_type* ce) -{ - assert(domain); - if (domain->rrsets == 0) { - /* if there is no data below it, it becomes non existing. - also empty nonterminals above it become nonexisting */ - /* check for data below this node. */ - if(!has_data_below(domain)) { - /* nonexist this domain and all parent empty nonterminals */ - domain_type* p = domain; - while(p != NULL && p->rrsets == 0) { - if(p == ce || has_data_below(p)) - return p; - p->is_existing = 0; - p = p->parent; - } - } - } - return NULL; -} - - -static domain_type* +/** remove rrset. Adjusts zone params. Does not remove domain */ +static void rrset_delete(namedb_type* db, domain_type* domain, rrset_type* rrset) { int i; @@ -306,40 +247,29 @@ rrset_delete(namedb_type* db, domain_type* domain, rrset_type* rrset) } if(!*pp) { /* rrset does not exist for domain */ - return NULL; + return; } *pp = rrset->next; DEBUG(DEBUG_XFRD,2, (LOG_INFO, "delete rrset of %s type %s", - dname_to_string(domain_dname(domain),0), + domain_to_string(domain), rrtype_to_string(rrset_rrtype(rrset)))); /* is this a SOA rrset ? */ if(rrset->zone->soa_rrset == rrset) { rrset->zone->soa_rrset = 0; - rrset->zone->updated = 1; - domain->has_SOA = 0; } if(rrset->zone->ns_rrset == rrset) { rrset->zone->ns_rrset = 0; } if(domain == rrset->zone->apex && rrset_rrtype(rrset) == TYPE_RRSIG) { for (i = 0; i < rrset->rr_count; ++i) { - if (rr_rrsig_type_covered(&rrset->rrs[i]) == TYPE_DNSKEY) { + if(rr_rrsig_type_covered(&rrset->rrs[i])==TYPE_DNSKEY) { rrset->zone->is_secure = 0; break; } } } - -#ifdef NSEC3 -#ifndef FULL_PREHASH - if (rrset->rrs[0].type == TYPE_NSEC3) { - namedb_del_nsec3_domain(db, domain, rrset->zone); - } -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ - /* recycle the memory space of the rrset */ for (i = 0; i < rrset->rr_count; ++i) add_rdata_to_recyclebin(db, &rrset->rrs[i]); @@ -349,60 +279,334 @@ rrset_delete(namedb_type* db, domain_type* domain, rrset_type* rrset) region_recycle(db->region, rrset, sizeof(rrset_type)); /* is the node now an empty node (completely deleted) */ - if (domain->rrsets == 0) { - return domain; + if(domain->rrsets == 0) { + /* if there is no data below it, it becomes non existing. + also empty nonterminals above it become nonexisting */ + /* check for data below this node. */ + if(!has_data_below(domain)) { + /* nonexist this domain and all parent empty nonterminals */ + domain_type* p = domain; + while(p != NULL && p->rrsets == 0) { + if(has_data_below(p)) + break; + p->is_existing = 0; + p = p->parent; + } + } } - return NULL; } static int -rdatas_equal(rdata_atom_type *a, rdata_atom_type *b, int num, uint16_t type) +rdatas_equal(rdata_atom_type *a, rdata_atom_type *b, int num, uint16_t type, + int* rdnum, char** reason) { int k; for(k = 0; k < num; k++) { if(rdata_atom_is_domain(type, k)) { if(dname_compare(domain_dname(a[k].domain), - domain_dname(b[k].domain))!=0) + domain_dname(b[k].domain))!=0) { + *rdnum = k; + *reason = "dname data"; + return 0; + } + } else if(rdata_atom_is_literal_domain(type, k)) { + /* literal dname, but compare case insensitive */ + if(a[k].data[0] != b[k].data[0]) { + *rdnum = k; + *reason = "literal dname len"; + return 0; /* uncompressed len must be equal*/ + } + if(!dname_equal_nocase((uint8_t*)(a[k].data+1), + (uint8_t*)(b[k].data+1), a[k].data[0])) { + *rdnum = k; + *reason = "literal dname data"; return 0; + } } else { /* check length */ - if(a[k].data[0] != b[k].data[0]) + if(a[k].data[0] != b[k].data[0]) { + *rdnum = k; + *reason = "rdata len"; return 0; + } /* check data */ - if(memcmp(a[k].data+1, b[k].data+1, a[k].data[0])!=0) + if(memcmp(a[k].data+1, b[k].data+1, a[k].data[0])!=0) { + *rdnum = k; + *reason = "rdata data"; return 0; + } } } return 1; } -static int -find_rr_num(rrset_type* rrset, - uint16_t type, uint16_t klass, +static void +debug_find_rr_num(rrset_type* rrset, uint16_t type, uint16_t klass, rdata_atom_type *rdatas, ssize_t rdata_num) { - int i; + int i, rd; + char* reason = ""; + + for(i=0; i < rrset->rr_count; ++i) { + if (rrset->rrs[i].type != type) { + log_msg(LOG_WARNING, "diff: RR <%s, %s> does not match " + "RR num %d type %s", + dname_to_string(rrset->rrs[i].owner->dname,0), + rrtype_to_string(type), i, + rrtype_to_string(rrset->rrs[i].type)); + } + if (rrset->rrs[i].klass != klass) { + log_msg(LOG_WARNING, "diff: RR <%s, %s> class %d " + "does not match RR num %d class %d", + dname_to_string(rrset->rrs[i].owner->dname,0), + rrtype_to_string(type), + klass, i, + rrset->rrs[i].klass); + } + if (rrset->rrs[i].rdata_count != rdata_num) { + log_msg(LOG_WARNING, "diff: RR <%s, %s> rdlen %u " + "does not match RR num %d rdlen %d", + dname_to_string(rrset->rrs[i].owner->dname,0), + rrtype_to_string(type), + (unsigned) rdata_num, i, + (unsigned) rrset->rrs[i].rdata_count); + } + if (!rdatas_equal(rdatas, rrset->rrs[i].rdatas, rdata_num, type, + &rd, &reason)) { + log_msg(LOG_WARNING, "diff: RR <%s, %s> rdata element " + "%d differs from RR num %d rdata (%s)", + dname_to_string(rrset->rrs[i].owner->dname,0), + rrtype_to_string(type), + rd, i, reason); + } + } +} + +static int +find_rr_num(rrset_type* rrset, uint16_t type, uint16_t klass, + rdata_atom_type *rdatas, ssize_t rdata_num, int add) +{ + int i, rd; + char* reason; for(i=0; i < rrset->rr_count; ++i) { if(rrset->rrs[i].type == type && rrset->rrs[i].klass == klass && rrset->rrs[i].rdata_count == rdata_num && - rdatas_equal(rdatas, rrset->rrs[i].rdatas, rdata_num, type)) + rdatas_equal(rdatas, rrset->rrs[i].rdatas, rdata_num, type, + &rd, &reason)) { return i; } } - + /* this is odd. Log why rr cannot be found. */ + if (!add) { + debug_find_rr_num(rrset, type, klass, rdatas, rdata_num); + } return -1; } -static int +#ifdef NSEC3 +/* see if nsec3 deletion triggers need action */ +static void +nsec3_delete_rr_trigger(namedb_type* db, rr_type* rr, zone_type* zone, + udb_ptr* udbz) +{ + /* the RR has not actually been deleted yet, so we can inspect it */ + if(!zone->nsec3_param) + return; + /* see if the domain was an NSEC3-domain in the chain, but no longer */ + if(rr->type == TYPE_NSEC3 && rr->owner->nsec3 && + rr->owner->nsec3->nsec3_node.key && + nsec3_rr_uses_params(rr, zone) && + nsec3_in_chain_count(rr->owner, zone) <= 1) { + domain_type* prev = nsec3_chain_find_prev(zone, rr->owner); + /* remove from prehash because no longer an NSEC3 domain */ + if(domain_is_prehash(db->domains, rr->owner)) + prehash_del(db->domains, rr->owner); + /* fixup the last in the zone */ + if(rr->owner == zone->nsec3_last) + zone->nsec3_last = prev; + /* unlink from the nsec3tree */ + zone_del_domain_in_hash_tree(zone->nsec3tree, + &rr->owner->nsec3->nsec3_node); + /* add previous NSEC3 to the prehash list */ + if(prev && prev != rr->owner) + prehash_add(db->domains, prev); + else nsec3_clear_precompile(db, zone); + /* this domain becomes ordinary data domain: done later */ + } + /* see if the rr was NSEC3PARAM that we were using */ + else if(rr->type == TYPE_NSEC3PARAM && rr == zone->nsec3_param) { + /* clear trees, wipe hashes, wipe precompile */ + nsec3_clear_precompile(db, zone); + /* pick up new nsec3param from udb */ + nsec3_find_zone_param(db, zone, udbz); + /* if no more NSEC3, done */ + if(!zone->nsec3_param) + return; + nsec3_precompile_newparam(db, zone); + } +} + +/* see if nsec3 prehash can be removed with new rrset content */ +static void +nsec3_rrsets_changed_remove_prehash(domain_type* domain, zone_type* zone) +{ + /* deletion of rrset already done, we can check if conditions apply */ + /* see if the domain is no longer precompiled */ + /* it has a hash_node, but no longer fulfills conditions */ + if(nsec3_domain_part_of_zone(domain, zone) && domain->nsec3 && + domain->nsec3->hash_node.key && + !nsec3_condition_hash(domain, zone)) { + /* remove precompile */ + domain->nsec3->nsec3_cover = NULL; + domain->nsec3->nsec3_wcard_child_cover = NULL; + domain->nsec3->nsec3_is_exact = 0; + /* remove it from the hash tree */ + zone_del_domain_in_hash_tree(zone->hashtree, + &domain->nsec3->hash_node); + zone_del_domain_in_hash_tree(zone->wchashtree, + &domain->nsec3->wchash_node); + } + if(domain != zone->apex && domain->nsec3 && + domain->nsec3->dshash_node.key && + !nsec3_condition_dshash(domain, zone)) { + /* remove precompile */ + domain->nsec3->nsec3_ds_parent_cover = NULL; + domain->nsec3->nsec3_ds_parent_is_exact = 0; + /* remove it from the hash tree */ + zone_del_domain_in_hash_tree(zone->dshashtree, + &domain->nsec3->dshash_node); + } +} + +/* see if domain needs to get precompiled info */ +static void +nsec3_rrsets_changed_add_prehash(namedb_type* db, domain_type* domain, + zone_type* zone) +{ + if(!zone->nsec3_param) + return; + if((!domain->nsec3 || !domain->nsec3->hash_node.key) + && nsec3_condition_hash(domain, zone)) { + region_type* tmpregion = region_create(xalloc, free); + nsec3_precompile_domain(db, domain, zone, tmpregion); + region_destroy(tmpregion); + } + if((!domain->nsec3 || !domain->nsec3->dshash_node.key) + && nsec3_condition_dshash(domain, zone)) { + nsec3_precompile_domain_ds(db, domain, zone); + } +} + +/* see if nsec3 rrset-deletion triggers need action */ +static void +nsec3_delete_rrset_trigger(namedb_type* db, domain_type* domain, + zone_type* zone, uint16_t type) +{ + if(!zone->nsec3_param) + return; + nsec3_rrsets_changed_remove_prehash(domain, zone); + /* for type nsec3, or a delegation, the domain may have become a + * 'normal' domain with its remaining data now */ + if(type == TYPE_NSEC3 || type == TYPE_NS || type == TYPE_DS) + nsec3_rrsets_changed_add_prehash(db, domain, zone); + /* for type DNAME or a delegation, obscured data may be revealed */ + if(type == TYPE_NS || type == TYPE_DS || type == TYPE_DNAME) { + /* walk over subdomains and check them each */ + domain_type *d; + for(d=domain_next(domain); d && domain_is_subdomain(d, domain); + d=domain_next(d)) { + nsec3_rrsets_changed_add_prehash(db, d, zone); + } + } +} + +/* see if nsec3 addition triggers need action */ +static void +nsec3_add_rr_trigger(namedb_type* db, rr_type* rr, zone_type* zone, + udb_ptr* udbz) +{ + /* the RR has been added in full, also to UDB (and thus NSEC3PARAM + * in the udb has been adjusted) */ + if(zone->nsec3_param && rr->type == TYPE_NSEC3 && + (!rr->owner->nsec3 || !rr->owner->nsec3->nsec3_node.key) + && nsec3_rr_uses_params(rr, zone)) { + /* added NSEC3 into the chain */ + nsec3_precompile_nsec3rr(db, rr->owner, zone); + /* the domain has become an NSEC3-domain, if it was precompiled + * previously, remove that, neatly done in routine above */ + nsec3_rrsets_changed_remove_prehash(rr->owner, zone); + /* set this NSEC3 to prehash */ + prehash_add(db->domains, rr->owner); + } else if(!zone->nsec3_param && rr->type == TYPE_NSEC3PARAM) { + /* see if this means NSEC3 chain can be used */ + nsec3_find_zone_param(db, zone, udbz); + if(!zone->nsec3_param) + return; + nsec3_zone_trees_create(db->region, zone); + nsec3_precompile_newparam(db, zone); + } +} + +/* see if nsec3 rrset-addition triggers need action */ +static void +nsec3_add_rrset_trigger(namedb_type* db, domain_type* domain, zone_type* zone, + uint16_t type) +{ + /* the rrset has been added so we can inspect it */ + if(!zone->nsec3_param) + return; + /* because the rrset is added we can check conditions easily. + * check if domain needs to become precompiled now */ + nsec3_rrsets_changed_add_prehash(db, domain, zone); + /* if a delegation, it changes from normal name to unhashed referral */ + if(type == TYPE_NS || type == TYPE_DS) { + nsec3_rrsets_changed_remove_prehash(domain, zone); + } + /* if delegation or DNAME added, then some RRs may get obscured */ + if(type == TYPE_NS || type == TYPE_DS || type == TYPE_DNAME) { + /* walk over subdomains and check them each */ + domain_type *d; + for(d=domain_next(domain); d && domain_is_subdomain(d, domain); + d=domain_next(d)) { + nsec3_rrsets_changed_remove_prehash(d, zone); + } + } +} +#endif /* NSEC3 */ + +/* fixup usage lower for domain names in the rdata */ +static void +rr_lower_usage(namedb_type* db, rr_type* rr) +{ + unsigned i; + for(i=0; i<rr->rdata_count; i++) { + if(rdata_atom_is_domain(rr->type, i)) { + assert(rdata_atom_domain(rr->rdatas[i])->usage > 0); + rdata_atom_domain(rr->rdatas[i])->usage --; + if(rdata_atom_domain(rr->rdatas[i])->usage == 0) + domain_table_deldomain(db, + rdata_atom_domain(rr->rdatas[i])); + } + } +} + +static void +rrset_lower_usage(namedb_type* db, rrset_type* rrset) +{ + unsigned i; + for(i=0; i<rrset->rr_count; i++) + rr_lower_usage(db, &rrset->rrs[i]); +} + +int delete_RR(namedb_type* db, const dname_type* dname, uint16_t type, uint16_t klass, - domain_type* prevdomain, buffer_type* packet, size_t rdatalen, zone_type *zone, - region_type* temp_region, int is_axfr) + region_type* temp_region, udb_ptr* udbz) { domain_type *domain; rrset_type *rrset; @@ -436,36 +640,30 @@ delete_RR(namedb_type* db, const dname_type* dname, dname_to_string(dname,0)); return 0; } - rrnum = find_rr_num(rrset, type, klass, rdatas, rdata_num); + rrnum = find_rr_num(rrset, type, klass, rdatas, rdata_num, 0); if(rrnum == -1) { log_msg(LOG_WARNING, "diff: RR <%s, %s> does not exist", dname_to_string(dname,0), rrtype_to_string(type)); return 1; /* not fatal error */ } + /* delete the normalized RR from the udb */ + udb_del_rr(db->udb, udbz, &rrset->rrs[rrnum]); #ifdef NSEC3 -#ifndef FULL_PREHASH - if (is_axfr == 0) { - struct domain *parent = domain; - do { - if (0 != namedb_add_nsec3_mod_domain(db, - parent)) { - return 0; - } - parent = parent->parent; - } while (parent != zone->apex->parent); - } -#else - (void)is_axfr; -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ - + /* process triggers for RR deletions */ + nsec3_delete_rr_trigger(db, &rrset->rrs[rrnum], zone, udbz); +#endif + /* lower usage (possibly deleting other domains, and thus + * invalidating the current RR's domain pointers) */ + rr_lower_usage(db, &rrset->rrs[rrnum]); if(rrset->rr_count == 1) { /* delete entire rrset */ - domain = rrset_delete(db, domain, rrset); - if (domain && domain != prevdomain && !domain->nextdiff) { - /* this domain is not yet in the diff chain */ - prevdomain->nextdiff = domain; - } + rrset_delete(db, domain, rrset); +#ifdef NSEC3 + /* cleanup nsec3 */ + nsec3_delete_rrset_trigger(db, domain, zone, type); +#endif + /* see if the domain can be deleted (and inspect parents) */ + domain_table_deldomain(db, domain); } else { /* swap out the bad RR and decrease the count */ rr_type* rrs_orig = rrset->rrs; @@ -482,17 +680,40 @@ delete_RR(namedb_type* db, const dname_type* dname, } region_recycle(db->region, rrs_orig, sizeof(rr_type) * rrset->rr_count); +#ifdef NSEC3 + if(type == TYPE_NSEC3PARAM && zone->nsec3_param) { + /* fixup nsec3_param pointer to same RR */ + assert(zone->nsec3_param >= rrs_orig && + zone->nsec3_param <= + rrs_orig+rrset->rr_count); + /* last moved to rrnum, others at same index*/ + if(zone->nsec3_param == &rrs_orig[ + rrset->rr_count-1]) + zone->nsec3_param = &rrset->rrs[rrnum]; + else + zone->nsec3_param = + (void*)zone->nsec3_param + -(void*)rrs_orig + + (void*)rrset->rrs; + } +#endif /* NSEC3 */ rrset->rr_count --; +#ifdef NSEC3 + /* for type nsec3, the domain may have become a + * 'normal' domain with its remaining data now */ + if(type == TYPE_NSEC3) + nsec3_rrsets_changed_add_prehash(db, domain, + zone); +#endif /* NSEC3 */ } } return 1; } -static int +int add_RR(namedb_type* db, const dname_type* dname, uint16_t type, uint16_t klass, uint32_t ttl, - buffer_type* packet, size_t rdatalen, zone_type *zone, - int is_axfr) + buffer_type* packet, size_t rdatalen, zone_type *zone, udb_ptr* udbz) { domain_type* domain; rrset_type* rrset; @@ -500,6 +721,7 @@ add_RR(namedb_type* db, const dname_type* dname, rr_type *rrs_old; ssize_t rdata_num; int rrnum; + int rrset_added = 0; domain = domain_table_find(db->domains, dname); if(!domain) { /* create the domain */ @@ -517,6 +739,7 @@ add_RR(namedb_type* db, const dname_type* dname, rrset->rrs = 0; rrset->rr_count = 0; domain_add_rrset(domain, rrset); + rrset_added = 1; } /* dnames in rdata are normalized, conform RFC 4035, @@ -529,21 +752,13 @@ add_RR(namedb_type* db, const dname_type* dname, dname_to_string(dname,0)); return 0; } - rrnum = find_rr_num(rrset, type, klass, rdatas, rdata_num); + rrnum = find_rr_num(rrset, type, klass, rdatas, rdata_num, 1); if(rrnum != -1) { DEBUG(DEBUG_XFRD, 2, (LOG_ERR, "diff: RR <%s, %s> already exists", dname_to_string(dname,0), rrtype_to_string(type))); /* ignore already existing RR: lenient accepting of messages */ return 1; } - if(domain == zone->apex) { - /* make sure we don't get multiple soa rrs */ - if (type == TYPE_SOA && rrset->rr_count > 0) { - log_msg(LOG_ERR, "diff: multiple soa records for %s", - dname_to_string(dname,0)); - return 0; - } - } /* re-alloc the rrs and add the new */ rrs_old = rrset->rrs; @@ -567,190 +782,104 @@ add_RR(namedb_type* db, const dname_type* dname, /* see if it is a SOA */ if(domain == zone->apex) { - if(type == TYPE_SOA) { - uint32_t soa_minimum; - zone->soa_rrset = rrset; - zone->updated = 1; - /* BUG #103 tweaked SOA ttl value */ - if(zone->soa_nx_rrset == 0) { - zone->soa_nx_rrset = region_alloc(db->region, - sizeof(rrset_type)); - if(!zone->soa_nx_rrset) { - log_msg(LOG_ERR, "out of memory, %s:%d", - __FILE__, __LINE__); - exit(1); - } - zone->soa_nx_rrset->rr_count = 1; - zone->soa_nx_rrset->next = 0; - zone->soa_nx_rrset->zone = zone; - zone->soa_nx_rrset->rrs = region_alloc(db->region, - sizeof(rr_type)); - if(!zone->soa_nx_rrset->rrs) { - log_msg(LOG_ERR, "out of memory, %s:%d", - __FILE__, __LINE__); - exit(1); - } - } - memcpy(zone->soa_nx_rrset->rrs, rrset->rrs, sizeof(rr_type)); - memcpy(&soa_minimum, rdata_atom_data(rrset->rrs->rdatas[6]), - rdata_atom_size(rrset->rrs->rdatas[6])); - if (rrset->rrs->ttl > ntohl(soa_minimum)) { - rrset->zone->soa_nx_rrset->rrs[0].ttl = ntohl(soa_minimum); - } - domain->has_SOA = 1; - } - if(type == TYPE_NS) { - zone->ns_rrset = rrset; - } - if(type == TYPE_RRSIG) { - int i; - for (i = 0; i < rrset->rr_count; ++i) { - if (rr_rrsig_type_covered(&rrset->rrs[i]) == TYPE_DNSKEY) { - zone->is_secure = 1; - break; - } - } + apex_rrset_checks(db, rrset, domain); +#ifdef NSEC3 + if(type == TYPE_NSEC3PARAM && zone->nsec3_param) { + /* the pointer just changed, fix it up to point + * to the same record */ + assert(zone->nsec3_param >= rrs_old && + zone->nsec3_param < rrs_old+rrset->rr_count); + /* in this order to make sure no overflow/underflow*/ + zone->nsec3_param = (void*)zone->nsec3_param - + (void*)rrs_old + (void*)rrset->rrs; } +#endif /* NSEC3 */ } -#ifdef NSEC3 -#ifndef FULL_PREHASH - if ((type == TYPE_NSEC3) && - (rrset->rr_count == 1)) { - /* NSEC3 RRset just added */ - if (0 != namedb_add_nsec3_domain(db, domain, zone)) - return 0; + /* write the just-normalized RR to the udb */ + if(!udb_write_rr(db->udb, udbz, &rrset->rrs[rrset->rr_count - 1])) { + log_msg(LOG_ERR, "could not add RR to nsd.db, disk-space?"); + return 0; } - if (is_axfr == 0) { - struct domain *parent = domain; - do { - if (0 != namedb_add_nsec3_mod_domain(db, parent)) - return 0; - parent = parent->parent; - } while (parent != zone->apex->parent); +#ifdef NSEC3 + if(rrset_added) { + domain_type* p = domain->parent; + nsec3_add_rrset_trigger(db, domain, zone, type); + /* go up and process (possibly created) empty nonterminals, + * until we hit the apex or root */ + while(p && p->rrsets == NULL && !p->is_apex) { + nsec3_rrsets_changed_add_prehash(db, p, zone); + p = p->parent; + } } -#else - (void)is_axfr; -#endif /* !FULL_PREHASH */ + nsec3_add_rr_trigger(db, &rrset->rrs[rrset->rr_count - 1], zone, udbz); #endif /* NSEC3 */ - return 1; } static zone_type* -find_zone(namedb_type* db, const dname_type* zone_name, nsd_options_t* opt, - size_t child_count) +find_or_create_zone(namedb_type* db, const dname_type* zone_name, + nsd_options_t* opt, const char* zstr, const char* patname) { - domain_type *domain; zone_type* zone; - zone_options_t* opts; - domain = domain_table_find(db->domains, zone_name); - if(!domain) { - DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfr: creating domain %s", - dname_to_string(zone_name,0))); - /* create the zone and domain of apex (zone has config options) */ - domain = domain_table_insert(db->domains, zone_name); - } else { - /* O(1) if SOA exists */ - zone = domain_find_zone(domain); - /* if domain was empty (no rrsets, empty zone) search in zonelist */ - /* check apex to make sure we don't find a parent zone */ - if(!zone || zone->apex != domain) - zone = namedb_find_zone(db, domain); - if(zone) { - assert(zone->apex == domain); - return zone; + zone_options_t* zopt; + zone = namedb_find_zone(db, zone_name); + if(zone) { + return zone; + } + zopt = zone_options_find(opt, zone_name); + if(!zopt) { + /* if _implicit_ then insert as _part_of_config */ + if(strncmp(patname, PATTERN_IMPLICIT_MARKER, + strlen(PATTERN_IMPLICIT_MARKER)) == 0) { + zopt = zone_options_create(opt->region); + if(!zopt) return 0; + zopt->part_of_config = 1; + zopt->name = region_strdup(opt->region, zstr); + zopt->pattern = pattern_options_find(opt, patname); + if(!zopt->name || !zopt->pattern) return 0; + if(!nsd_options_insert_zone(opt, zopt)) { + log_msg(LOG_ERR, "bad domain name or duplicate zone '%s' " + "pattern %s", zstr, patname); + } + } else { + /* create zone : presumably already added to zonelist + * by xfrd, who wrote the AXFR or IXFR to disk, so we only + * need to add it to our config. + * This process does not need linesize and offset zonelist */ + zopt = zone_list_zone_insert(opt, zstr, patname, 0, 0); + if(!zopt) + return 0; } } - /* lookup in config */ - opts = zone_options_find(opt, domain_dname(domain)); - if(!opts) { - log_msg(LOG_ERR, "xfr: zone %s not in config.", - dname_to_string(zone_name,0)); - return 0; - } - /* create the zone */ - DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfr: creating zone_type %s", - dname_to_string(zone_name,0))); - zone = (zone_type *) region_alloc(db->region, sizeof(zone_type)); - if(!zone) { - log_msg(LOG_ERR, "out of memory, %s:%d", __FILE__, __LINE__); - exit(1); - } - zone->next = db->zones; - zone->opts = opts; - db->zones = zone; - db->zone_count++; - zone->apex = domain; - zone->soa_rrset = 0; - zone->soa_nx_rrset = 0; - zone->ns_rrset = 0; -#ifdef NSEC3 - zone->nsec3_soa_rr = NULL; - zone->nsec3_last = NULL; -#endif - zone->dirty = region_alloc(db->region, sizeof(uint8_t)*child_count); - if(!zone->dirty) { - log_msg(LOG_ERR, "out of memory, %s:%d", __FILE__, __LINE__); - exit(1); - } - memset(zone->dirty, 0, sizeof(uint8_t)*child_count); -#ifdef NSEC3 -#ifndef FULL_PREHASH - zone->nsec3_domains = NULL; - - if (0 != zone_nsec3_domains_create(db, zone)) { - log_msg(LOG_ERR, - "xfr: zone NSEC3 domains " - "memory allocation failure"); - return 0; - } -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ - zone->number = db->zone_count; - zone->is_secure = 0; - zone->updated = 1; - zone->is_ok = 0; + zone = namedb_zone_create(db, zone_name, zopt); return zone; } -static void +void delete_zone_rrs(namedb_type* db, zone_type* zone) { rrset_type *rrset; - domain_type *domain = zone->apex; - domain_type *next = NULL; - zone->updated = 1; -#ifdef NSEC3 -#ifndef FULL_PREHASH - zone_nsec3_domains_destroy(db, zone); -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ - + domain_type *domain = zone->apex, *next; /* go through entire tree below the zone apex (incl subzones) */ - while(domain && dname_is_subdomain( - domain_dname(domain), domain_dname(zone->apex))) + while(domain && domain_is_subdomain(domain, zone->apex)) { DEBUG(DEBUG_XFRD,2, (LOG_INFO, "delete zone visit %s", - dname_to_string(domain_dname(domain),0))); + domain_to_string(domain))); /* delete all rrsets of the zone */ while((rrset = domain_find_any_rrset(domain, zone))) { - (void)rrset_delete(db, domain, rrset); + /* lower usage can delete other domains */ + rrset_lower_usage(db, rrset); + /* rrset del does not delete our domain(yet) */ + rrset_delete(db, domain, rrset); } + /* the delete upcoming could delete parents, but nothing next + * or after the domain so store next ptr */ next = domain_next(domain); - domain->nextdiff = next; + /* see if the domain can be deleted (and inspect parents) */ + domain_table_deldomain(db, domain); domain = next; } -#ifdef NSEC3 -#ifndef FULL_PREHASH - if (0 != zone_nsec3_domains_create(db, zone)) { - log_msg(LOG_ERR, - "Zone %s: unable to create zone NSEC3 prehash table", - dname_to_string(domain_dname(zone->apex), - NULL)); - } -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ DEBUG(DEBUG_XFRD, 1, (LOG_INFO, "axfrdel: recyclebin holds %lu bytes", (unsigned long) region_get_recycle_size(db->region))); @@ -760,34 +889,19 @@ delete_zone_rrs(namedb_type* db, zone_type* zone) #endif assert(zone->soa_rrset == 0); - /* keep zone->soa_nx_rrset alloced */ + /* keep zone->soa_nx_rrset alloced: it is reused */ assert(zone->ns_rrset == 0); assert(zone->is_secure == 0); - assert(zone->updated == 1); -} - -/* fix empty terminals */ -static void -fix_empty_terminals(zone_type* zone_db) -{ - domain_type* domain = zone_db->apex, *ce = NULL, *next = NULL; - while (domain) { - ce = rrset_delete_empty_terminals(domain, ce); - next = domain->nextdiff; - domain->nextdiff = NULL; - domain = next; - } } /* return value 0: syntaxerror,badIXFR, 1:OK, 2:done_and_skip_it */ static int -apply_ixfr(namedb_type* db, FILE *in, const off_t* startpos, - const char* zone, uint32_t serialno, nsd_options_t* opt, - uint16_t id, uint32_t seq_nr, uint32_t seq_total, +apply_ixfr(namedb_type* db, FILE *in, const char* zone, uint32_t serialno, + nsd_options_t* opt, uint32_t seq_nr, uint32_t seq_total, int* is_axfr, int* delete_mode, int* rr_count, - size_t child_count) + udb_ptr* udbz, struct zone** zone_res, const char* patname, int* bytes) { - uint32_t filelen, msglen, pkttype, timestamp[2]; + uint32_t msglen, checklen, pkttype; int qcount, ancount, counter; buffer_type* packet; region_type* region; @@ -795,36 +909,24 @@ apply_ixfr(namedb_type* db, FILE *in, const off_t* startpos, uint16_t rrlen; const dname_type *dname_zone, *dname; zone_type* zone_db; - domain_type* last_in_list; - char file_zone_name[3072]; - uint32_t file_serial, file_seq_nr; - uint16_t file_id; - off_t mempos; - - memmove(&mempos, startpos, sizeof(off_t)); - if(fseeko(in, mempos, SEEK_SET) == -1) { - log_msg(LOG_INFO, "could not fseeko: %s.", strerror(errno)); - return 0; - } - /* read ixfr packet RRs and apply to in memory db */ - if(!diff_read_32(in, &pkttype) || pkttype != DIFF_PART_IXFR) { + /* note that errors could not really happen due to format of the + * packet since xfrd has checked all dnames and RRs before commit, + * this is why the errors are fatal (exit process), it must be + * something internal or a bad disk or something. */ + + /* read ixfr packet RRs and apply to in memory db */ + if(!diff_read_32(in, &pkttype) || pkttype != DIFF_PART_XXFR) { log_msg(LOG_ERR, "could not read type or wrong type"); return 0; } - if(!diff_read_32(in, ×tamp[0]) || - !diff_read_32(in, ×tamp[1])) { - log_msg(LOG_ERR, "could not read timestamp"); - return 0; - } - if(!diff_read_32(in, &filelen)) { + if(!diff_read_32(in, &msglen)) { log_msg(LOG_ERR, "could not read len"); return 0; } - /* read header */ - if(filelen < QHEADERSZ + sizeof(uint32_t)*3 + sizeof(uint16_t)) { + if(msglen < QHEADERSZ) { log_msg(LOG_ERR, "msg too short"); return 0; } @@ -834,35 +936,7 @@ apply_ixfr(namedb_type* db, FILE *in, const off_t* startpos, log_msg(LOG_ERR, "out of memory"); return 0; } - - if(!diff_read_str(in, file_zone_name, sizeof(file_zone_name)) || - !diff_read_32(in, &file_serial) || - !diff_read_16(in, &file_id) || - !diff_read_32(in, &file_seq_nr)) - { - log_msg(LOG_ERR, "could not part data"); - region_destroy(region); - return 0; - } - - if(strcmp(file_zone_name, zone) != 0 || serialno != file_serial || - id != file_id || seq_nr != file_seq_nr) { - log_msg(LOG_ERR, "internal error: reading part with changed id"); - region_destroy(region); - return 0; - } - msglen = filelen - sizeof(uint32_t)*3 - sizeof(uint16_t) - - strlen(file_zone_name); packet = buffer_create(region, QIOBUFSZ); - dname_zone = dname_parse(region, zone); - zone_db = find_zone(db, dname_zone, opt, child_count); - if(!zone_db) { - log_msg(LOG_ERR, "no zone exists"); - region_destroy(region); - /* break out and stop the IXFR, ignore it */ - return 2; - } - if(msglen > QIOBUFSZ) { log_msg(LOG_ERR, "msg too long"); region_destroy(region); @@ -876,6 +950,23 @@ apply_ixfr(namedb_type* db, FILE *in, const off_t* startpos, } buffer_set_limit(packet, msglen); + /* see if check on data fails: checks that we are not reading + * random garbage */ + if(!diff_read_32(in, &checklen) || checklen != msglen) { + log_msg(LOG_ERR, "transfer part has incorrect checkvalue"); + return 0; + } + *bytes += msglen; + + dname_zone = dname_parse(region, zone); + zone_db = find_or_create_zone(db, dname_zone, opt, zone, patname); + if(!zone_db) { + log_msg(LOG_ERR, "could not create zone %s %s", zone, patname); + region_destroy(region); + return 0; + } + *zone_res = zone_db; + /* only answer section is really used, question, additional and authority section RRs are skipped */ qcount = QDCOUNT(packet); @@ -931,8 +1022,8 @@ apply_ixfr(namedb_type* db, FILE *in, const off_t* startpos, } if(buffer_read_u32(packet) != serialno) { buffer_skip(packet, -4); - log_msg(LOG_ERR, "SOA serial %d different from commit %d", - buffer_read_u32(packet), serialno); + log_msg(LOG_ERR, "SOA serial %u different from commit %u", + (unsigned)buffer_read_u32(packet), (unsigned)serialno); region_destroy(region); return 0; } @@ -941,13 +1032,11 @@ apply_ixfr(namedb_type* db, FILE *in, const off_t* startpos, *rr_count = 1; *is_axfr = 0; *delete_mode = 0; - DEBUG(DEBUG_XFRD,2, (LOG_INFO, "diff: %s start count %d, ax %d, delmode %d", dname_to_string(dname_zone, 0), *rr_count, *is_axfr, *delete_mode)); } else counter = 0; - last_in_list = zone_db->apex; for(; counter < ancount; ++counter,++(*rr_count)) { uint16_t type, klass; @@ -978,7 +1067,15 @@ apply_ixfr(namedb_type* db, FILE *in, const off_t* startpos, if(*rr_count == 1 && type != TYPE_SOA) { /* second RR: if not SOA: this is an AXFR; delete all zone contents */ +#ifdef NSEC3 + nsec3_hash_tree_clear(zone_db); +#endif delete_zone_rrs(db, zone_db); + udb_zone_clear(db->udb, udbz); +#ifdef NSEC3 + nsec3_clear_precompile(db, zone_db); + zone_db->nsec3_param = NULL; +#endif /* NSEC3 */ /* add everything else (incl end SOA) */ *delete_mode = 0; *is_axfr = 1; @@ -1000,7 +1097,15 @@ apply_ixfr(namedb_type* db, FILE *in, const off_t* startpos, thisserial = buffer_read_u32(packet); if(thisserial == serialno) { /* AXFR */ +#ifdef NSEC3 + nsec3_hash_tree_clear(zone_db); +#endif delete_zone_rrs(db, zone_db); + udb_zone_clear(db->udb, udbz); +#ifdef NSEC3 + nsec3_clear_precompile(db, zone_db); + zone_db->nsec3_param = NULL; +#endif /* NSEC3 */ *delete_mode = 0; *is_axfr = 1; } @@ -1040,26 +1145,22 @@ apply_ixfr(namedb_type* db, FILE *in, const off_t* startpos, && seq_nr == seq_total-1) { continue; /* do not delete final SOA RR for IXFR */ } - if(!delete_RR(db, dname, type, klass, last_in_list, packet, - rrlen, zone_db, region, *is_axfr)) { + if(!delete_RR(db, dname, type, klass, packet, + rrlen, zone_db, region, udbz)) { region_destroy(region); return 0; } - if (!*is_axfr && last_in_list->nextdiff) { - last_in_list = last_in_list->nextdiff; - } } else { /* add this rr */ if(!add_RR(db, dname, type, klass, ttl, packet, - rrlen, zone_db, *is_axfr)) { + rrlen, zone_db, udbz)) { region_destroy(region); return 0; } } } - fix_empty_terminals(zone_db); region_destroy(region); return 1; } @@ -1089,601 +1190,764 @@ check_for_bad_serial(namedb_type* db, const char* zone_str, uint32_t old_serial) return 0; } -/* for multiple tcp packets use a data structure that has - * a rbtree (zone_names) with for each zone: - * has a rbtree by sequence number - * with inside a serial_number and ID (for checking only) - * and contains a off_t to the IXFR packet in the file. - * so when you get a commit for a zone, get zone obj, find sequence, - * then check if you have all sequence numbers available. Apply all packets. - */ -struct diff_read_data { - /* rbtree of struct diff_zone*/ - rbtree_t* zones; - /* region for allocation */ - region_type* region; -}; -struct diff_zone { - /* key is dname of zone */ - rbnode_t node; - /* rbtree of struct diff_xfrpart */ - rbtree_t* parts; -}; -struct diff_xfrpart { - /* key is sequence number */ - rbnode_t node; - uint32_t seq_nr; - uint32_t new_serial; - uint16_t id; - off_t file_pos; -}; - -static struct diff_read_data* -diff_read_data_create() -{ - region_type* region = region_create(xalloc, free); - struct diff_read_data* data = (struct diff_read_data*) - region_alloc(region, sizeof(struct diff_read_data)); - if(!data) { - log_msg(LOG_ERR, "out of memory, %s:%d", __FILE__, __LINE__); - exit(1); - } - data->region = region; - data->zones = rbtree_create(region, - (int (*)(const void *, const void *)) dname_compare); - return data; -} - -static struct diff_zone* -diff_read_find_zone(struct diff_read_data* data, const char* name) -{ - const dname_type* dname = dname_parse(data->region, name); - struct diff_zone* zp = (struct diff_zone*) - rbtree_search(data->zones, dname); - return zp; -} - -static int intcompf(const void* a, const void* b) -{ - if(*(uint32_t*)a < *(uint32_t*)b) - return -1; - if(*(uint32_t*)a > *(uint32_t*)b) - return +1; - return 0; -} - -static struct diff_zone* -diff_read_insert_zone(struct diff_read_data* data, const char* name) -{ - const dname_type* dname = dname_parse(data->region, name); - struct diff_zone* zp = region_alloc(data->region, - sizeof(struct diff_zone)); - if(!zp) { - log_msg(LOG_ERR, "out of memory, %s:%d", __FILE__, __LINE__); - exit(1); - } - zp->node = *RBTREE_NULL; - zp->node.key = dname; - zp->parts = rbtree_create(data->region, intcompf); - rbtree_insert(data->zones, (rbnode_t*)zp); - return zp; -} - -static struct diff_xfrpart* -diff_read_find_part(struct diff_zone* zp, uint32_t seq_nr) -{ - struct diff_xfrpart* xp = (struct diff_xfrpart*) - rbtree_search(zp->parts, &seq_nr); - return xp; -} - -static struct diff_xfrpart* -diff_read_insert_part(struct diff_read_data* data, - struct diff_zone* zp, uint32_t seq_nr) -{ - struct diff_xfrpart* xp = region_alloc(data->region, - sizeof(struct diff_xfrpart)); - if(!xp) { - log_msg(LOG_ERR, "out of memory, %s:%d", __FILE__, __LINE__); - exit(1); - } - xp->node = *RBTREE_NULL; - xp->node.key = &xp->seq_nr; - xp->seq_nr = seq_nr; - rbtree_insert(zp->parts, (rbnode_t*)xp); - return xp; -} - -/* mark commit as rollback and close inputfile, fatal exits */ -static void -mark_and_exit(nsd_options_t* opt, FILE* f, off_t commitpos, const char* desc) -{ - const char* filename = opt->difffile; - fclose(f); - if(!(f = fopen(filename, "r+"))) { - log_msg(LOG_ERR, "mark xfr, failed to re-open difffile %s: %s", - filename, strerror(errno)); - } else if(fseeko(f, commitpos, SEEK_SET) == -1) { - log_msg(LOG_INFO, "could not fseeko: %s.", strerror(errno)); - fclose(f); - } else { - uint8_t c = 0; - (void)write_data(f, &c, sizeof(c)); - fclose(f); - log_msg(LOG_ERR, "marked xfr as failed: %s", desc); - log_msg(LOG_ERR, "marked xfr so that next reload can succeed"); - } - exit(1); -} - static int -read_sure_part(namedb_type* db, FILE *in, nsd_options_t* opt, - struct diff_read_data* data, struct diff_log** log, - size_t child_count) +apply_ixfr_for_zone(nsd_type* nsd, zone_type* zonedb, FILE* in, + nsd_options_t* opt, udb_base* taskudb, udb_ptr* last_task, + uint32_t xfrfilenr) { char zone_buf[3072]; char log_buf[5120]; - uint32_t old_serial, new_serial, num_parts; - uint16_t id; + char patname_buf[2048]; + + uint32_t old_serial, new_serial, num_parts, type; + uint64_t time_end_0, time_start_0; + uint32_t time_end_1, time_start_1; uint8_t committed; - struct diff_zone *zp; uint32_t i; - int have_all_parts = 1; - struct diff_log* thislog = 0; - off_t commitpos; + int num_bytes = 0; /* read zone name and serial */ - if(!diff_read_str(in, zone_buf, sizeof(zone_buf)) || - !diff_read_32(in, &old_serial) || - !diff_read_32(in, &new_serial) || - !diff_read_16(in, &id) || - !diff_read_32(in, &num_parts)) { - log_msg(LOG_ERR, "diff file bad commit part"); + if(!diff_read_32(in, &type)) { + log_msg(LOG_ERR, "diff file too short"); return 0; } - commitpos = ftello(in); /* position of commit byte */ - if(commitpos == -1) { - log_msg(LOG_INFO, "could not ftello: %s.", strerror(errno)); + if(type != DIFF_PART_XFRF) { + log_msg(LOG_ERR, "xfr file has wrong format"); return 0; + } + /* committed and num_parts are first because they need to be + * updated once the rest is written. The log buf is not certain + * until its done, so at end of file. The patname is in case a + * new zone is created, we know what the options-pattern is */ if(!diff_read_8(in, &committed) || - !diff_read_str(in, log_buf, sizeof(log_buf)) ) - { + !diff_read_32(in, &num_parts) || + !diff_read_64(in, &time_end_0) || + !diff_read_32(in, &time_end_1) || + !diff_read_32(in, &old_serial) || + !diff_read_32(in, &new_serial) || + !diff_read_64(in, &time_start_0) || + !diff_read_32(in, &time_start_1) || + !diff_read_str(in, zone_buf, sizeof(zone_buf)) || + !diff_read_str(in, patname_buf, sizeof(patname_buf))) { log_msg(LOG_ERR, "diff file bad commit part"); return 0; } - if(log) { - thislog = (struct diff_log*)region_alloc(db->region, sizeof(struct diff_log)); - if(!thislog) { - log_msg(LOG_ERR, "out of memory, %s:%d", __FILE__, __LINE__); - exit(1); - } - thislog->zone_name = region_strdup(db->region, zone_buf); - thislog->comment = region_strdup(db->region, log_buf); - thislog->error = 0; - thislog->next = *log; - *log = thislog; - } - /* has been read in completely */ - zp = diff_read_find_zone(data, zone_buf); - if(!zp) { - log_msg(LOG_ERR, "diff file commit without IXFR"); - if(thislog) - thislog->error = "error no IXFR parts"; - return 1; + if(strcmp(zone_buf, dname_to_string(zonedb->apex->dname,0)) != 0) { + log_msg(LOG_ERR, "file %s does not match task %s", + zone_buf, dname_to_string(zonedb->apex->dname,0)); + return 0; } - if(committed && check_for_bad_serial(db, zone_buf, old_serial)) { - DEBUG(DEBUG_XFRD,1, (LOG_ERR, - "skipping diff file commit with bad serial")); - zp->parts->root = RBTREE_NULL; - zp->parts->count = 0; - if(thislog) - thislog->error = "error bad serial"; - return 1; + if(!committed) { + log_msg(LOG_ERR, "diff file %s was not committed", zone_buf); + return 0; } - for(i=0; i<num_parts; i++) { - struct diff_xfrpart *xp = diff_read_find_part(zp, i); - if(!xp || xp->id != id || xp->new_serial != new_serial) { - have_all_parts = 0; - } + if(num_parts == 0) { + log_msg(LOG_ERR, "diff file %s was not completed", zone_buf); + return 0; } - if(!have_all_parts) { + if(check_for_bad_serial(nsd->db, zone_buf, old_serial)) { DEBUG(DEBUG_XFRD,1, (LOG_ERR, - "skipping diff file commit without all parts")); - if(thislog) - thislog->error = "error missing parts"; + "skipping diff file commit with bad serial")); + return 1; } - if(committed && have_all_parts) + if(committed) { int is_axfr=0, delete_mode=0, rr_count=0; - off_t resume_pos; + const dname_type* apex = zonedb->apex->dname; + udb_ptr z; -#ifdef NSEC3 -#ifndef FULL_PREHASH - struct region *region; - dname_type const *zone_dname; - struct zone *zone; - - region = region_create(xalloc, free); - if (region == NULL) { - log_msg(LOG_ERR, "out of memory"); - return 0; - } - zone_dname = dname_parse(region, zone_buf); - if (zone_dname == NULL) { - log_msg(LOG_ERR, "out of memory"); - region_destroy(region); - return 0; - } - zone = find_zone(db, zone_dname, opt, child_count); - region_destroy(region); - if (zone == NULL) { - log_msg(LOG_ERR, "no zone exists"); - /* just stop trying applying ixfr */ - return 1; - } - if (0 != namedb_nsec3_mod_domains_create(db)) { - log_msg(LOG_ERR, - "unable to allocate space " - "for modified NSEC3 domains"); - return 0; + DEBUG(DEBUG_XFRD,1, (LOG_INFO, "processing xfr: %s", zone_buf)); + if(udb_base_get_userflags(nsd->db->udb) != 0) { + log_msg(LOG_ERR, "database corrupted, cannot update"); + xfrd_unlink_xfrfile(nsd, xfrfilenr); + exit(1); } -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ - - DEBUG(DEBUG_XFRD,1, (LOG_INFO, "processing xfr: %s", log_buf)); - - resume_pos = ftello(in); - if(resume_pos == -1) { - log_msg(LOG_INFO, "could not ftello: %s.", strerror(errno)); - return 0; + /* all parts were checked by xfrd before commit */ + if(!udb_zone_search(nsd->db->udb, &z, dname_name(apex), + apex->name_size)) { + /* create it */ + if(!udb_zone_create(nsd->db->udb, &z, dname_name(apex), + apex->name_size)) { + /* out of disk space perhaps */ + log_msg(LOG_ERR, "could not udb_create_zone " + "%s, disk space full?", log_buf); + return 0; + } } + /* set the udb dirty until we are finished applying changes */ + udb_base_set_userflags(nsd->db->udb, 1); + /* read and apply all of the parts */ for(i=0; i<num_parts; i++) { - struct diff_xfrpart *xp = diff_read_find_part(zp, i); int ret; DEBUG(DEBUG_XFRD,2, (LOG_INFO, "processing xfr: apply part %d", (int)i)); - ret = apply_ixfr(db, in, &xp->file_pos, zone_buf, new_serial, opt, - id, xp->seq_nr, num_parts, &is_axfr, &delete_mode, - &rr_count, child_count); + ret = apply_ixfr(nsd->db, in, zone_buf, new_serial, opt, + i, num_parts, &is_axfr, &delete_mode, + &rr_count, &z, &zonedb, patname_buf, &num_bytes); if(ret == 0) { - log_msg(LOG_ERR, "bad ixfr packet part %d in %s", (int)i, - opt->difffile); - mark_and_exit(opt, in, commitpos, log_buf); + log_msg(LOG_ERR, "bad ixfr packet part %d in diff file for %s", (int)i, zone_buf); + xfrd_unlink_xfrfile(nsd, xfrfilenr); + /* the udb is still dirty, it is bad */ + exit(1); } else if(ret == 2) { break; } } + udb_base_set_userflags(nsd->db->udb, 0); + /* read the final log_str: but do not fail on it */ + if(!diff_read_str(in, log_buf, sizeof(log_buf))) { + log_msg(LOG_ERR, "could not read log for transfer %s", + zone_buf); + snprintf(log_buf, sizeof(log_buf), "error reading log"); + } #ifdef NSEC3 -#ifndef FULL_PREHASH - if (is_axfr != 0) - prehash_zone(db, zone); - else - prehash_zone_incremental(db, zone); -#endif /* !FULL_PREHASH */ + if(zonedb) prehash_zone(nsd->db, zonedb); #endif /* NSEC3 */ - - if(fseeko(in, resume_pos, SEEK_SET) == -1) { - log_msg(LOG_INFO, "could not fseeko: %s.", strerror(errno)); - return 0; + zonedb->is_changed = 1; + ZONE(&z)->is_changed = 1; + ZONE(&z)->mtime = time_end_0; + udb_zone_set_log_str(nsd->db->udb, &z, log_buf); + udb_ptr_unlink(&z, nsd->db->udb); + if(taskudb) task_new_soainfo(taskudb, last_task, zonedb); + + if(1 <= verbosity) { + double elapsed = (double)(time_end_0 - time_start_0)+ + (double)((double)time_end_1 + -(double)time_start_1) / 1000000.0; + VERBOSITY(2, (LOG_INFO, "zone %s %s of %d bytes in %g seconds", + zone_buf, log_buf, num_bytes, elapsed)); } } else { DEBUG(DEBUG_XFRD,1, (LOG_INFO, "skipping xfr: %s", log_buf)); } - - /* clean out the parts for the zone after the commit/rollback */ - zp->parts->root = RBTREE_NULL; - zp->parts->count = 0; return 1; } +struct udb_base* task_file_create(const char* file) +{ + return udb_base_create_new(file, &namedb_walkfunc, NULL); +} + static int -store_ixfr_data(FILE *in, uint32_t len, struct diff_read_data* data, off_t* startpos) +task_create_new_elem(struct udb_base* udb, udb_ptr* last, udb_ptr* e, + size_t sz, const dname_type* zname) { - char zone_name[3072]; - struct diff_zone* zp; - struct diff_xfrpart* xp; - uint32_t new_serial, seq; - uint16_t id; - if(!diff_read_str(in, zone_name, sizeof(zone_name)) || - !diff_read_32(in, &new_serial) || - !diff_read_16(in, &id) || - !diff_read_32(in, &seq)) { - log_msg(LOG_INFO, "could not read ixfr store info: file format error"); + if(!udb_ptr_alloc_space(e, udb, udb_chunk_type_task, sz)) { return 0; } - len -= sizeof(uint32_t)*3 + sizeof(uint16_t) + strlen(zone_name); - if(fseeko(in, len, SEEK_CUR) == -1) - log_msg(LOG_INFO, "fseek failed: %s", strerror(errno)); - /* store the info */ - zp = diff_read_find_zone(data, zone_name); - if(!zp) - zp = diff_read_insert_zone(data, zone_name); - xp = diff_read_find_part(zp, seq); - if(xp) { - log_msg(LOG_INFO, "discarding partial xfr part: %s %d", zone_name, seq); - /* overwrite with newer value (which probably relates to next commit) */ + if(udb_ptr_is_null(last)) { + udb_base_set_userdata(udb, e->data); + } else { + udb_rptr_set_ptr(&TASKLIST(last)->next, udb, e); } - else { - xp = diff_read_insert_part(data, zp, seq); + udb_ptr_set_ptr(last, udb, e); + + /* fill in tasklist item */ + udb_rel_ptr_init(&TASKLIST(e)->next); + TASKLIST(e)->size = sz; + TASKLIST(e)->oldserial = 0; + TASKLIST(e)->newserial = 0; + TASKLIST(e)->yesno = 0; + + if(zname) { + memmove(TASKLIST(e)->zname, zname, dname_total_size(zname)); } - xp->new_serial = new_serial; - xp->id = id; - memmove(&xp->file_pos, startpos, sizeof(off_t)); return 1; } -static int -read_process_part(namedb_type* db, FILE *in, uint32_t type, - nsd_options_t* opt, struct diff_read_data* data, - struct diff_log** log, size_t child_count, off_t* startpos) +void task_new_soainfo(struct udb_base* udb, udb_ptr* last, struct zone* z) { - uint32_t len, len2; + /* calculate size */ + udb_ptr e; + size_t sz; + const dname_type* apex, *ns, *em; + if(!z || !z->apex || !domain_dname(z->apex)) + return; /* safety check */ + + DEBUG(DEBUG_IPC,1, (LOG_INFO, "nsd: add soa info for zone %s", + domain_to_string(z->apex))); + apex = domain_dname(z->apex); + sz = sizeof(struct task_list_d) + dname_total_size(apex); + if(z->soa_rrset) { + ns = domain_dname(rdata_atom_domain( + z->soa_rrset->rrs[0].rdatas[0])); + em = domain_dname(rdata_atom_domain( + z->soa_rrset->rrs[0].rdatas[1])); + sz += sizeof(uint32_t)*6 + sizeof(uint8_t)*2 + + ns->name_size + em->name_size; + } else { + ns = 0; + em = 0; + } - /* read length */ - if(!diff_read_32(in, &len)) - return 1; - /* read content */ - if(type == DIFF_PART_IXFR) { - DEBUG(DEBUG_XFRD,2, (LOG_INFO, "part IXFR len %d", len)); - if(!store_ixfr_data(in, len, data, startpos)) - return 0; + /* create new task_list item */ + if(!task_create_new_elem(udb, last, &e, sz, apex)) { + log_msg(LOG_ERR, "tasklist: out of space, cannot add SOAINFO"); + return; } - else if(type == DIFF_PART_SURE) { - DEBUG(DEBUG_XFRD,2, (LOG_INFO, "part SURE len %d", len)); - if(!read_sure_part(db, in, opt, data, log, child_count)) - return 0; - } else { - DEBUG(DEBUG_XFRD,1, (LOG_INFO, "unknown part %x len %d", type, len)); - return 0; + TASKLIST(&e)->task_type = task_soa_info; + + if(z->soa_rrset) { + uint32_t ttl = htonl(z->soa_rrset->rrs[0].ttl); + uint8_t* p = (uint8_t*)TASKLIST(&e)->zname; + p += dname_total_size(apex); + memmove(p, &ttl, sizeof(uint32_t)); + p += sizeof(uint32_t); + memmove(p, &ns->name_size, sizeof(uint8_t)); + p += sizeof(uint8_t); + memmove(p, dname_name(ns), ns->name_size); + p += ns->name_size; + memmove(p, &em->name_size, sizeof(uint8_t)); + p += sizeof(uint8_t); + memmove(p, dname_name(em), em->name_size); + p += em->name_size; + memmove(p, rdata_atom_data(z->soa_rrset->rrs[0].rdatas[2]), + sizeof(uint32_t)); + p += sizeof(uint32_t); + memmove(p, rdata_atom_data(z->soa_rrset->rrs[0].rdatas[3]), + sizeof(uint32_t)); + p += sizeof(uint32_t); + memmove(p, rdata_atom_data(z->soa_rrset->rrs[0].rdatas[4]), + sizeof(uint32_t)); + p += sizeof(uint32_t); + memmove(p, rdata_atom_data(z->soa_rrset->rrs[0].rdatas[5]), + sizeof(uint32_t)); + p += sizeof(uint32_t); + memmove(p, rdata_atom_data(z->soa_rrset->rrs[0].rdatas[6]), + sizeof(uint32_t)); } - /* read length */ - if(!diff_read_32(in, &len2)) - return 1; /* short read is OK */ - /* verify length */ - if(len != len2) - return 0; /* bad data is wrong */ - return 1; + udb_ptr_unlink(&e, udb); } -/* - * Finds smallest offset in data structs - * returns 0 if no offsets in the data structs. - */ -static int -find_smallest_offset(struct diff_read_data* data, off_t* offset) +void task_process_sync(struct udb_base* taskudb) { - int found_any = 0; - struct diff_zone* dz; - struct diff_xfrpart* dx; - off_t mem_offset, mem_fpos; + /* need to sync before other process uses the mmap? */ + DEBUG(DEBUG_IPC,1, (LOG_INFO, "task procsync %s size %d", + taskudb->fname, (int)taskudb->base_size)); + (void)taskudb; +} - if(!data || !data->zones) - return 0; - RBTREE_FOR(dz, struct diff_zone*, data->zones) - { - if(!dz->parts) - continue; - RBTREE_FOR(dx, struct diff_xfrpart*, dz->parts) - { - memmove(&mem_fpos, &dx->file_pos, sizeof(off_t)); +void task_remap(struct udb_base* taskudb) +{ + DEBUG(DEBUG_IPC,1, (LOG_INFO, "task remap %s size %d", + taskudb->fname, (int)taskudb->glob_data->fsize)); + udb_base_remap_process(taskudb); +} - if(found_any) { - memmove(&mem_offset, offset, sizeof(off_t)); +void task_clear(struct udb_base* taskudb) +{ + udb_ptr t, n; + udb_ptr_new(&t, taskudb, udb_base_get_userdata(taskudb)); + udb_base_set_userdata(taskudb, 0); + udb_ptr_init(&n, taskudb); + while(!udb_ptr_is_null(&t)) { + udb_ptr_set_rptr(&n, taskudb, &TASKLIST(&t)->next); + udb_rptr_zero(&TASKLIST(&t)->next, taskudb); + udb_ptr_free_space(&t, taskudb, TASKLIST(&t)->size); + udb_ptr_set_ptr(&t, taskudb, &n); + } + udb_ptr_unlink(&t, taskudb); + udb_ptr_unlink(&n, taskudb); +} - if(mem_fpos < mem_offset) - memmove(offset, &mem_fpos, sizeof(off_t)); - } else { - found_any = 1; - memmove(offset, &mem_fpos, sizeof(off_t)); - } - } +void task_new_expire(struct udb_base* udb, udb_ptr* last, + const struct dname* z, int expired) +{ + udb_ptr e; + if(!z) return; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "add expire info for zone %s", + dname_to_string(z,NULL))); + if(!task_create_new_elem(udb, last, &e, sizeof(struct task_list_d)+ + dname_total_size(z), z)) { + log_msg(LOG_ERR, "tasklist: out of space, cannot add expire"); + return; } + TASKLIST(&e)->task_type = task_expire; + TASKLIST(&e)->yesno = expired; + udb_ptr_unlink(&e, udb); +} - return found_any; +void task_new_check_zonefiles(udb_base* udb, udb_ptr* last, + const dname_type* zone) +{ + udb_ptr e; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "add task checkzonefiles")); + if(!task_create_new_elem(udb, last, &e, sizeof(struct task_list_d) + + (zone?dname_total_size(zone):0), zone)) { + log_msg(LOG_ERR, "tasklist: out of space, cannot add check_zones"); + return; + } + TASKLIST(&e)->task_type = task_check_zonefiles; + TASKLIST(&e)->yesno = (zone!=NULL); + udb_ptr_unlink(&e, udb); } -int -diff_read_file(namedb_type* db, nsd_options_t* opt, struct diff_log** log, +void task_new_write_zonefiles(udb_base* udb, udb_ptr* last, + const dname_type* zone) +{ + udb_ptr e; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "add task writezonefiles")); + if(!task_create_new_elem(udb, last, &e, sizeof(struct task_list_d) + + (zone?dname_total_size(zone):0), zone)) { + log_msg(LOG_ERR, "tasklist: out of space, cannot add writezones"); + return; + } + TASKLIST(&e)->task_type = task_write_zonefiles; + TASKLIST(&e)->yesno = (zone!=NULL); + udb_ptr_unlink(&e, udb); +} + +void task_new_set_verbosity(udb_base* udb, udb_ptr* last, int v) +{ + udb_ptr e; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "add task set_verbosity")); + if(!task_create_new_elem(udb, last, &e, sizeof(struct task_list_d), + NULL)) { + log_msg(LOG_ERR, "tasklist: out of space, cannot add set_v"); + return; + } + TASKLIST(&e)->task_type = task_set_verbosity; + TASKLIST(&e)->yesno = v; + udb_ptr_unlink(&e, udb); +} + +#ifdef BIND8_STATS +void* task_new_stat_info(udb_base* udb, udb_ptr* last, struct nsdst* stat, size_t child_count) { - const char* filename = opt->difffile; - FILE *df; - uint32_t type, timestamp[2], curr_timestamp[2]; - struct diff_read_data* data = diff_read_data_create(); - off_t startpos; + void* p; + udb_ptr e; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "add task stat_info")); + if(!task_create_new_elem(udb, last, &e, sizeof(struct task_list_d)+ + sizeof(*stat) + sizeof(stc_t)*child_count, NULL)) { + log_msg(LOG_ERR, "tasklist: out of space, cannot add stati"); + return NULL; + } + TASKLIST(&e)->task_type = task_stat_info; + p = TASKLIST(&e)->zname; + memcpy(p, stat, sizeof(*stat)); + udb_ptr_unlink(&e, udb); + return p + sizeof(*stat); +} +#endif /* BIND8_STATS */ - df = fopen(filename, "r"); - if(!df) { - DEBUG(DEBUG_XFRD,1, (LOG_INFO, "could not open file %s for reading: %s", - filename, strerror(errno))); - region_destroy(data->region); - return 1; +void +task_new_add_zone(udb_base* udb, udb_ptr* last, const char* zone, + const char* pattern) +{ + size_t zlen = strlen(zone); + size_t plen = strlen(pattern); + void *p; + udb_ptr e; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "add task addzone %s %s", zone, pattern)); + if(!task_create_new_elem(udb, last, &e, sizeof(struct task_list_d)+ + zlen + 1 + plen + 1, NULL)) { + log_msg(LOG_ERR, "tasklist: out of space, cannot add addz"); + return; } + TASKLIST(&e)->task_type = task_add_zone; + p = TASKLIST(&e)->zname; + memcpy(p, zone, zlen+1); + memmove(p+zlen+1, pattern, plen+1); + udb_ptr_unlink(&e, udb); +} - /* check timestamp */ - curr_timestamp[0] = (uint32_t) db->diff_timestamp.tv_sec; - curr_timestamp[1] = (uint32_t) db->diff_timestamp.tv_usec; +void +task_new_del_zone(udb_base* udb, udb_ptr* last, const dname_type* dname) +{ + udb_ptr e; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "add task delzone %s", dname_to_string(dname, 0))); + if(!task_create_new_elem(udb, last, &e, sizeof(struct task_list_d) + +dname_total_size(dname), dname)) { + log_msg(LOG_ERR, "tasklist: out of space, cannot add delz"); + return; + } + TASKLIST(&e)->task_type = task_del_zone; + udb_ptr_unlink(&e, udb); +} - if(!diff_read_32(df, &type)) { - DEBUG(DEBUG_XFRD,1, (LOG_INFO, "difffile %s is empty", - filename)); - db->diff_skip = 0; - db->diff_pos = 0; +void task_new_add_key(udb_base* udb, udb_ptr* last, key_options_t* key) +{ + char* p; + udb_ptr e; + assert(key->name && key->algorithm && key->secret); + DEBUG(DEBUG_IPC,1, (LOG_INFO, "add task addkey")); + if(!task_create_new_elem(udb, last, &e, sizeof(struct task_list_d) + +strlen(key->name)+1+strlen(key->algorithm)+1+ + strlen(key->secret)+1, NULL)) { + log_msg(LOG_ERR, "tasklist: out of space, cannot add addk"); + return; } - else if (!diff_read_32(df, ×tamp[0]) || - !diff_read_32(df, ×tamp[1])) { - log_msg(LOG_ERR, "difffile %s bad first part: no timestamp", - filename); - region_destroy(data->region); - fclose(df); - return 0; + TASKLIST(&e)->task_type = task_add_key; + p = (char*)TASKLIST(&e)->zname; + memmove(p, key->name, strlen(key->name)+1); + p+=strlen(key->name)+1; + memmove(p, key->algorithm, strlen(key->algorithm)+1); + p+=strlen(key->algorithm)+1; + memmove(p, key->secret, strlen(key->secret)+1); + udb_ptr_unlink(&e, udb); +} + +void task_new_del_key(udb_base* udb, udb_ptr* last, const char* name) +{ + char* p; + udb_ptr e; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "add task delkey")); + if(!task_create_new_elem(udb, last, &e, sizeof(struct task_list_d) + +strlen(name)+1, NULL)) { + log_msg(LOG_ERR, "tasklist: out of space, cannot add delk"); + return; } - else if (curr_timestamp[0] != timestamp[0] || - curr_timestamp[1] != timestamp[1]) { - /* new timestamp, no skipping */ - db->diff_timestamp.tv_sec = (time_t) timestamp[0]; - db->diff_timestamp.tv_usec = (suseconds_t) timestamp[1]; - - if (db->diff_skip) { - DEBUG(DEBUG_XFRD,1, (LOG_INFO, "new timestamp on " - "difffile %s, restoring diff_skip and diff_pos " - "[old timestamp: %u.%u; new timestamp: %u.%u]", - filename, curr_timestamp[0], curr_timestamp[1], - timestamp[0], timestamp[1])); - db->diff_skip = 0; - db->diff_pos = 0; - } + TASKLIST(&e)->task_type = task_del_key; + p = (char*)TASKLIST(&e)->zname; + memmove(p, name, strlen(name)+1); + udb_ptr_unlink(&e, udb); +} + +void task_new_add_pattern(udb_base* udb, udb_ptr* last, pattern_options_t* p) +{ + region_type* temp; + buffer_type* buffer; + udb_ptr e; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "add task addpattern %s", p->pname)); + temp = region_create(xalloc, free); + buffer = buffer_create(temp, 4096); + pattern_options_marshal(buffer, p); + buffer_flip(buffer); + if(!task_create_new_elem(udb, last, &e, sizeof(struct task_list_d) + + buffer_limit(buffer), NULL)) { + log_msg(LOG_ERR, "tasklist: out of space, cannot add addp"); + region_destroy(temp); + return; } + TASKLIST(&e)->task_type = task_add_pattern; + TASKLIST(&e)->yesno = buffer_limit(buffer); + memmove(TASKLIST(&e)->zname, buffer_begin(buffer), + buffer_limit(buffer)); + udb_ptr_unlink(&e, udb); + region_destroy(temp); +} - /* Always seek, to diff_pos or to beginning of the file. */ - if (fseeko(df, 0, SEEK_SET)==-1) { - log_msg(LOG_INFO, "could not fseeko file %s: %s.", filename, - strerror(errno)); - region_destroy(data->region); - fclose(df); - return 0; +void task_new_del_pattern(udb_base* udb, udb_ptr* last, const char* name) +{ + char* p; + udb_ptr e; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "add task delpattern %s", name)); + if(!task_create_new_elem(udb, last, &e, sizeof(struct task_list_d) + +strlen(name)+1, NULL)) { + log_msg(LOG_ERR, "tasklist: out of space, cannot add delp"); + return; } - if(db->diff_skip) { - DEBUG(DEBUG_XFRD,1, (LOG_INFO, "skip diff file")); - if(fseeko(df, db->diff_pos, SEEK_SET)==-1) { - log_msg(LOG_INFO, "could not fseeko file %s: %s. " - "Reread from start.", filename, - strerror(errno)); - } + TASKLIST(&e)->task_type = task_del_pattern; + p = (char*)TASKLIST(&e)->zname; + memmove(p, name, strlen(name)+1); + udb_ptr_unlink(&e, udb); +} + +void task_new_opt_change(udb_base* udb, udb_ptr* last, nsd_options_t* opt) +{ + udb_ptr e; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "add task opt_change")); + if(!task_create_new_elem(udb, last, &e, sizeof(struct task_list_d), + NULL)) { + log_msg(LOG_ERR, "tasklist: out of space, cannot add o_c"); + return; } + TASKLIST(&e)->task_type = task_opt_change; +#ifdef RATELIMIT + TASKLIST(&e)->oldserial = opt->rrl_ratelimit; + TASKLIST(&e)->newserial = opt->rrl_whitelist_ratelimit; + TASKLIST(&e)->yesno = (uint64_t) opt->rrl_slip; +#else + (void)opt; +#endif + udb_ptr_unlink(&e, udb); +} - startpos = ftello(df); - if(startpos == -1) { - log_msg(LOG_INFO, "could not ftello: %s.", strerror(errno)); - region_destroy(data->region); - fclose(df); +int +task_new_apply_xfr(udb_base* udb, udb_ptr* last, const dname_type* dname, + uint32_t old_serial, uint32_t new_serial, uint64_t filenumber) +{ + udb_ptr e; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "add task apply_xfr")); + if(!task_create_new_elem(udb, last, &e, sizeof(struct task_list_d) + +dname_total_size(dname), dname)) { + log_msg(LOG_ERR, "tasklist: out of space, cannot add applyxfr"); return 0; } + TASKLIST(&e)->oldserial = old_serial; + TASKLIST(&e)->newserial = new_serial; + TASKLIST(&e)->yesno = filenumber; + TASKLIST(&e)->task_type = task_apply_xfr; + udb_ptr_unlink(&e, udb); + return 1; +} - DEBUG(DEBUG_XFRD,1, (LOG_INFO, "start of diff file read at pos %u", - (uint32_t) db->diff_pos)); - while(diff_read_32(df, &type)) - { - DEBUG(DEBUG_XFRD,2, (LOG_INFO, "iter loop")); - - /* read timestamp */ - if(!diff_read_32(df, ×tamp[0]) || - !diff_read_32(df, ×tamp[1])) { - log_msg(LOG_INFO, "could not read timestamp: %s.", - strerror(errno)); - region_destroy(data->region); - fclose(df); - return 0; - } +void +task_process_expire(namedb_type* db, struct task_list_d* task) +{ + uint8_t ok; + zone_type* z = namedb_find_zone(db, task->zname); + assert(task->task_type == task_expire); + if(!z) { + DEBUG(DEBUG_IPC, 1, (LOG_WARNING, "zone %s %s but not in zonetree", + dname_to_string(task->zname, NULL), + task->yesno?"expired":"unexpired")); + return; + } + DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: expire task zone %s %s", + dname_to_string(task->zname,0), + task->yesno?"expired":"unexpired")); + /* find zone, set expire flag */ + ok = !task->yesno; + /* only update zone->is_ok if needed to minimize copy-on-write + * of memory pages shared after fork() */ + if(ok && !z->is_ok) + z->is_ok = 1; + else if(!ok && z->is_ok) + z->is_ok = 0; +} - if(!read_process_part(db, df, type, opt, data, log, - child_count, &startpos)) - { - log_msg(LOG_INFO, "error processing diff file"); - region_destroy(data->region); - fclose(df); - return 0; - } - startpos = ftello(df); - if(startpos == -1) { - log_msg(LOG_INFO, "could not ftello: %s.", strerror(errno)); - region_destroy(data->region); - fclose(df); - return 0; - } +static void +task_process_set_verbosity(struct task_list_d* task) +{ + DEBUG(DEBUG_IPC,1, (LOG_INFO, "verbosity task %d", (int)task->yesno)); + verbosity = task->yesno; +} + +static void +task_process_checkzones(struct nsd* nsd, udb_base* udb, udb_ptr* last_task, + struct task_list_d* task) +{ + /* on SIGHUP check if zone-text-files changed and if so, + * reread. When from xfrd-reload, no need to fstat the files */ + if(task->yesno) { + zone_options_t* zo = zone_options_find(nsd->options, + task->zname); + if(zo) + namedb_check_zonefile(nsd->db, udb, last_task, zo); + } else { + /* check all zones */ + namedb_check_zonefiles(nsd->db, nsd->options, udb, last_task); } - DEBUG(DEBUG_XFRD,1, (LOG_INFO, "end of diff file read")); +} - if(find_smallest_offset(data, &db->diff_pos)) { - /* can skip to the first unused element */ - DEBUG(DEBUG_XFRD,2, (LOG_INFO, "next time skip diff file")); - db->diff_skip = 1; +static void +task_process_writezones(struct nsd* nsd, struct task_list_d* task) +{ + if(task->yesno) { + zone_options_t* zo = zone_options_find(nsd->options, + task->zname); + if(zo) + namedb_write_zonefile(nsd->db, zo); } else { - /* all processed, can skip to here next time */ - DEBUG(DEBUG_XFRD,2, (LOG_INFO, "next time skip diff file")); - db->diff_skip = 1; - db->diff_pos = ftello(df); - if(db->diff_pos == -1) { - log_msg(LOG_INFO, "could not ftello: %s.", - strerror(errno)); - db->diff_skip = 0; - } + namedb_write_zonefiles(nsd->db, nsd->options); } +} - region_destroy(data->region); - fclose(df); - return 1; +static void +task_process_add_zone(struct nsd* nsd, udb_base* udb, udb_ptr* last_task, + struct task_list_d* task) +{ + zone_type* z; + const dname_type* zdname; + const char* zname = (const char*)task->zname; + const char* pname = zname + strlen(zname)+1; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "addzone task %s %s", zname, pname)); + zdname = dname_parse(nsd->db->region, zname); + if(!zdname) { + log_msg(LOG_ERR, "can not parse zone name %s", zname); + return; + } + /* create zone */ + z = find_or_create_zone(nsd->db, zdname, nsd->options, zname, pname); + if(!z) { + region_recycle(nsd->db->region, (void*)zdname, + dname_total_size(zdname)); + log_msg(LOG_ERR, "can not add zone %s %s", zname, pname); + return; + } + /* if zone is empty, attempt to read the zonefile from disk (if any) */ + if(!z->soa_rrset && z->opts->pattern->zonefile) { + namedb_read_zonefile(nsd->db, z, udb, last_task); + } } -static int diff_broken(FILE *df, off_t* break_pos) +static void +task_process_del_zone(struct nsd* nsd, struct task_list_d* task) { - uint32_t type, len, len2; - *break_pos = ftello(df); + udb_ptr udbz; + zone_type* zone; + zone_options_t* zopt; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "delzone task %s", dname_to_string( + task->zname, NULL))); + zone = namedb_find_zone(nsd->db, task->zname); + if(!zone) + return; - /* try to read and validate parts of the file */ - while(diff_read_32(df, &type)) /* cannot read type is no error, normal EOF */ - { - /* check type */ - if(type != DIFF_PART_IXFR && type != DIFF_PART_SURE) - return 1; - /* check length */ - if(!diff_read_32(df, &len)) - return 1; /* EOF inside the part is error */ - if(fseeko(df, len, SEEK_CUR) == -1) - { - log_msg(LOG_INFO, "fseeko failed: %s", strerror(errno)); - return 1; - } - /* fseek clears EOF flag, but try reading length value, - if EOF, the part is truncated */ - if(!diff_read_32(df, &len2)) - return 1; - if(len != len2) - return 1; /* bad part, lengths must agree */ - /* this part is ok */ - *break_pos = ftello(df); +#ifdef NSEC3 + nsec3_hash_tree_clear(zone); +#endif + delete_zone_rrs(nsd->db, zone); + if(udb_zone_search(nsd->db->udb, &udbz, dname_name(task->zname), + task->zname->name_size)) { + udb_zone_delete(nsd->db->udb, &udbz); + udb_ptr_unlink(&udbz, nsd->db->udb); } - return 0; +#ifdef NSEC3 + nsec3_clear_precompile(nsd->db, zone); + zone->nsec3_param = NULL; +#endif /* NSEC3 */ + + /* remove from zonetree, apex, soa */ + zopt = zone->opts; + namedb_zone_delete(nsd->db, zone); + /* remove from options (zone_list already edited by xfrd) */ + zone_options_delete(nsd->options, zopt); +} + +static void +task_process_add_key(struct nsd* nsd, struct task_list_d* task) +{ + key_options_t key; + key.name = (char*)task->zname; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "addkey task %s", key.name)); + key.algorithm = key.name + strlen(key.name)+1; + key.secret = key.algorithm + strlen(key.algorithm)+1; + key_options_add_modify(nsd->options, &key); + memset(key.secret, 0xdd, strlen(key.secret)); /* wipe secret */ } -void diff_snip_garbage(namedb_type* db, nsd_options_t* opt) +static void +task_process_del_key(struct nsd* nsd, struct task_list_d* task) { - off_t break_pos; - const char* filename = opt->difffile; - FILE *df; + char* name = (char*)task->zname; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "delkey task %s", name)); + /* this is reload and nothing is using the TSIG key right now */ + key_options_remove(nsd->options, name); +} - /* open file here and keep open, so it cannot change under our nose */ - df = fopen(filename, "r+"); - if(!df) { - DEBUG(DEBUG_XFRD,1, (LOG_INFO, "could not open file %s for garbage collecting: %s", - filename, strerror(errno))); +static void +task_process_add_pattern(struct nsd* nsd, struct task_list_d* task) +{ + region_type* temp = region_create(xalloc, free); + buffer_type buffer; + pattern_options_t *pat; + buffer_create_from(&buffer, task->zname, task->yesno); + pat = pattern_options_unmarshal(temp, &buffer); + DEBUG(DEBUG_IPC,1, (LOG_INFO, "addpattern task %s", pat->pname)); + pattern_options_add_modify(nsd->options, pat); + region_destroy(temp); +} + +static void +task_process_del_pattern(struct nsd* nsd, struct task_list_d* task) +{ + char* name = (char*)task->zname; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "delpattern task %s", name)); + pattern_options_remove(nsd->options, name); +} + +static void +task_process_opt_change(struct nsd* nsd, struct task_list_d* task) +{ + DEBUG(DEBUG_IPC,1, (LOG_INFO, "optchange task")); +#ifdef RATELIMIT + nsd->options->rrl_ratelimit = task->oldserial; + nsd->options->rrl_whitelist_ratelimit = task->newserial; + nsd->options->rrl_slip = task->yesno; + rrl_set_limit(nsd->options->rrl_ratelimit, nsd->options->rrl_whitelist_ratelimit, + nsd->options->rrl_slip); +#else + (void)nsd; (void)task; +#endif +} + +static void +task_process_apply_xfr(struct nsd* nsd, udb_base* udb, udb_ptr *last_task, + udb_ptr* task) +{ + /* we have to use an udb_ptr task here, because the apply_xfr procedure + * appends soa_info which may remap and change the pointer. */ + zone_type* zone; + FILE* df; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "applyxfr task %s", dname_to_string( + TASKLIST(task)->zname, NULL))); + zone = namedb_find_zone(nsd->db, TASKLIST(task)->zname); + if(!zone) { + /* assume the zone has been deleted and a zone transfer was + * still waiting to be processed */ return; } - /* and skip into file, since nsd does not read anything before the pos */ - if(db->diff_skip) { - DEBUG(DEBUG_XFRD,1, (LOG_INFO, "garbage collect skip diff file")); - if(fseeko(df, db->diff_pos, SEEK_SET)==-1) { - log_msg(LOG_INFO, "could not fseeko file %s: %s.", - filename, strerror(errno)); - fclose(df); - return; - } + /* apply the XFR */ + /* oldserial, newserial, yesno is filenumber */ + df = xfrd_open_xfrfile(nsd, TASKLIST(task)->yesno, "r"); + if(!df) { + /* could not open file to update */ + /* there is no reply to xfrd failed-update, + * because xfrd has a scan for apply-failures. */ + return; } - - /* detect break point */ - if(diff_broken(df, &break_pos)) - { - /* snip off at break_pos */ - DEBUG(DEBUG_XFRD,1, (LOG_INFO, "snipping off trailing partial part of %s", - filename)); - if(ftruncate(fileno(df), break_pos) == -1) - log_msg(LOG_ERR, "ftruncate %s failed: %s", - filename, strerror(errno)); + /* read and apply zone transfer */ + if(!apply_ixfr_for_zone(nsd, zone, df, nsd->options, udb, + last_task, TASKLIST(task)->yesno)) { + /* there is no reply to xfrd failed-update, + * because xfrd has a scan for apply-failures. */ } fclose(df); + xfrd_unlink_xfrfile(nsd, TASKLIST(task)->yesno); +} + + +void task_process_in_reload(struct nsd* nsd, udb_base* udb, udb_ptr *last_task, + udb_ptr* task) +{ + switch(TASKLIST(task)->task_type) { + case task_expire: + task_process_expire(nsd->db, TASKLIST(task)); + break; + case task_check_zonefiles: + task_process_checkzones(nsd, udb, last_task, TASKLIST(task)); + break; + case task_write_zonefiles: + task_process_writezones(nsd, TASKLIST(task)); + break; + case task_set_verbosity: + task_process_set_verbosity(TASKLIST(task)); + break; + case task_add_zone: + task_process_add_zone(nsd, udb, last_task, TASKLIST(task)); + break; + case task_del_zone: + task_process_del_zone(nsd, TASKLIST(task)); + break; + case task_add_key: + task_process_add_key(nsd, TASKLIST(task)); + break; + case task_del_key: + task_process_del_key(nsd, TASKLIST(task)); + break; + case task_add_pattern: + task_process_add_pattern(nsd, TASKLIST(task)); + break; + case task_del_pattern: + task_process_del_pattern(nsd, TASKLIST(task)); + break; + case task_opt_change: + task_process_opt_change(nsd, TASKLIST(task)); + break; + case task_apply_xfr: + task_process_apply_xfr(nsd, udb, last_task, task); + break; + default: + log_msg(LOG_WARNING, "unhandled task in reload type %d", + (int)TASKLIST(task)->task_type); + break; + } + udb_ptr_free_space(task, udb, TASKLIST(task)->size); } diff --git a/usr.sbin/nsd/difffile.h b/usr.sbin/nsd/difffile.h index d54c629b5a7..d5f2cb8833f 100644 --- a/usr.sbin/nsd/difffile.h +++ b/usr.sbin/nsd/difffile.h @@ -1,7 +1,7 @@ /* * difffile.h - nsd.diff file handling header file. Read/write diff files. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -9,62 +9,123 @@ #ifndef DIFFFILE_H #define DIFFFILE_H -#include "config.h" #include "rbtree.h" #include "namedb.h" #include "options.h" +#include "udb.h" +struct nsd; +struct nsdst; -#define DIFF_PART_IXFR ('I'<<24 | 'X'<<16 | 'F'<<8 | 'R') -#define DIFF_PART_SURE ('S'<<24 | 'U'<<16 | 'R'<<8 | 'E') - -/* - * Used to pass commit logs - */ -struct diff_log { - char* zone_name; - char* error; - char* comment; - struct diff_log* next; -}; +#define DIFF_PART_XXFR ('X'<<24 | 'X'<<16 | 'F'<<8 | 'R') +#define DIFF_PART_XFRF ('X'<<24 | 'F'<<16 | 'R'<<8 | 'F') /* write an xfr packet data to the diff file, type=IXFR. - The diff file is created if necessary. */ -void diff_write_packet(const char* zone, uint32_t new_serial, uint16_t id, - uint32_t seq_nr, uint8_t* data, size_t len, nsd_options_t* opt); + The diff file is created if necessary, with initial header(notcommitted). */ +void diff_write_packet(const char* zone, const char* pat, uint32_t old_serial, + uint32_t new_serial, uint32_t seq_nr, uint8_t* data, size_t len, + struct nsd* nsd, uint64_t filenumber); /* - * Write a commit packet to the diff file, type=SURE. - * The zone data (preceding ixfr packets) are committed. - * See NSD-DIFFFILE for meaning of the arguments. + * Overwrite header of diff file with committed vale and other data. + * append log string. */ void diff_write_commit(const char* zone, uint32_t old_serial, - uint32_t new_serial, uint16_t id, uint32_t num_parts, - uint8_t commit, const char* log_msg, - nsd_options_t* opt); - -/* check if the crc in the nsd.db is the same in memory as on disk. - returns 1 if different. 0 if the same. returns -1 on error. */ -int db_crc_different(namedb_type* db); - -/* read the diff file and apply to the database in memory. - It will attempt to skip bad data. - If you pass a non-null value log, log comments are alloced in namedb.region - then, *log must be 0 on start of call (entries are prepended). - returns 0 on an unrecoverable error. */ -int diff_read_file(namedb_type* db, nsd_options_t* opt, struct diff_log** log, - size_t child_count); - -/* check the diff file for garbage at the end (bad type, partial write) - * and snip it off. - */ -void diff_snip_garbage(namedb_type* db, nsd_options_t* opt); + uint32_t new_serial, uint32_t num_parts, uint8_t commit, + const char* log_msg, struct nsd* nsd, uint64_t filenumber); /* * These functions read parts of the diff file. */ int diff_read_32(FILE *in, uint32_t* result); -int diff_read_16(FILE *in, uint16_t* result); int diff_read_8(FILE *in, uint8_t* result); int diff_read_str(FILE* in, char* buf, size_t len); +/* delete the RRs for a zone from memory */ +void delete_zone_rrs(namedb_type* db, zone_type* zone); +/* delete an RR */ +int delete_RR(namedb_type* db, const dname_type* dname, + uint16_t type, uint16_t klass, + buffer_type* packet, size_t rdatalen, zone_type *zone, + region_type* temp_region, struct udb_ptr* udbz); +/* add an RR */ +int add_RR(namedb_type* db, const dname_type* dname, + uint16_t type, uint16_t klass, uint32_t ttl, + buffer_type* packet, size_t rdatalen, zone_type *zone, + struct udb_ptr* udbz); + +/* task udb structure */ +struct task_list_d { + /** next task in list */ + udb_rel_ptr next; + /** task type */ + enum { + /** expire or un-expire a zone */ + task_expire, + /** apply an ixfr or axfr to a zone */ + task_apply_xfr, + /** soa info for zone */ + task_soa_info, + /** check mtime of zonefiles and read them, done on SIGHUP */ + task_check_zonefiles, + /** write zonefiles (if changed) */ + task_write_zonefiles, + /** set verbosity */ + task_set_verbosity, + /** statistic info */ + task_stat_info, + /** add a zone */ + task_add_zone, + /** delete zone */ + task_del_zone, + /** add TSIG key */ + task_add_key, + /** delete TSIG key */ + task_del_key, + /** add pattern */ + task_add_pattern, + /** delete pattern */ + task_del_pattern, + /** options change */ + task_opt_change + } task_type; + uint32_t size; /* size of this struct */ + + /** soainfo: zonename dname, soaRR wireform */ + /** expire: zonename, boolyesno */ + /** apply_xfr: zonename, serials, yesno is filenamecounter */ + uint32_t oldserial, newserial; + /** general variable. for some used to see if zname is present. */ + uint64_t yesno; + struct dname zname[0]; +}; +#define TASKLIST(ptr) ((struct task_list_d*)UDB_PTR(ptr)) +/** create udb for tasks */ +struct udb_base* task_file_create(const char* file); +void task_remap(udb_base* udb); +void task_process_sync(udb_base* udb); +void task_clear(udb_base* udb); +void task_new_soainfo(udb_base* udb, udb_ptr* last, struct zone* z); +void task_new_expire(udb_base* udb, udb_ptr* last, + const struct dname* z, int expired); +void* task_new_stat_info(udb_base* udb, udb_ptr* last, struct nsdst* stat, + size_t child_count); +void task_new_check_zonefiles(udb_base* udb, udb_ptr* last, + const dname_type* zone); +void task_new_write_zonefiles(udb_base* udb, udb_ptr* last, + const dname_type* zone); +void task_new_set_verbosity(udb_base* udb, udb_ptr* last, int v); +void task_new_add_zone(udb_base* udb, udb_ptr* last, const char* zone, + const char* pattern); +void task_new_del_zone(udb_base* udb, udb_ptr* last, const dname_type* dname); +void task_new_add_key(udb_base* udb, udb_ptr* last, key_options_t* key); +void task_new_del_key(udb_base* udb, udb_ptr* last, const char* name); +void task_new_add_pattern(udb_base* udb, udb_ptr* last, pattern_options_t* p); +void task_new_del_pattern(udb_base* udb, udb_ptr* last, const char* name); +void task_new_opt_change(udb_base* udb, udb_ptr* last, nsd_options_t* opt); +int task_new_apply_xfr(udb_base* udb, udb_ptr* last, const dname_type* zone, + uint32_t old_serial, uint32_t new_serial, uint64_t filenumber); +void task_process_in_reload(struct nsd* nsd, udb_base* udb, udb_ptr *last_task, + udb_ptr* task); +void task_process_expire(namedb_type* db, struct task_list_d* task); + #endif /* DIFFFILE_H */ diff --git a/usr.sbin/nsd/dname.h b/usr.sbin/nsd/dname.h index fccc3ee2967..a9aa15ad177 100644 --- a/usr.sbin/nsd/dname.h +++ b/usr.sbin/nsd/dname.h @@ -1,7 +1,7 @@ /* * dname.h -- Domain name handling. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -179,9 +179,9 @@ dname_label(const dname_type *dname, uint8_t label) * Return < 0 if LEFT < RIGHT, 0 if LEFT == RIGHT, and > 0 if LEFT > * RIGHT. The comparison is case sensitive. * - * Pre: vleft != NULL && vright != NULL + * Pre: left != NULL && right != NULL */ -int dname_compare(const void *vleft, const void *right); +int dname_compare(const dname_type *left, const dname_type *right); /* @@ -346,21 +346,6 @@ label_next(const uint8_t *label) const char *dname_to_string(const dname_type *dname, const dname_type *origin); -/* - * Convert DNAME to its string representation. This is a reentrant - * version of dname_to_string. The buf argument is a pointer to a - * user defined result buffer capable of holding the string representation - * of a DNAME. Due to escape sequences and such, this buffer is recommeneded - * to be at least 5 * MAXDOMAINLEN in size. - * - * If ORIGIN is provided and DNAME is a subdomain of ORIGIN the dname - * will be represented relative to ORIGIN. - * - * Pre: dname != NULL - */ -const char *dname_to_string_r(const dname_type *dname, - const dname_type *origin, - char *buf); /* * Create a dname containing the single label specified by STR @@ -389,13 +374,11 @@ const dname_type *dname_replace(region_type* region, const dname_type* src, const dname_type* dest); -#ifndef FULL_PREHASH -/** - * Create a dname representing the wildcard form of the passed dname. - */ -int dname_make_wildcard(struct region *region, - struct dname const *dname, - struct dname const **wildcard); -#endif +/** Convert uncompressed wireformat dname to a string */ +char* wiredname2str(const uint8_t* dname); +/** convert uncompressed label to string */ +char* wirelabel2str(const uint8_t* label); +/** check if two uncompressed dnames of the same total length are equal */ +int dname_equal_nocase(uint8_t* a, uint8_t* b, uint16_t len); #endif /* _DNAME_H_ */ diff --git a/usr.sbin/nsd/edns.c b/usr.sbin/nsd/edns.c index b69873f5fa1..57c2e6c6634 100644 --- a/usr.sbin/nsd/edns.c +++ b/usr.sbin/nsd/edns.c @@ -1,7 +1,7 @@ /* * edns.c -- EDNS definitions (RFC 2671). * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * diff --git a/usr.sbin/nsd/edns.h b/usr.sbin/nsd/edns.h index 8de1b685f01..b8643e954e4 100644 --- a/usr.sbin/nsd/edns.h +++ b/usr.sbin/nsd/edns.h @@ -1,7 +1,7 @@ /* * edns.h -- EDNS definitions (RFC 2671). * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * diff --git a/usr.sbin/nsd/ipc.c b/usr.sbin/nsd/ipc.c index 28e1cc5e7ec..141b0f3a83d 100644 --- a/usr.sbin/nsd/ipc.c +++ b/usr.sbin/nsd/ipc.c @@ -1,7 +1,7 @@ /* * ipc.c - Interprocess communication routines. Handlers read and write. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -11,6 +11,7 @@ #include <errno.h> #include <unistd.h> #include <stdlib.h> +#include <fcntl.h> #include "ipc.h" #include "buffer.h" #include "xfrd-tcp.h" @@ -18,59 +19,16 @@ #include "namedb.h" #include "xfrd.h" #include "xfrd-notify.h" +#include "difffile.h" -/* set is_ok for the zone according to the zone message */ -static zone_type* handle_xfrd_zone_state(struct nsd* nsd, buffer_type* packet); -/* write ipc ZONE_STATE message into the buffer */ -static void write_zone_state_packet(buffer_type* packet, zone_type* zone); /* attempt to send NSD_STATS command to child fd */ static void send_stat_to_child(struct main_ipc_handler_data* data, int fd); -/* write IPC expire notification msg to a buffer */ -static void xfrd_write_expire_notification(buffer_type* buffer, xfrd_zone_t* zone); /* send reload request over the IPC channel */ static void xfrd_send_reload_req(xfrd_state_t* xfrd); /* send quit request over the IPC channel */ static void xfrd_send_quit_req(xfrd_state_t* xfrd); -/* get SOA INFO out of IPC packet buffer */ -static void xfrd_handle_ipc_SOAINFO(xfrd_state_t* xfrd, buffer_type* packet); /* perform read part of handle ipc for xfrd */ -static void xfrd_handle_ipc_read(netio_handler_type *handler, xfrd_state_t* xfrd); - -static zone_type* -handle_xfrd_zone_state(struct nsd* nsd, buffer_type* packet) -{ - uint8_t ok; - const dname_type *dname; - domain_type *domain; - zone_type *zone; - - ok = buffer_read_u8(packet); - dname = (dname_type*)buffer_current(packet); - DEBUG(DEBUG_IPC,1, (LOG_INFO, "handler zone state %s is %s", - dname_to_string(dname, NULL), ok?"ok":"expired")); - /* find in zone_types, if does not exist, we cannot serve anyway */ - /* find zone in config, since that one always exists */ - domain = domain_table_find(nsd->db->domains, dname); - if(!domain) { - DEBUG(DEBUG_IPC,1, (LOG_INFO, "zone state msg, empty zone (domain %s)", - dname_to_string(dname, NULL))); - return NULL; - } - zone = domain_find_zone(domain); - if(!zone || dname_compare(domain_dname(zone->apex), dname) != 0) { - DEBUG(DEBUG_IPC,1, (LOG_INFO, "zone state msg, empty zone (zone %s)", - dname_to_string(dname, NULL))); - return NULL; - } - assert(zone); - /* only update zone->is_ok if needed to minimize copy-on-write - of memory pages shared after fork() */ - if(ok && !zone->is_ok) - zone->is_ok = 1; - if(!ok && zone->is_ok) - zone->is_ok = 0; - return zone; -} +static void xfrd_handle_ipc_read(struct event* handler, xfrd_state_t* xfrd); static void ipc_child_quit(struct nsd* nsd) @@ -80,42 +38,27 @@ ipc_child_quit(struct nsd* nsd) #ifdef BIND8_STATS bind8_stats(nsd); #endif /* BIND8_STATS */ + +#if 0 /* OS collects memory pages */ + event_base_free(event_base); + region_destroy(server_region); +#endif server_shutdown(nsd); exit(0); } void -child_handle_parent_command(netio_type *ATTR_UNUSED(netio), - netio_handler_type *handler, - netio_event_types_type event_types) +child_handle_parent_command(int fd, short event, void* arg) { sig_atomic_t mode; int len; struct ipc_handler_conn_data *data = - (struct ipc_handler_conn_data *) handler->user_data; - if (!(event_types & NETIO_EVENT_READ)) { - return; - } - - if(data->conn->is_reading) { - int ret = conn_read(data->conn); - if(ret == -1) { - log_msg(LOG_ERR, "handle_parent_command: error in conn_read: %s", - strerror(errno)); - data->conn->is_reading = 0; - return; - } - if(ret == 0) { - return; /* continue later */ - } - /* completed */ - data->conn->is_reading = 0; - buffer_flip(data->conn->packet); - (void)handle_xfrd_zone_state(data->nsd, data->conn->packet); + (struct ipc_handler_conn_data *) arg; + if (!(event & EV_READ)) { return; } - if ((len = read(handler->fd, &mode, sizeof(mode))) == -1) { + if ((len = read(fd, &mode, sizeof(mode))) == -1) { log_msg(LOG_ERR, "handle_parent_command: read: %s", strerror(errno)); return; @@ -123,7 +66,7 @@ child_handle_parent_command(netio_type *ATTR_UNUSED(netio), if (len == 0) { /* parent closed the connection. Quit */ - data->nsd->mode = NSD_QUIT; + ipc_child_quit(data->nsd); return; } @@ -139,15 +82,22 @@ child_handle_parent_command(netio_type *ATTR_UNUSED(netio), server_close_all_sockets(data->nsd->udp, data->nsd->ifs); server_close_all_sockets(data->nsd->tcp, data->nsd->ifs); /* mode == NSD_QUIT_CHILD */ - (void)write(handler->fd, &mode, sizeof(mode)); + (void)write(fd, &mode, sizeof(mode)); ipc_child_quit(data->nsd); break; - case NSD_ZONE_STATE: - data->conn->is_reading = 1; - data->conn->total_bytes = 0; - data->conn->msglen = 0; - data->conn->fd = handler->fd; - buffer_clear(data->conn->packet); + case NSD_QUIT_WITH_STATS: +#ifdef BIND8_STATS + DEBUG(DEBUG_IPC, 2, (LOG_INFO, "quit QUIT_WITH_STATS")); + /* reply with ack and stats and then quit */ + if(!write_socket(fd, &mode, sizeof(mode))) { + log_msg(LOG_ERR, "cannot write quitwst to parent"); + } + if(!write_socket(fd, &data->nsd->st, sizeof(data->nsd->st))) { + log_msg(LOG_ERR, "cannot write stats to parent"); + } + fsync(fd); +#endif /* BIND8_STATS */ + ipc_child_quit(data->nsd); break; default: log_msg(LOG_ERR, "handle_parent_command: bad mode %d", @@ -169,38 +119,6 @@ parent_handle_xfrd_command(netio_type *ATTR_UNUSED(netio), return; } - if(data->conn->is_reading) { - /* handle ZONE_STATE forward to children */ - int ret = conn_read(data->conn); - size_t i; - zone_type* zone; - if(ret == -1) { - log_msg(LOG_ERR, "main xfrd listener: error in conn_read: %s", - strerror(errno)); - data->conn->is_reading = 0; - return; - } - if(ret == 0) { - return; /* continue later */ - } - /* completed */ - data->conn->is_reading = 0; - buffer_flip(data->conn->packet); - zone = handle_xfrd_zone_state(data->nsd, data->conn->packet); - if(!zone) - return; - /* forward to all children */ - for (i = 0; i < data->nsd->child_count; ++i) { - if(!zone->dirty[i]) { - zone->dirty[i] = 1; - stack_push(data->nsd->children[i].dirty_zones, zone); - data->nsd->children[i].handler->event_types |= - NETIO_EVENT_WRITE; - } - } - return; - } - if ((len = read(handler->fd, &mode, sizeof(mode))) == -1) { log_msg(LOG_ERR, "handle_xfrd_command: read: %s", strerror(errno)); @@ -212,6 +130,7 @@ parent_handle_xfrd_command(netio_type *ATTR_UNUSED(netio), DEBUG(DEBUG_IPC,1, (LOG_INFO, "handle_xfrd_command: xfrd closed channel.")); close(handler->fd); handler->fd = -1; + data->nsd->mode = NSD_SHUTDOWN; return; } @@ -221,18 +140,15 @@ parent_handle_xfrd_command(netio_type *ATTR_UNUSED(netio), data->nsd->signal_hint_reload = 1; break; case NSD_QUIT: + case NSD_SHUTDOWN: data->nsd->mode = mode; break; + case NSD_STATS: + data->nsd->signal_hint_stats = 1; + break; case NSD_REAP_CHILDREN: data->nsd->signal_hint_child = 1; break; - case NSD_ZONE_STATE: - data->conn->is_reading = 1; - data->conn->total_bytes = 0; - data->conn->msglen = 0; - data->conn->fd = handler->fd; - buffer_clear(data->conn->packet); - break; default: log_msg(LOG_ERR, "handle_xfrd_command: bad mode %d", (int) mode); @@ -241,27 +157,6 @@ parent_handle_xfrd_command(netio_type *ATTR_UNUSED(netio), } static void -write_zone_state_packet(buffer_type* packet, zone_type* zone) -{ - sig_atomic_t cmd = NSD_ZONE_STATE; - uint8_t ok = zone->is_ok; - uint16_t sz; - if(!zone->apex) { - return; - } - sz = dname_total_size(domain_dname(zone->apex)) + 1; - sz = htons(sz); - - buffer_clear(packet); - buffer_write(packet, &cmd, sizeof(cmd)); - buffer_write(packet, &sz, sizeof(sz)); - buffer_write(packet, &ok, sizeof(ok)); - buffer_write(packet, domain_dname(zone->apex), - dname_total_size(domain_dname(zone->apex))); - buffer_flip(packet); -} - -static void send_stat_to_child(struct main_ipc_handler_data* data, int fd) { sig_atomic_t cmd = NSD_STATS; @@ -275,6 +170,7 @@ send_stat_to_child(struct main_ipc_handler_data* data, int fd) data->child->need_to_send_STATS = 0; } +#ifndef NDEBUG int packet_read_query_section(buffer_type *packet, uint8_t* dest, uint16_t* qtype, uint16_t* qclass); static void debug_print_fwd_name(int ATTR_UNUSED(len), buffer_type* packet, int acl_num) @@ -297,11 +193,16 @@ debug_print_fwd_name(int ATTR_UNUSED(len), buffer_type* packet, int acl_num) buffer_set_position(packet, bufpos); region_destroy(tempregion); } +#endif static void send_quit_to_child(struct main_ipc_handler_data* data, int fd) { +#ifdef BIND8_STATS + sig_atomic_t cmd = NSD_QUIT_WITH_STATS; +#else sig_atomic_t cmd = NSD_QUIT; +#endif if(write(fd, &cmd, sizeof(cmd)) == -1) { if(errno == EAGAIN || errno == EINTR) return; /* try again later */ @@ -314,6 +215,75 @@ send_quit_to_child(struct main_ipc_handler_data* data, int fd) (int)data->child->pid)); } +/** the child is done, mark it as exited */ +static void +child_is_done(struct nsd* nsd, int fd) +{ + size_t i; + if(fd != -1) close(fd); + for(i=0; i<nsd->child_count; ++i) + if(nsd->children[i].child_fd == fd) { + nsd->children[i].child_fd = -1; + nsd->children[i].has_exited = 1; + nsd->children[i].handler->fd = -1; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "server %d is done", + (int)nsd->children[i].pid)); + } + parent_check_all_children_exited(nsd); +} + +#ifdef BIND8_STATS +/** add stats to total */ +void +stats_add(struct nsdst* total, struct nsdst* s) +{ + unsigned i; + for(i=0; i<sizeof(total->qtype)/sizeof(stc_t); i++) + total->qtype[i] += s->qtype[i]; + for(i=0; i<sizeof(total->qclass)/sizeof(stc_t); i++) + total->qclass[i] += s->qclass[i]; + total->qudp += s->qudp; + total->qudp6 += s->qudp6; + total->ctcp += s->ctcp; + total->ctcp6 += s->ctcp6; + for(i=0; i<sizeof(total->rcode)/sizeof(stc_t); i++) + total->rcode[i] += s->rcode[i]; + for(i=0; i<sizeof(total->opcode)/sizeof(stc_t); i++) + total->opcode[i] += s->opcode[i]; + total->dropped += s->dropped; + total->truncated += s->truncated; + total->wrongzone += s->wrongzone; + total->txerr += s->txerr; + total->rxerr += s->rxerr; + total->edns += s->edns; + total->ednserr += s->ednserr; + total->raxfr += s->raxfr; + total->nona += s->nona; + + total->db_disk = s->db_disk; + total->db_mem = s->db_mem; +} + +#define FINAL_STATS_TIMEOUT 10 /* seconds */ +static void +read_child_stats(struct nsd* nsd, struct nsd_child* child, int fd) +{ + struct nsdst s; + errno=0; + if(block_read(nsd, fd, &s, sizeof(s), FINAL_STATS_TIMEOUT)!=sizeof(s)) { + log_msg(LOG_ERR, "problems reading finalstats from server " + "%d: %s", (int)child->pid, strerror(errno)); + } else { + stats_add(&nsd->st, &s); + child->query_count = s.qudp + s.qudp6 + s.ctcp + s.ctcp6; + /* we know that the child is going to close the connection + * now (this is an ACK of the QUIT_W_STATS so we know the + * child is done, no longer sending e.g. NOTIFY contents) */ + child_is_done(nsd, fd); + } +} +#endif /* BIND8_STATS */ + void parent_handle_child_command(netio_type *ATTR_UNUSED(netio), netio_handler_type *handler, @@ -326,43 +296,14 @@ parent_handle_child_command(netio_type *ATTR_UNUSED(netio), /* do a nonblocking write to the child if it is ready. */ if (event_types & NETIO_EVENT_WRITE) { - if(!data->busy_writing_zone_state && - !data->child->need_to_send_STATS && - !data->child->need_to_send_QUIT && - !data->child->need_to_exit && - data->child->dirty_zones->num > 0) { - /* create packet from next dirty zone */ - zone_type* zone = (zone_type*)stack_pop(data->child->dirty_zones); - assert(zone); - zone->dirty[data->child_num] = 0; - data->busy_writing_zone_state = 1; - write_zone_state_packet(data->write_conn->packet, zone); - data->write_conn->msglen = buffer_limit(data->write_conn->packet); - data->write_conn->total_bytes = sizeof(uint16_t); /* len bytes already in packet */ - data->write_conn->fd = handler->fd; - } - if(data->busy_writing_zone_state) { - /* write more of packet */ - int ret = conn_write(data->write_conn); - if(ret == -1) { - log_msg(LOG_ERR, "handle_child_cmd %d: could not write: %s", - (int)data->child->pid, strerror(errno)); - data->busy_writing_zone_state = 0; - } else if(ret == 1) { - data->busy_writing_zone_state = 0; /* completed */ - } - } else if(data->child->need_to_send_STATS && - !data->child->need_to_exit) { + if(data->child->need_to_send_STATS && + !data->child->need_to_exit) { send_stat_to_child(data, handler->fd); } else if(data->child->need_to_send_QUIT) { send_quit_to_child(data, handler->fd); if(!data->child->need_to_send_QUIT) handler->event_types = NETIO_EVENT_READ; - } - if(!data->busy_writing_zone_state && - !data->child->need_to_send_STATS && - !data->child->need_to_send_QUIT && - data->child->dirty_zones->num == 0) { + } else { handler->event_types = NETIO_EVENT_READ; } } @@ -468,18 +409,7 @@ parent_handle_child_command(netio_type *ATTR_UNUSED(netio), } if (len == 0) { - size_t i; - if(handler->fd != -1) close(handler->fd); - for(i=0; i<data->nsd->child_count; ++i) - if(data->nsd->children[i].child_fd == handler->fd) { - data->nsd->children[i].child_fd = -1; - data->nsd->children[i].has_exited = 1; - DEBUG(DEBUG_IPC,1, (LOG_INFO, - "server %d closed cmd channel", - (int) data->nsd->children[i].pid)); - } - handler->fd = -1; - parent_check_all_children_exited(data->nsd); + child_is_done(data->nsd, handler->fd); return; } @@ -487,6 +417,11 @@ parent_handle_child_command(netio_type *ATTR_UNUSED(netio), case NSD_QUIT: data->nsd->mode = mode; break; +#ifdef BIND8_STATS + case NSD_QUIT_WITH_STATS: + read_child_stats(data->nsd, data->child, handler->fd); + break; +#endif /* BIND8_STATS */ case NSD_STATS: data->nsd->signal_hint_stats = 1; break; @@ -573,33 +508,16 @@ parent_handle_reload_command(netio_type *ATTR_UNUSED(netio), } static void -xfrd_write_expire_notification(buffer_type* buffer, xfrd_zone_t* zone) -{ - sig_atomic_t cmd = NSD_ZONE_STATE; - uint8_t ok = 1; - uint16_t sz = dname_total_size(zone->apex) + 1; - sz = htons(sz); - if(zone->state == xfrd_zone_expired) - ok = 0; - - DEBUG(DEBUG_IPC,1, (LOG_INFO, - "xfrd encoding ipc zone state msg for zone %s state %d.", - zone->apex_str, (int)zone->state)); - - buffer_clear(buffer); - buffer_write(buffer, &cmd, sizeof(cmd)); - buffer_write(buffer, &sz, sizeof(sz)); - buffer_write(buffer, &ok, sizeof(ok)); - buffer_write(buffer, zone->apex, dname_total_size(zone->apex)); - buffer_flip(buffer); -} - -static void xfrd_send_reload_req(xfrd_state_t* xfrd) { sig_atomic_t req = NSD_RELOAD; + uint64_t p = xfrd->last_task->data; + udb_ptr_unlink(xfrd->last_task, xfrd->nsd->task[xfrd->nsd->mytask]); + task_process_sync(xfrd->nsd->task[xfrd->nsd->mytask]); /* ask server_main for a reload */ - if(write(xfrd->ipc_handler.fd, &req, sizeof(req)) == -1) { + if(write(xfrd->ipc_handler.ev_fd, &req, sizeof(req)) == -1) { + udb_ptr_init(xfrd->last_task, xfrd->nsd->task[xfrd->nsd->mytask]); + udb_ptr_set(xfrd->last_task, xfrd->nsd->task[xfrd->nsd->mytask], p); if(errno == EAGAIN || errno == EINTR) return; /* try again later */ log_msg(LOG_ERR, "xfrd: problems sending reload command: %s", @@ -607,21 +525,55 @@ xfrd_send_reload_req(xfrd_state_t* xfrd) return; } DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: asked nsd to reload new updates")); + /* swapped task to other side, start to use other task udb. */ + xfrd->nsd->mytask = 1 - xfrd->nsd->mytask; + task_remap(xfrd->nsd->task[xfrd->nsd->mytask]); + udb_ptr_init(xfrd->last_task, xfrd->nsd->task[xfrd->nsd->mytask]); + assert(udb_base_get_userdata(xfrd->nsd->task[xfrd->nsd->mytask])->data == 0); + xfrd_prepare_zones_for_reload(); xfrd->reload_cmd_last_sent = xfrd_time(); xfrd->need_to_send_reload = 0; xfrd->can_send_reload = 0; } +void +ipc_xfrd_set_listening(struct xfrd_state* xfrd, short mode) +{ + int fd = xfrd->ipc_handler.ev_fd; + struct event_base* base = xfrd->event_base; + event_del(&xfrd->ipc_handler); + event_set(&xfrd->ipc_handler, fd, mode, xfrd_handle_ipc, xfrd); + if(event_base_set(base, &xfrd->ipc_handler) != 0) + log_msg(LOG_ERR, "ipc: cannot set event_base"); + /* no timeout for IPC events */ + if(event_add(&xfrd->ipc_handler, NULL) != 0) + log_msg(LOG_ERR, "ipc: cannot add event"); + xfrd->ipc_handler_flags = mode; +} + +static void +xfrd_send_shutdown_req(xfrd_state_t* xfrd) +{ + sig_atomic_t cmd = NSD_SHUTDOWN; + xfrd->ipc_send_blocked = 1; + ipc_xfrd_set_listening(xfrd, EV_PERSIST|EV_READ); + DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: ipc send shutdown")); + if(!write_socket(xfrd->ipc_handler.ev_fd, &cmd, sizeof(cmd))) { + log_msg(LOG_ERR, "xfrd: error writing shutdown to main: %s", + strerror(errno)); + } + xfrd->need_to_send_shutdown = 0; +} + static void xfrd_send_quit_req(xfrd_state_t* xfrd) { sig_atomic_t cmd = NSD_QUIT; xfrd->ipc_send_blocked = 1; - xfrd->ipc_handler.event_types &= (~NETIO_EVENT_WRITE); - xfrd->sending_zone_state = 0; + ipc_xfrd_set_listening(xfrd, EV_PERSIST|EV_READ); DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: ipc send ackreload(quit)")); - if(!write_socket(xfrd->ipc_handler.fd, &cmd, sizeof(cmd))) { + if(!write_socket(xfrd->ipc_handler.ev_fd, &cmd, sizeof(cmd))) { log_msg(LOG_ERR, "xfrd: error writing ack to main: %s", strerror(errno)); } @@ -629,119 +581,55 @@ xfrd_send_quit_req(xfrd_state_t* xfrd) } static void -xfrd_handle_ipc_SOAINFO(xfrd_state_t* xfrd, buffer_type* packet) +xfrd_send_stats(xfrd_state_t* xfrd) { - xfrd_soa_t soa; - xfrd_soa_t* soa_ptr = &soa; - xfrd_zone_t* zone; - /* dname is sent in memory format */ - const dname_type* dname = (const dname_type*)buffer_begin(packet); - - /* find zone and decode SOA */ - zone = (xfrd_zone_t*)rbtree_search(xfrd->zones, dname); - buffer_skip(packet, dname_total_size(dname)); - - if(!buffer_available(packet, sizeof(uint32_t)*6 + sizeof(uint8_t)*2)) { - /* NSD has zone without any info */ - DEBUG(DEBUG_IPC,1, (LOG_INFO, "SOAINFO for %s lost zone", - dname_to_string(dname,0))); - soa_ptr = NULL; - } else { - /* read soa info */ - memset(&soa, 0, sizeof(soa)); - /* left out type, klass, count for speed */ - soa.type = htons(TYPE_SOA); - soa.klass = htons(CLASS_IN); - soa.ttl = htonl(buffer_read_u32(packet)); - soa.rdata_count = htons(7); - soa.prim_ns[0] = buffer_read_u8(packet); - if(!buffer_available(packet, soa.prim_ns[0])) - return; - buffer_read(packet, soa.prim_ns+1, soa.prim_ns[0]); - soa.email[0] = buffer_read_u8(packet); - if(!buffer_available(packet, soa.email[0])) - return; - buffer_read(packet, soa.email+1, soa.email[0]); - - soa.serial = htonl(buffer_read_u32(packet)); - soa.refresh = htonl(buffer_read_u32(packet)); - soa.retry = htonl(buffer_read_u32(packet)); - soa.expire = htonl(buffer_read_u32(packet)); - soa.minimum = htonl(buffer_read_u32(packet)); - DEBUG(DEBUG_IPC,1, (LOG_INFO, "SOAINFO for %s %u", - dname_to_string(dname,0), ntohl(soa.serial))); - } - - if(!zone) { - DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: zone %s master zone updated", - dname_to_string(dname,0))); - notify_handle_master_zone_soainfo(xfrd->notify_zones, - dname, soa_ptr); - return; + sig_atomic_t cmd = NSD_STATS; + DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: ipc send stats")); + if(!write_socket(xfrd->ipc_handler.ev_fd, &cmd, sizeof(cmd))) { + log_msg(LOG_ERR, "xfrd: error writing stats to main: %s", + strerror(errno)); } - xfrd_handle_incoming_soa(zone, soa_ptr, xfrd_time()); + xfrd->need_to_send_stats = 0; } void -xfrd_handle_ipc(netio_type* ATTR_UNUSED(netio), - netio_handler_type *handler, - netio_event_types_type event_types) +xfrd_handle_ipc(int ATTR_UNUSED(fd), short event, void* arg) { - xfrd_state_t* xfrd = (xfrd_state_t*)handler->user_data; - if ((event_types & NETIO_EVENT_READ)) + xfrd_state_t* xfrd = (xfrd_state_t*)arg; + if ((event & EV_READ)) { /* first attempt to read as a signal from main * could block further send operations */ - xfrd_handle_ipc_read(handler, xfrd); + xfrd_handle_ipc_read(&xfrd->ipc_handler, xfrd); } - if ((event_types & NETIO_EVENT_WRITE)) + if ((event & EV_WRITE)) { - if(xfrd->ipc_send_blocked) { /* wait for SOA_END */ - handler->event_types = NETIO_EVENT_READ; + if(xfrd->ipc_send_blocked) { /* wait for RELOAD_DONE */ + ipc_xfrd_set_listening(xfrd, EV_PERSIST|EV_READ); return; } - /* if necessary prepare a packet */ - if(!(xfrd->can_send_reload && xfrd->need_to_send_reload) && - !xfrd->need_to_send_quit && - !xfrd->sending_zone_state && - xfrd->dirty_zones->num > 0) { - xfrd_zone_t* zone = (xfrd_zone_t*)stack_pop(xfrd->dirty_zones); - assert(zone); - zone->dirty = 0; - xfrd->sending_zone_state = 1; - xfrd_write_expire_notification(xfrd->ipc_conn_write->packet, zone); - xfrd->ipc_conn_write->msglen = buffer_limit(xfrd->ipc_conn_write->packet); - /* skip length bytes; they are encoded in the packet, after cmd */ - xfrd->ipc_conn_write->total_bytes = sizeof(uint16_t); - } - /* write a bit */ - if(xfrd->sending_zone_state) { - /* call conn_write */ - int ret = conn_write(xfrd->ipc_conn_write); - if(ret == -1) { - log_msg(LOG_ERR, "xfrd: error in write ipc: %s", strerror(errno)); - xfrd->sending_zone_state = 0; - } - else if(ret == 1) { /* done */ - xfrd->sending_zone_state = 0; - } + if(xfrd->need_to_send_shutdown) { + xfrd_send_shutdown_req(xfrd); } else if(xfrd->need_to_send_quit) { xfrd_send_quit_req(xfrd); } else if(xfrd->can_send_reload && xfrd->need_to_send_reload) { xfrd_send_reload_req(xfrd); + } else if(xfrd->need_to_send_stats) { + xfrd_send_stats(xfrd); } if(!(xfrd->can_send_reload && xfrd->need_to_send_reload) && + !xfrd->need_to_send_shutdown && !xfrd->need_to_send_quit && - !xfrd->sending_zone_state && - xfrd->dirty_zones->num == 0) { - handler->event_types = NETIO_EVENT_READ; /* disable writing for now */ + !xfrd->need_to_send_stats) { + /* disable writing for now */ + ipc_xfrd_set_listening(xfrd, EV_PERSIST|EV_READ); } } } static void -xfrd_handle_ipc_read(netio_handler_type *handler, xfrd_state_t* xfrd) +xfrd_handle_ipc_read(struct event* handler, xfrd_state_t* xfrd) { sig_atomic_t cmd; int len; @@ -770,6 +658,7 @@ xfrd_handle_ipc_read(netio_handler_type *handler, xfrd_state_t* xfrd) } if(xfrd->ipc_conn->is_reading) { /* reading an IPC message */ + buffer_type* tmp; int ret = conn_read(xfrd->ipc_conn); if(ret == -1) { log_msg(LOG_ERR, "xfrd: error in read ipc: %s", strerror(errno)); @@ -779,26 +668,22 @@ xfrd_handle_ipc_read(netio_handler_type *handler, xfrd_state_t* xfrd) if(ret == 0) return; buffer_flip(xfrd->ipc_conn->packet); - if(xfrd->ipc_is_soa) { - xfrd->ipc_conn->is_reading = 0; - xfrd_handle_ipc_SOAINFO(xfrd, xfrd->ipc_conn->packet); - } else { - /* use ipc_conn to read remaining data as well */ - buffer_type* tmp = xfrd->ipc_pass; - xfrd->ipc_conn->is_reading=2; - xfrd->ipc_pass = xfrd->ipc_conn->packet; - xfrd->ipc_conn->packet = tmp; - xfrd->ipc_conn->total_bytes = sizeof(xfrd->ipc_conn->msglen); - xfrd->ipc_conn->msglen = 2*sizeof(uint32_t); - buffer_clear(xfrd->ipc_conn->packet); - buffer_set_limit(xfrd->ipc_conn->packet, xfrd->ipc_conn->msglen); - } + /* use ipc_conn to read remaining data as well */ + tmp = xfrd->ipc_pass; + xfrd->ipc_conn->is_reading=2; + xfrd->ipc_pass = xfrd->ipc_conn->packet; + xfrd->ipc_conn->packet = tmp; + xfrd->ipc_conn->total_bytes = sizeof(xfrd->ipc_conn->msglen); + xfrd->ipc_conn->msglen = 2*sizeof(uint32_t); + buffer_clear(xfrd->ipc_conn->packet); + buffer_set_limit(xfrd->ipc_conn->packet, xfrd->ipc_conn->msglen); return; } - if((len = read(handler->fd, &cmd, sizeof(cmd))) == -1) { - log_msg(LOG_ERR, "xfrd_handle_ipc: read: %s", - strerror(errno)); + if((len = read(handler->ev_fd, &cmd, sizeof(cmd))) == -1) { + if(errno != EINTR && errno != EAGAIN) + log_msg(LOG_ERR, "xfrd_handle_ipc: read: %s", + strerror(errno)); return; } if(len == 0) @@ -812,48 +697,49 @@ xfrd_handle_ipc_read(netio_handler_type *handler, xfrd_state_t* xfrd) switch(cmd) { case NSD_QUIT: case NSD_SHUTDOWN: - DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: main send shutdown cmd.")); + DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: main sent shutdown cmd.")); xfrd->shutdown = 1; break; - case NSD_SOA_BEGIN: - DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: ipc recv SOA_BEGIN")); - /* reload starts sending SOA INFOs; don't block */ - xfrd->parent_soa_info_pass = 1; - /* reset the nonblocking ipc write; - the new parent does not want half a packet */ - xfrd->sending_zone_state = 0; - break; - case NSD_SOA_INFO: - DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: ipc recv SOA_INFO")); - assert(xfrd->parent_soa_info_pass); - xfrd->ipc_is_soa = 1; - xfrd->ipc_conn->is_reading = 1; - break; - case NSD_SOA_END: + case NSD_RELOAD_DONE: /* reload has finished */ - DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: ipc recv SOA_END")); + DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: ipc recv RELOAD_DONE")); +#ifdef BIND8_STATS + if(block_read(NULL, handler->ev_fd, &xfrd->reload_pid, + sizeof(pid_t), -1) != sizeof(pid_t)) { + log_msg(LOG_ERR, "xfrd cannot get reload_pid"); + } +#endif /* BIND8_STATS */ + /* read the not-mytask for the results and soainfo */ + xfrd_process_task_result(xfrd, + xfrd->nsd->task[1-xfrd->nsd->mytask]); + /* reset the IPC, (and the nonblocking ipc write; + the new parent does not want half a packet) */ xfrd->can_send_reload = 1; - xfrd->parent_soa_info_pass = 0; xfrd->ipc_send_blocked = 0; - handler->event_types |= NETIO_EVENT_WRITE; + ipc_xfrd_set_listening(xfrd, EV_PERSIST|EV_READ|EV_WRITE); xfrd_reopen_logfile(); xfrd_check_failed_updates(); - xfrd_send_expy_all_zones(); break; case NSD_PASS_TO_XFRD: DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: ipc recv PASS_TO_XFRD")); - xfrd->ipc_is_soa = 0; xfrd->ipc_conn->is_reading = 1; break; + case NSD_RELOAD_REQ: + DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: ipc recv RELOAD_REQ")); + /* make reload happen, right away, and schedule file check */ + task_new_check_zonefiles(xfrd->nsd->task[xfrd->nsd->mytask], + xfrd->last_task, NULL); + xfrd_set_reload_now(xfrd); + break; case NSD_RELOAD: /* main tells us that reload is done, stop ipc send to main */ DEBUG(DEBUG_IPC,1, (LOG_INFO, "xfrd: ipc recv RELOAD")); - handler->event_types |= NETIO_EVENT_WRITE; + ipc_xfrd_set_listening(xfrd, EV_PERSIST|EV_READ|EV_WRITE); xfrd->need_to_send_quit = 1; break; default: log_msg(LOG_ERR, "xfrd_handle_ipc: bad mode %d (%d)", (int)cmd, - ntohl(cmd)); + (int)ntohl(cmd)); break; } @@ -864,4 +750,3 @@ xfrd_handle_ipc_read(netio_handler_type *handler, xfrd_state_t* xfrd) buffer_clear(xfrd->ipc_conn->packet); } } - diff --git a/usr.sbin/nsd/ipc.h b/usr.sbin/nsd/ipc.h index 0bd02e32b72..cb27db46063 100644 --- a/usr.sbin/nsd/ipc.h +++ b/usr.sbin/nsd/ipc.h @@ -1,7 +1,7 @@ /* * ipc.h - Interprocess communication routines. Handlers read and write. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -10,12 +10,14 @@ #ifndef NSD_IPC_H #define NSD_IPC_H -#include "config.h" #include "netio.h" struct buffer; struct nsd; struct nsd_child; struct xfrd_tcp; +struct xfrd_state; +struct nsdst; +struct event; /* * Data for the server_main IPC handler @@ -35,10 +37,6 @@ struct main_ipc_handler_data uint16_t total_bytes; uint32_t acl_num; int32_t acl_xfr; - - /* writing data, connection and state */ - uint8_t busy_writing_zone_state; - struct xfrd_tcp *write_conn; }; /* @@ -78,17 +76,21 @@ void parent_handle_child_command(netio_type *netio, * Routine used by server_child. * Handle a command received from the parent process. */ -void child_handle_parent_command(netio_type *netio, - netio_handler_type *handler, netio_event_types_type event_types); +void child_handle_parent_command(int fd, short event, void* arg); /* * Routine used by xfrd * Handle interprocess communication with parent process, read and write. */ -void xfrd_handle_ipc(netio_type *netio, - netio_handler_type *handler, netio_event_types_type event_types); +void xfrd_handle_ipc(int fd, short event, void* arg); /* check if all children have exited in an orderly fashion and set mode */ void parent_check_all_children_exited(struct nsd* nsd); +/** add stats to total */ +void stats_add(struct nsdst* total, struct nsdst* s); + +/** set event to listen to given mode, no timeout, must be added already */ +void ipc_xfrd_set_listening(struct xfrd_state* xfrd, short mode); + #endif /* NSD_IPC_H */ diff --git a/usr.sbin/nsd/iterated_hash.c b/usr.sbin/nsd/iterated_hash.c index 4211f503c25..e8606a3b06c 100644 --- a/usr.sbin/nsd/iterated_hash.c +++ b/usr.sbin/nsd/iterated_hash.c @@ -1,7 +1,7 @@ /* * iterated_hash.c -- nsec3 hash calculation. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * diff --git a/usr.sbin/nsd/iterated_hash.h b/usr.sbin/nsd/iterated_hash.h index 2a6bef399d0..9997e62598b 100644 --- a/usr.sbin/nsd/iterated_hash.h +++ b/usr.sbin/nsd/iterated_hash.h @@ -1,7 +1,7 @@ /* * iterated_hash.h -- nsec3 hash calculation. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -10,10 +10,11 @@ #ifndef ITERATED_HASH_H #define ITERATED_HASH_H -#include "config.h" #ifdef NSEC3 #include <openssl/sha.h> +#define NSEC3_SHA1_HASH 1 /* same type code as DS hash */ + int iterated_hash(unsigned char out[SHA_DIGEST_LENGTH], const unsigned char *salt,int saltlength, const unsigned char *in,int inlength,int iterations); diff --git a/usr.sbin/nsd/mini_event.c b/usr.sbin/nsd/mini_event.c new file mode 100644 index 00000000000..4048bcfae89 --- /dev/null +++ b/usr.sbin/nsd/mini_event.c @@ -0,0 +1,446 @@ +/* + * mini_event.c - implementation of part of libevent api, portably. + * + * Copyright (c) 2007, NLnet Labs. All rights reserved. + * + * This software is open source. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of the NLNET LABS nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * + */ + +/** + * \file + * fake libevent implementation. Less broad in functionality, and only + * supports select(2). + */ + +#include "config.h" +#ifdef HAVE_TIME_H +#include <time.h> +#endif +#include <string.h> +#include <errno.h> +#include <sys/time.h> + +#if defined(USE_MINI_EVENT) && !defined(USE_WINSOCK) +#ifdef HAVE_WINSOCK2_H +#define FD_SET_T (u_int) +#else +#define FD_SET_T +#endif + +#include <signal.h> +#include "mini_event.h" +#include "util.h" + +/** compare events in tree, based on timevalue, ptr for uniqueness */ +int +mini_ev_cmp(const void* a, const void* b) +{ + const struct event* e = (const struct event*)a; + const struct event* f = (const struct event*)b; + if(e->ev_timeout.tv_sec < f->ev_timeout.tv_sec) + return -1; + if(e->ev_timeout.tv_sec > f->ev_timeout.tv_sec) + return 1; + if(e->ev_timeout.tv_usec < f->ev_timeout.tv_usec) + return -1; + if(e->ev_timeout.tv_usec > f->ev_timeout.tv_usec) + return 1; + if(e < f) + return -1; + if(e > f) + return 1; + return 0; +} + +/** set time */ +static int +settime(struct event_base* base) +{ + if(gettimeofday(base->time_tv, NULL) < 0) { + return -1; + } +#ifndef S_SPLINT_S + *base->time_secs = (time_t)base->time_tv->tv_sec; +#endif + return 0; +} + +/** create event base */ +void * +event_init(time_t* time_secs, struct timeval* time_tv) +{ + struct event_base* base = (struct event_base*)malloc( + sizeof(struct event_base)); + if(!base) + return NULL; + memset(base, 0, sizeof(*base)); + base->region = region_create(xalloc, free); + if(!base->region) { + free(base); + return NULL; + } + base->time_secs = time_secs; + base->time_tv = time_tv; + if(settime(base) < 0) { + event_base_free(base); + return NULL; + } + base->times = rbtree_create(base->region, mini_ev_cmp); + if(!base->times) { + event_base_free(base); + return NULL; + } + base->capfd = MAX_FDS; +#ifdef FD_SETSIZE + if((int)FD_SETSIZE < base->capfd) + base->capfd = (int)FD_SETSIZE; +#endif + base->fds = (struct event**)calloc((size_t)base->capfd, + sizeof(struct event*)); + if(!base->fds) { + event_base_free(base); + return NULL; + } + base->signals = (struct event**)calloc(MAX_SIG, sizeof(struct event*)); + if(!base->signals) { + event_base_free(base); + return NULL; + } +#ifndef S_SPLINT_S + FD_ZERO(&base->reads); + FD_ZERO(&base->writes); +#endif + return base; +} + +/** get version */ +const char * +event_get_version(void) +{ + return "mini-event-"PACKAGE_VERSION; +} + +/** get polling method, select */ +const char * +event_get_method(void) +{ + return "select"; +} + +/** call timeouts handlers, and return how long to wait for next one or -1 */ +static int +handle_timeouts(struct event_base* base, struct timeval* now, + struct timeval* wait) +{ + struct event* p; + int tofired = 0; +#ifndef S_SPLINT_S + wait->tv_sec = (time_t)-1; +#endif + + while((rbnode_t*)(p = (struct event*)rbtree_first(base->times)) + !=RBTREE_NULL) { +#ifndef S_SPLINT_S + if(p->ev_timeout.tv_sec > now->tv_sec || + (p->ev_timeout.tv_sec==now->tv_sec && + p->ev_timeout.tv_usec > now->tv_usec)) { + /* there is a next larger timeout. wait for it */ + wait->tv_sec = p->ev_timeout.tv_sec - now->tv_sec; + if(now->tv_usec > p->ev_timeout.tv_usec) { + wait->tv_sec--; + wait->tv_usec = 1000000 - (now->tv_usec - + p->ev_timeout.tv_usec); + } else { + wait->tv_usec = p->ev_timeout.tv_usec + - now->tv_usec; + } + return tofired; + } +#endif + /* event times out, remove it */ + tofired = 1; + (void)rbtree_delete(base->times, p); + p->ev_flags &= ~EV_TIMEOUT; + (*p->ev_callback)(p->ev_fd, EV_TIMEOUT, p->ev_arg); + } + return tofired; +} + +/** call select and callbacks for that */ +static int +handle_select(struct event_base* base, struct timeval* wait) +{ + fd_set r, w; + int ret, i; + +#ifndef S_SPLINT_S + if(wait->tv_sec==(time_t)-1) + wait = NULL; +#endif + memmove(&r, &base->reads, sizeof(fd_set)); + memmove(&w, &base->writes, sizeof(fd_set)); + memmove(&base->ready, &base->content, sizeof(fd_set)); + + if((ret = select(base->maxfd+1, &r, &w, NULL, wait)) == -1) { + ret = errno; + if(settime(base) < 0) + return -1; + errno = ret; + if(ret == EAGAIN || ret == EINTR) + return 0; + return -1; + } + if(settime(base) < 0) + return -1; + + for(i=0; i<base->maxfd+1; i++) { + short bits = 0; + if(!base->fds[i] || !(FD_ISSET(i, &base->ready))) { + continue; + } + if(FD_ISSET(i, &r)) { + bits |= EV_READ; + ret--; + } + if(FD_ISSET(i, &w)) { + bits |= EV_WRITE; + ret--; + } + bits &= base->fds[i]->ev_flags; + if(bits) { + (*base->fds[i]->ev_callback)(base->fds[i]->ev_fd, + bits, base->fds[i]->ev_arg); + if(ret==0) + break; + } + } + return 0; +} + +/** run select once */ +int +event_base_loop(struct event_base* base, int flags) +{ + struct timeval wait; + if(!(flags & EVLOOP_ONCE)) + return event_base_dispatch(base); + /* see if timeouts need handling */ + if(handle_timeouts(base, base->time_tv, &wait)) + return 0; /* there were timeouts, end of loop */ + if(base->need_to_exit) + return 0; + /* do select */ + if(handle_select(base, &wait) < 0) { + if(base->need_to_exit) + return 0; + return -1; + } + return 0; +} + +/** run select in a loop */ +int +event_base_dispatch(struct event_base* base) +{ + struct timeval wait; + if(settime(base) < 0) + return -1; + while(!base->need_to_exit) + { + /* see if timeouts need handling */ + (void)handle_timeouts(base, base->time_tv, &wait); + if(base->need_to_exit) + return 0; + /* do select */ + if(handle_select(base, &wait) < 0) { + if(base->need_to_exit) + return 0; + return -1; + } + } + return 0; +} + +/** exit that loop */ +int +event_base_loopexit(struct event_base* base, + struct timeval* ATTR_UNUSED(tv)) +{ + base->need_to_exit = 1; + return 0; +} + +/* free event base, free events yourself */ +void +event_base_free(struct event_base* base) +{ + if(!base) + return; + if(base->times) + free(base->times); + if(base->fds) + free(base->fds); + if(base->signals) + free(base->signals); + region_destroy(base->region); + free(base); +} + +/** set content of event */ +void +event_set(struct event* ev, int fd, short bits, + void (*cb)(int, short, void *), void* arg) +{ + ev->node.key = ev; + ev->ev_fd = fd; + ev->ev_flags = bits; + ev->ev_callback = cb; + ev->ev_arg = arg; + ev->added = 0; +} + +/* add event to a base */ +int +event_base_set(struct event_base* base, struct event* ev) +{ + ev->ev_base = base; + ev->added = 0; + return 0; +} + +/* add event to make it active, you may not change it with event_set anymore */ +int +event_add(struct event* ev, struct timeval* tv) +{ + if(ev->added) + event_del(ev); + if(ev->ev_fd != -1 && ev->ev_fd >= ev->ev_base->capfd) + return -1; + if( (ev->ev_flags&(EV_READ|EV_WRITE)) && ev->ev_fd != -1) { + ev->ev_base->fds[ev->ev_fd] = ev; + if(ev->ev_flags&EV_READ) { + FD_SET(FD_SET_T ev->ev_fd, &ev->ev_base->reads); + } + if(ev->ev_flags&EV_WRITE) { + FD_SET(FD_SET_T ev->ev_fd, &ev->ev_base->writes); + } + FD_SET(FD_SET_T ev->ev_fd, &ev->ev_base->content); + FD_CLR(FD_SET_T ev->ev_fd, &ev->ev_base->ready); + if(ev->ev_fd > ev->ev_base->maxfd) + ev->ev_base->maxfd = ev->ev_fd; + } + if(tv && (ev->ev_flags&EV_TIMEOUT)) { +#ifndef S_SPLINT_S + struct timeval* now = ev->ev_base->time_tv; + ev->ev_timeout.tv_sec = tv->tv_sec + now->tv_sec; + ev->ev_timeout.tv_usec = tv->tv_usec + now->tv_usec; + while(ev->ev_timeout.tv_usec > 1000000) { + ev->ev_timeout.tv_usec -= 1000000; + ev->ev_timeout.tv_sec++; + } +#endif + (void)rbtree_insert(ev->ev_base->times, &ev->node); + } + ev->added = 1; + return 0; +} + +/* remove event, you may change it again */ +int +event_del(struct event* ev) +{ + if(ev->ev_fd != -1 && ev->ev_fd >= ev->ev_base->capfd) + return -1; + if((ev->ev_flags&EV_TIMEOUT)) + (void)rbtree_delete(ev->ev_base->times, &ev->node); + if((ev->ev_flags&(EV_READ|EV_WRITE)) && ev->ev_fd != -1) { + ev->ev_base->fds[ev->ev_fd] = NULL; + FD_CLR(FD_SET_T ev->ev_fd, &ev->ev_base->reads); + FD_CLR(FD_SET_T ev->ev_fd, &ev->ev_base->writes); + FD_CLR(FD_SET_T ev->ev_fd, &ev->ev_base->ready); + FD_CLR(FD_SET_T ev->ev_fd, &ev->ev_base->content); + } + ev->added = 0; + return 0; +} + +/** which base gets to handle signals */ +static struct event_base* signal_base = NULL; + +/** signal handler */ +static RETSIGTYPE +sigh(int sig) +{ + struct event* ev; + if(!signal_base || sig < 0 || sig >= MAX_SIG) + return; + ev = signal_base->signals[sig]; + if(!ev) + return; + (*ev->ev_callback)(sig, EV_SIGNAL, ev->ev_arg); +} + +/** install signal handler */ +int +signal_add(struct event* ev, struct timeval* ATTR_UNUSED(tv)) +{ + struct sigaction action; + if(ev->ev_fd == -1 || ev->ev_fd >= MAX_SIG) + return -1; + signal_base = ev->ev_base; + ev->ev_base->signals[ev->ev_fd] = ev; + ev->added = 1; + action.sa_handler = sigh; + sigfillset(&action.sa_mask); + action.sa_flags = 0; + return sigaction(ev->ev_fd, &action, NULL); +} + +/** remove signal handler */ +int +signal_del(struct event* ev) +{ + if(ev->ev_fd == -1 || ev->ev_fd >= MAX_SIG) + return -1; + ev->ev_base->signals[ev->ev_fd] = NULL; + ev->added = 0; + return 0; +} + +#else /* USE_MINI_EVENT */ +#ifndef USE_WINSOCK +int +mini_ev_cmp(const void* ATTR_UNUSED(a), const void* ATTR_UNUSED(b)) +{ + return 0; +} +#endif /* not USE_WINSOCK */ +#endif /* USE_MINI_EVENT */ diff --git a/usr.sbin/nsd/mini_event.h b/usr.sbin/nsd/mini_event.h new file mode 100644 index 00000000000..b40983b6479 --- /dev/null +++ b/usr.sbin/nsd/mini_event.h @@ -0,0 +1,183 @@ +/* + * mini-event.h - micro implementation of libevent api, using select() only. + * + * Copyright (c) 2007, NLnet Labs. All rights reserved. + * + * This software is open source. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of the NLNET LABS nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * \file + * This file implements part of the event(3) libevent api. + * The back end is only select. Max number of fds is limited. + * Max number of signals is limited, one handler per signal only. + * And one handler per fd. + * + * Although limited to select() and a max (1024) open fds, it + * is efficient: + * o dispatch call caches fd_sets to use. + * o handler calling takes time ~ to the number of fds. + * o timeouts are stored in a redblack tree, sorted, so take log(n). + * Timeouts are only accurate to the second (no subsecond accuracy). + * To avoid cpu hogging, fractional timeouts are rounded up to a whole second. + */ + +#ifndef MINI_EVENT_H +#define MINI_EVENT_H +struct region; + +#if defined(USE_MINI_EVENT) && !defined(USE_WINSOCK) + +#ifndef HAVE_EVENT_BASE_FREE +#define HAVE_EVENT_BASE_FREE +#endif + +/** event timeout */ +#define EV_TIMEOUT 0x01 +/** event fd readable */ +#define EV_READ 0x02 +/** event fd writable */ +#define EV_WRITE 0x04 +/** event signal */ +#define EV_SIGNAL 0x08 +/** event must persist */ +#define EV_PERSIST 0x10 + +/* needs our redblack tree */ +#include "rbtree.h" + +/** max number of file descriptors to support */ +#define MAX_FDS 1024 +/** max number of signals to support */ +#define MAX_SIG 32 + +/** event base */ +struct event_base +{ + /** sorted by timeout (absolute), ptr */ + rbtree_t* times; + /** array of 0 - maxfd of ptr to event for it */ + struct event** fds; + /** max fd in use */ + int maxfd; + /** capacity - size of the fds array */ + int capfd; + /* fdset for read write, for fds ready, and added */ + fd_set + /** fds for reading */ + reads, + /** fds for writing */ + writes, + /** fds determined ready for use */ + ready, + /** ready plus newly added events. */ + content; + /** array of 0 - maxsig of ptr to event for it */ + struct event** signals; + /** if we need to exit */ + int need_to_exit; + /** where to store time in seconds */ + time_t* time_secs; + /** where to store time in microseconds */ + struct timeval* time_tv; + /** region for allocation */ + struct region* region; +}; + +/** + * Event structure. Has some of the event elements. + */ +struct event { + /** node in timeout rbtree */ + rbnode_t node; + /** is event already added */ + int added; + + /** event base it belongs to */ + struct event_base *ev_base; + /** fd to poll or -1 for timeouts. signal number for sigs. */ + int ev_fd; + /** what events this event is interested in, see EV_.. above. */ + short ev_flags; + /** timeout value */ + struct timeval ev_timeout; + + /** callback to call: fd, eventbits, userarg */ + void (*ev_callback)(int, short, void *arg); + /** callback user arg */ + void *ev_arg; +}; + +/* function prototypes (some are as they appear in event.h) */ +/** create event base */ +void *event_init(time_t* time_secs, struct timeval* time_tv); +/** get version */ +const char *event_get_version(void); +/** get polling method, select */ +const char *event_get_method(void); +/** run select in a loop */ +int event_base_dispatch(struct event_base *); +/** exit that loop */ +int event_base_loopexit(struct event_base *, struct timeval *); +/** run select once */ +#define EVLOOP_ONCE 1 +int event_base_loop(struct event_base* base, int flags); +/** free event base. Free events yourself */ +void event_base_free(struct event_base *); +/** set content of event */ +void event_set(struct event *, int, short, void (*)(int, short, void *), void *); +/** add event to a base. You *must* call this for every event. */ +int event_base_set(struct event_base *, struct event *); +/** add event to make it active. You may not change it with event_set anymore */ +int event_add(struct event *, struct timeval *); +/** remove event. You may change it again */ +int event_del(struct event *); + +/** add a timer */ +#define evtimer_add(ev, tv) event_add(ev, tv) +/** remove a timer */ +#define evtimer_del(ev) event_del(ev) + +/* uses different implementation. Cannot mix fd/timeouts and signals inside + * the same struct event. create several event structs for that. */ +/** install signal handler */ +int signal_add(struct event *, struct timeval *); +/** set signal event contents */ +#define signal_set(ev, x, cb, arg) \ + event_set(ev, x, EV_SIGNAL|EV_PERSIST, cb, arg) +/** remove signal handler */ +int signal_del(struct event *); + +#endif /* USE_MINI_EVENT and not USE_WINSOCK */ + +/** compare events in tree, based on timevalue, ptr for uniqueness */ +int mini_ev_cmp(const void* a, const void* b); + +#endif /* MINI_EVENT_H */ diff --git a/usr.sbin/nsd/namedb.c b/usr.sbin/nsd/namedb.c index 5ed3b31baf6..5ffb6ff10dd 100644 --- a/usr.sbin/nsd/namedb.c +++ b/usr.sbin/nsd/namedb.c @@ -1,7 +1,7 @@ /* * namedb.c -- common namedb operations. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -16,14 +16,14 @@ #include <limits.h> #include <stdio.h> #include <string.h> -#include <errno.h> #include "namedb.h" +#include "nsec3.h" static domain_type * -allocate_domain_info(domain_table_type *table, - const dname_type *dname, - domain_type *parent) +allocate_domain_info(domain_table_type* table, + const dname_type* dname, + domain_type* parent) { domain_type *result; @@ -33,70 +33,312 @@ allocate_domain_info(domain_table_type *table, result = (domain_type *) region_alloc(table->region, sizeof(domain_type)); - result->node.key = dname_partial_copy( + result->dname = dname_partial_copy( table->region, dname, domain_dname(parent)->label_count + 1); result->parent = parent; - result->nextdiff = NULL; result->wildcard_child_closest_match = result; result->rrsets = NULL; - result->number = 0; + result->usage = 0; #ifdef NSEC3 - result->nsec3_cover = NULL; -#ifdef FULL_PREHASH - result->nsec3_wcard_child_cover = NULL; - result->nsec3_ds_parent_cover = NULL; - result->nsec3_lookup = NULL; - result->nsec3_is_exact = 0; - result->nsec3_ds_parent_is_exact = 0; -#endif /* FULL_PREHASH */ -#endif /* NSEC3 */ + result->nsec3 = NULL; +#endif result->is_existing = 0; result->is_apex = 0; - result->has_SOA = 0; + assert(table->numlist_last); /* it exists because root exists */ + /* push this domain at the end of the numlist */ + result->number = table->numlist_last->number+1; + result->numlist_next = NULL; + result->numlist_prev = table->numlist_last; + table->numlist_last->numlist_next = result; + table->numlist_last = result; return result; } +#ifdef NSEC3 +void +allocate_domain_nsec3(domain_table_type* table, domain_type* result) +{ + if(result->nsec3) + return; + result->nsec3 = (struct nsec3_domain_data*) region_alloc(table->region, + sizeof(struct nsec3_domain_data)); + result->nsec3->nsec3_cover = NULL; + result->nsec3->nsec3_wcard_child_cover = NULL; + result->nsec3->nsec3_ds_parent_cover = NULL; + result->nsec3->nsec3_is_exact = 0; + result->nsec3->nsec3_ds_parent_is_exact = 0; + result->nsec3->have_nsec3_hash = 0; + result->nsec3->have_nsec3_wc_hash = 0; + result->nsec3->have_nsec3_ds_parent_hash = 0; + result->nsec3->prehash_prev = NULL; + result->nsec3->prehash_next = NULL; + result->nsec3->nsec3_node.key = NULL; + result->nsec3->hash_node.key = NULL; + result->nsec3->wchash_node.key = NULL; + result->nsec3->dshash_node.key = NULL; +} +#endif /* NSEC3 */ + +/** make the domain last in the numlist, changes numbers of domains */ +static void +numlist_make_last(domain_table_type* table, domain_type* domain) +{ + size_t sw; + domain_type* last = table->numlist_last; + if(domain == last) + return; + /* swap numbers with the last element */ + sw = domain->number; + domain->number = last->number; + last->number = sw; + /* swap list position with the last element */ + assert(domain->numlist_next); + assert(last->numlist_prev); + if(domain->numlist_next != last) { + /* case 1: there are nodes between domain .. last */ + domain_type* span_start = domain->numlist_next; + domain_type* span_end = last->numlist_prev; + /* these assignments walk the new list from start to end */ + if(domain->numlist_prev) + domain->numlist_prev->numlist_next = last; + last->numlist_prev = domain->numlist_prev; + last->numlist_next = span_start; + span_start->numlist_prev = last; + span_end->numlist_next = domain; + domain->numlist_prev = span_end; + domain->numlist_next = NULL; + } else { + /* case 2: domain and last are neighbors */ + /* these assignments walk the new list from start to end */ + if(domain->numlist_prev) + domain->numlist_prev->numlist_next = last; + last->numlist_prev = domain->numlist_prev; + last->numlist_next = domain; + domain->numlist_prev = last; + domain->numlist_next = NULL; + } + table->numlist_last = domain; +} + +/** pop the biggest domain off the numlist */ +static domain_type* +numlist_pop_last(domain_table_type* table) +{ + domain_type* d = table->numlist_last; + table->numlist_last = table->numlist_last->numlist_prev; + if(table->numlist_last) + table->numlist_last->numlist_next = NULL; + return d; +} + +/** see if a domain is eligible to be deleted, and thus is not used */ +static int +domain_can_be_deleted(domain_type* domain) +{ + domain_type* n; + /* it has data or it has usage, do not delete it */ + if(domain->rrsets) return 0; + if(domain->usage) return 0; + n = domain_next(domain); + /* it has children domains, do not delete it */ + if(n && domain_is_subdomain(n, domain)) + return 0; + return 1; +} + +#ifdef NSEC3 +/** see if domain is on the prehash list */ +int domain_is_prehash(domain_table_type* table, domain_type* domain) +{ + if(domain->nsec3 + && (domain->nsec3->prehash_prev || domain->nsec3->prehash_next)) + return 1; + return (table->prehash_list == domain); +} + +/** remove domain node from NSEC3 tree in hash space */ +void +zone_del_domain_in_hash_tree(rbtree_t* tree, rbnode_t* node) +{ + if(!node->key) + return; + rbtree_delete(tree, node->key); + /* note that domain is no longer in the tree */ + node->key = NULL; +} + +/** clear the prehash list */ +void prehash_clear(domain_table_type* table) +{ + domain_type* d = table->prehash_list, *n; + while(d) { + n = d->nsec3->prehash_next; + d->nsec3->prehash_prev = NULL; + d->nsec3->prehash_next = NULL; + d = n; + } + table->prehash_list = NULL; +} + +/** add domain to prehash list */ +void +prehash_add(domain_table_type* table, domain_type* domain) +{ + if(domain_is_prehash(table, domain)) + return; + allocate_domain_nsec3(table, domain); + domain->nsec3->prehash_next = table->prehash_list; + if(table->prehash_list) + table->prehash_list->nsec3->prehash_prev = domain; + table->prehash_list = domain; +} + +/** remove domain from prehash list */ +void +prehash_del(domain_table_type* table, domain_type* domain) +{ + if(domain->nsec3->prehash_next) + domain->nsec3->prehash_next->nsec3->prehash_prev = + domain->nsec3->prehash_prev; + if(domain->nsec3->prehash_prev) + domain->nsec3->prehash_prev->nsec3->prehash_next = + domain->nsec3->prehash_next; + else table->prehash_list = domain->nsec3->prehash_next; + domain->nsec3->prehash_next = NULL; + domain->nsec3->prehash_prev = NULL; +} +#endif /* NSEC3 */ + +/** perform domain name deletion */ +static void +do_deldomain(namedb_type* db, domain_type* domain) +{ + assert(domain && domain->parent); /* exists and not root */ + /* first adjust the number list so that domain is the last one */ + numlist_make_last(db->domains, domain); + /* pop off the domain from the number list */ + (void)numlist_pop_last(db->domains); + +#ifdef NSEC3 + /* if on prehash list, remove from prehash */ + if(domain_is_prehash(db->domains, domain)) + prehash_del(db->domains, domain); + + /* see if nsec3-nodes are used */ + if(domain->nsec3) { + if(domain->nsec3->nsec3_node.key) + zone_del_domain_in_hash_tree(nsec3_tree_zone(db, domain) + ->nsec3tree, &domain->nsec3->nsec3_node); + if(domain->nsec3->hash_node.key) + zone_del_domain_in_hash_tree(nsec3_tree_zone(db, domain) + ->hashtree, &domain->nsec3->hash_node); + if(domain->nsec3->wchash_node.key) + zone_del_domain_in_hash_tree(nsec3_tree_zone(db, domain) + ->wchashtree, &domain->nsec3->wchash_node); + if(domain->nsec3->dshash_node.key) + zone_del_domain_in_hash_tree(nsec3_tree_dszone(db, domain) + ->dshashtree, &domain->nsec3->dshash_node); + region_recycle(db->domains->region, domain->nsec3, + sizeof(struct nsec3_domain_data)); + } +#endif /* NSEC3 */ + + /* see if this domain is someones wildcard-child-closest-match, + * which can only be the parent, and then it should use the + * one-smaller than this domain as closest-match. */ + if(domain->parent->wildcard_child_closest_match == domain) + domain->parent->wildcard_child_closest_match = + domain_previous(domain); + + /* actual removal */ + radix_delete(db->domains->nametree, domain->rnode); + region_recycle(db->domains->region, (dname_type*)domain->dname, + dname_total_size(domain->dname)); + region_recycle(db->domains->region, domain, sizeof(domain_type)); +} + +void +domain_table_deldomain(namedb_type* db, domain_type* domain) +{ + while(domain_can_be_deleted(domain)) { + /* delete it */ + do_deldomain(db, domain); + /* test parent */ + domain = domain->parent; + } +} + +/** clear hash tree */ +void +hash_tree_clear(rbtree_t* tree) +{ + rbnode_t* n; + if(!tree) return; + + /* note that elements are no longer in the tree */ + for(n=rbtree_first(tree); n!=RBTREE_NULL; n=rbtree_next(n)) { + n->key = NULL; + } + tree->count = 0; + tree->root = RBTREE_NULL; +} + +void hash_tree_delete(region_type* region, rbtree_t* tree) +{ + region_recycle(region, tree, sizeof(rbtree_t)); +} + +/** add domain nsec3 node to hashedspace tree */ +void zone_add_domain_in_hash_tree(region_type* region, rbtree_t** tree, + int (*cmpf)(const void*, const void*), + domain_type* domain, rbnode_t* node) +{ + if(!*tree) + *tree = rbtree_create(region, cmpf); + memset(node, 0, sizeof(rbnode_t)); + node->key = domain; + rbtree_insert(*tree, node); +} + domain_table_type * -domain_table_create(region_type *region) +domain_table_create(region_type* region) { - const dname_type *origin; - domain_table_type *result; - domain_type *root; + const dname_type* origin; + domain_table_type* result; + domain_type* root; assert(region); origin = dname_make(region, (uint8_t *) "", 0); root = (domain_type *) region_alloc(region, sizeof(domain_type)); - root->node.key = origin; + root->dname = origin; root->parent = NULL; - root->nextdiff = NULL; root->wildcard_child_closest_match = root; root->rrsets = NULL; root->number = 1; /* 0 is used for after header */ + root->usage = 1; /* do not delete root, ever */ root->is_existing = 0; root->is_apex = 0; - root->has_SOA = 0; + root->numlist_prev = NULL; + root->numlist_next = NULL; #ifdef NSEC3 - root->nsec3_cover = NULL; -#ifdef FULL_PREHASH - root->nsec3_is_exact = 0; - root->nsec3_ds_parent_is_exact = 0; - root->nsec3_wcard_child_cover = NULL; - root->nsec3_ds_parent_cover = NULL; - root->nsec3_lookup = NULL; -#endif /* FULL_PREHASH */ -#endif /* NSEC3 */ + root->nsec3 = NULL; +#endif result = (domain_table_type *) region_alloc(region, sizeof(domain_table_type)); result->region = region; - result->names_to_domains = rbtree_create( - region, (int (*)(const void *, const void *)) dname_compare); - rbtree_insert(result->names_to_domains, (rbnode_t *) root); + result->nametree = radix_tree_create(region); + root->rnode = radname_insert(result->nametree, dname_name(root->dname), + root->dname->name_size, root); result->root = root; + result->numlist_last = root; +#ifdef NSEC3 + result->prehash_list = NULL; +#endif return result; } @@ -115,7 +357,9 @@ domain_table_search(domain_table_type *table, assert(closest_match); assert(closest_encloser); - exact = rbtree_find_less_equal(table->names_to_domains, dname, (rbnode_t **) closest_match); + exact = radname_find_less_equal(table->nametree, dname_name(dname), + dname->name_size, (struct radnode**)closest_match); + *closest_match = (domain_type*)((*(struct radnode**)closest_match)->elem); assert(*closest_match); *closest_encloser = *closest_match; @@ -135,11 +379,11 @@ domain_table_search(domain_table_type *table, } domain_type * -domain_table_find(domain_table_type *table, - const dname_type *dname) +domain_table_find(domain_table_type* table, + const dname_type* dname) { - domain_type *closest_match; - domain_type *closest_encloser; + domain_type* closest_match; + domain_type* closest_encloser; int exact; exact = domain_table_search( @@ -149,12 +393,12 @@ domain_table_find(domain_table_type *table, domain_type * -domain_table_insert(domain_table_type *table, - const dname_type *dname) +domain_table_insert(domain_table_type* table, + const dname_type* dname) { - domain_type *closest_match; - domain_type *closest_encloser; - domain_type *result; + domain_type* closest_match; + domain_type* closest_encloser; + domain_type* result; int exact; assert(table); @@ -172,8 +416,9 @@ domain_table_insert(domain_table_type *table, result = allocate_domain_info(table, dname, closest_encloser); - rbtree_insert(table->names_to_domains, (rbnode_t *) result); - result->number = table->names_to_domains->count; + result->rnode = radname_insert(table->nametree, + dname_name(result->dname), + result->dname->name_size, result); /* * If the newly added domain name is larger @@ -199,26 +444,21 @@ domain_table_insert(domain_table_type *table, } int -domain_table_iterate(domain_table_type *table, +domain_table_iterate(domain_table_type* table, domain_table_iterator_type iterator, - void *user_data) + void* user_data) { - const void *dname; - void *node; int error = 0; - - assert(table); - - RBTREE_WALK(table->names_to_domains, dname, node) { - error += iterator((domain_type *) node, user_data); + struct radnode* n; + for(n = radix_first(table->nametree); n; n = radix_next(n)) { + error += iterator((domain_type*)n->elem, user_data); } - return error; } void -domain_add_rrset(domain_type *domain, rrset_type *rrset) +domain_add_rrset(domain_type* domain, rrset_type* rrset) { #if 0 /* fast */ rrset->next = domain->rrsets; @@ -240,9 +480,9 @@ domain_add_rrset(domain_type *domain, rrset_type *rrset) rrset_type * -domain_find_rrset(domain_type *domain, zone_type *zone, uint16_t type) +domain_find_rrset(domain_type* domain, zone_type* zone, uint16_t type) { - rrset_type *result = domain->rrsets; + rrset_type* result = domain->rrsets; while (result) { if (result->zone == zone && rrset_rrtype(result) == type) { @@ -254,9 +494,9 @@ domain_find_rrset(domain_type *domain, zone_type *zone, uint16_t type) } rrset_type * -domain_find_any_rrset(domain_type *domain, zone_type *zone) +domain_find_any_rrset(domain_type* domain, zone_type* zone) { - rrset_type *result = domain->rrsets; + rrset_type* result = domain->rrsets; while (result) { if (result->zone == zone) { @@ -268,9 +508,9 @@ domain_find_any_rrset(domain_type *domain, zone_type *zone) } zone_type * -domain_find_zone(domain_type *domain) +domain_find_zone(domain_type* domain) { - rrset_type *rrset; + rrset_type* rrset; while (domain) { for (rrset = domain->rrsets; rrset; rrset = rrset->next) { if (rrset_rrtype(rrset) == TYPE_SOA) { @@ -282,22 +522,10 @@ domain_find_zone(domain_type *domain) return NULL; } -#ifndef FULL_PREHASH -domain_type * -domain_find_zone_apex(domain_type *domain) { - while (domain != NULL) { - if (domain->has_SOA != 0) - return domain; - domain = domain->parent; - } - return NULL; -} -#endif /* !FULL_PREHASH */ - zone_type * -domain_find_parent_zone(zone_type *zone) +domain_find_parent_zone(zone_type* zone) { - rrset_type *rrset; + rrset_type* rrset; assert(zone); @@ -310,7 +538,7 @@ domain_find_parent_zone(zone_type *zone) } domain_type * -domain_find_ns_rrsets(domain_type *domain, zone_type *zone, rrset_type **ns) +domain_find_ns_rrsets(domain_type* domain, zone_type* zone, rrset_type **ns) { while (domain && domain != zone->apex) { *ns = domain_find_rrset(domain, zone, TYPE_NS); @@ -324,18 +552,18 @@ domain_find_ns_rrsets(domain_type *domain, zone_type *zone, rrset_type **ns) } int -domain_is_glue(domain_type *domain, zone_type *zone) +domain_is_glue(domain_type* domain, zone_type* zone) { - rrset_type *unused; - domain_type *ns_domain = domain_find_ns_rrsets(domain, zone, &unused); + rrset_type* unused; + domain_type* ns_domain = domain_find_ns_rrsets(domain, zone, &unused); return (ns_domain != NULL && domain_find_rrset(ns_domain, zone, TYPE_SOA) == NULL); } domain_type * -domain_wildcard_child(domain_type *domain) +domain_wildcard_child(domain_type* domain) { - domain_type *wildcard_child; + domain_type* wildcard_child; assert(domain); assert(domain->wildcard_child_closest_match); @@ -351,14 +579,14 @@ domain_wildcard_child(domain_type *domain) } int -zone_is_secure(zone_type *zone) +zone_is_secure(zone_type* zone) { assert(zone); return zone->is_secure; } uint16_t -rr_rrsig_type_covered(rr_type *rr) +rr_rrsig_type_covered(rr_type* rr) { assert(rr->type == TYPE_RRSIG); assert(rr->rdata_count > 0); @@ -368,20 +596,16 @@ rr_rrsig_type_covered(rr_type *rr) } zone_type * -namedb_find_zone(namedb_type *db, domain_type *domain) +namedb_find_zone(namedb_type* db, const dname_type* dname) { - zone_type *zone; - - for (zone = db->zones; zone; zone = zone->next) { - if (zone->apex == domain) - break; - } - - return zone; + struct radnode* n = radname_search(db->zonetree, dname_name(dname), + dname->name_size); + if(n) return (zone_type*)n->elem; + return NULL; } rrset_type * -domain_find_non_cname_rrset(domain_type *domain, zone_type *zone) +domain_find_non_cname_rrset(domain_type* domain, zone_type* zone) { /* find any rrset type that is not allowed next to a CNAME */ /* nothing is allowed next to a CNAME, except RRSIG, NSEC, NSEC3 */ @@ -402,251 +626,12 @@ domain_find_non_cname_rrset(domain_type *domain, zone_type *zone) return NULL; } -/** - * Create namedb. - * - */ -struct namedb * -namedb_create(void) -{ - struct namedb *db = NULL; - region_type *region = NULL; -#ifdef NSEC3 -#ifndef FULL_PREHASH - region_type *nsec3_region = NULL; - region_type *nsec3_mod_region = NULL; -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ - -#ifdef USE_MMAP_ALLOC - region = region_create_custom(mmap_alloc, mmap_free, - MMAP_ALLOC_CHUNK_SIZE, MMAP_ALLOC_LARGE_OBJECT_SIZE, - MMAP_ALLOC_INITIAL_CLEANUP_SIZE, 1); -#else /* !USE_MMAP_ALLOC */ - region = region_create_custom(xalloc, free, - DEFAULT_CHUNK_SIZE, DEFAULT_LARGE_OBJECT_SIZE, - DEFAULT_INITIAL_CLEANUP_SIZE, 1); -#endif /* !USE_MMAP_ALLOC */ - if (region == NULL) - return NULL; - -#ifdef NSEC3 -#ifndef FULL_PREHASH -#ifdef USE_MMAP_ALLOC - nsec3_region = region_create_custom(mmap_alloc, mmap_free, - MMAP_ALLOC_CHUNK_SIZE, MMAP_ALLOC_LARGE_OBJECT_SIZE, - MMAP_ALLOC_INITIAL_CLEANUP_SIZE, 1); -#else /* !USE_MMAP_ALLOC */ - nsec3_region = region_create_custom(xalloc, free, - DEFAULT_CHUNK_SIZE, DEFAULT_LARGE_OBJECT_SIZE, - DEFAULT_INITIAL_CLEANUP_SIZE, 1); -#endif /* !USE_MMAP_ALLOC */ - if (nsec3_region == NULL) { - region_destroy(region); - return NULL; - } -#ifdef USE_MMAP_ALLOC - nsec3_mod_region = region_create_custom(mmap_alloc, mmap_free, - MMAP_ALLOC_CHUNK_SIZE, MMAP_ALLOC_LARGE_OBJECT_SIZE, - MMAP_ALLOC_INITIAL_CLEANUP_SIZE, 1); -#else /* !USE_MMAP_ALLOC */ - nsec3_mod_region = region_create_custom(xalloc, free, - DEFAULT_CHUNK_SIZE, DEFAULT_LARGE_OBJECT_SIZE, - DEFAULT_INITIAL_CLEANUP_SIZE, 1); -#endif /* !USE_MMAP_ALLOC */ - if (nsec3_mod_region == NULL) { - region_destroy(region); - region_destroy(nsec3_region); - return NULL; - } -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ - - /* Make a new structure... */ - db = (namedb_type *) region_alloc(region, sizeof(namedb_type)); - db->region = region; -#ifdef NSEC3 -#ifndef FULL_PREHASH - db->nsec3_region = nsec3_region; - db->nsec3_mod_region = nsec3_mod_region; - db->nsec3_mod_domains = NULL; -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ - db->domains = domain_table_create(region); - db->zones = NULL; - db->zone_count = 0; - db->filename = NULL; - db->fd = NULL; - db->crc = ~0; - db->crc_pos = 0; - db->diff_skip = 0; - db->diff_pos = 0; - return db; -} - -/** - * Destroy namedb. - * - */ -void -namedb_destroy(struct namedb *db) -{ -#ifdef NSEC3 -#ifndef FULL_PREHASH - region_destroy(db->nsec3_mod_region); - db->nsec3_mod_region = NULL; - db->nsec3_mod_domains = NULL; - region_destroy(db->nsec3_region); - db->nsec3_region = NULL; -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ - region_destroy(db->region); -} - - -#ifdef NSEC3 -#ifndef FULL_PREHASH -int -zone_nsec3_domains_create(struct namedb *db, struct zone *zone) -{ - if ((db == NULL) || (zone == NULL)) - return EINVAL; - if (zone->nsec3_domains != NULL) - return 0; - zone->nsec3_domains = rbtree_create(db->nsec3_region, - dname_compare); - if (zone->nsec3_domains == NULL) - return ENOMEM; - return 0; -} - -int -zone_nsec3_domains_destroy(struct namedb *db, struct zone *zone) -{ - rbnode_t *node; - if ((db == NULL) || (zone == NULL)) - return EINVAL; - if (zone->nsec3_domains == NULL) - return 0; - - node = rbtree_postorder_first(zone->nsec3_domains->root); - while (node != RBTREE_NULL) { - struct nsec3_domain *nsec3_domain = - (struct nsec3_domain *) node; - node = rbtree_postorder_next(node); - - if (nsec3_domain->covers != NULL) { - nsec3_domain->covers->nsec3_cover = NULL; - } - region_recycle(db->nsec3_region, nsec3_domain, - sizeof(*nsec3_domain)); - } - region_recycle(db->nsec3_region, zone->nsec3_domains, - sizeof(*(zone->nsec3_domains))); - zone->nsec3_domains = NULL; - return 0; -} - - int -namedb_add_nsec3_domain(struct namedb *db, struct domain *domain, - struct zone *zone) +namedb_lookup(struct namedb* db, + const dname_type* dname, + domain_type **closest_match, + domain_type **closest_encloser) { - struct nsec3_domain *nsec3_domain; - if (zone->nsec3_domains == NULL) - return 0; - nsec3_domain = (struct nsec3_domain *) region_alloc(db->nsec3_region, - sizeof(*nsec3_domain)); - if (nsec3_domain == NULL) - return ENOMEM; - nsec3_domain->node.key = domain_dname(domain); - nsec3_domain->nsec3_domain = domain; - nsec3_domain->covers = NULL; - if (rbtree_insert(zone->nsec3_domains, (rbnode_t *) nsec3_domain) == NULL) { - region_recycle(db->nsec3_region, nsec3_domain, sizeof(*nsec3_domain)); - } - return 0; + return domain_table_search( + db->domains, dname, closest_match, closest_encloser); } - - -int -namedb_del_nsec3_domain(struct namedb *db, struct domain *domain, - struct zone *zone) -{ - rbnode_t *node; - struct nsec3_domain *nsec3_domain; - int error = 0; - - if (zone->nsec3_domains == NULL) - return 0; - - node = rbtree_delete(zone->nsec3_domains, domain_dname(domain)); - if (node == NULL) - return 0; - - nsec3_domain = (struct nsec3_domain *) node; - if (nsec3_domain->covers != NULL) { - /* - * It is possible that this NSEC3 domain was modified - * due to the addition/deletion of another NSEC3 domain. - * Make sure it gets added to the NSEC3 list later by - * making sure it's covered domain is added to the - * NSEC3 mod list. S64#3441 - */ - error = namedb_add_nsec3_mod_domain(db, nsec3_domain->covers); - nsec3_domain->covers->nsec3_cover = NULL; - nsec3_domain->covers = NULL; - } - region_recycle(db->nsec3_region, nsec3_domain, sizeof(*nsec3_domain)); - return error; -} - - -int -namedb_nsec3_mod_domains_create(struct namedb *db) -{ - if (db == NULL) - return EINVAL; - namedb_nsec3_mod_domains_destroy(db); - - db->nsec3_mod_domains = rbtree_create(db->nsec3_mod_region, dname_compare); - if (db->nsec3_mod_domains == NULL) - return ENOMEM; - return 0; -} - - -int -namedb_nsec3_mod_domains_destroy(struct namedb *db) -{ - if (db == NULL) - return EINVAL; - if (db->nsec3_mod_domains == NULL) - return 0; - region_free_all(db->nsec3_mod_region); - db->nsec3_mod_domains = NULL; - return 0; -} - -int -namedb_add_nsec3_mod_domain(struct namedb *db, struct domain *domain) -{ - struct nsec3_mod_domain *nsec3_mod_domain; - nsec3_mod_domain = (struct nsec3_mod_domain *) - region_alloc(db->nsec3_mod_region, sizeof(*nsec3_mod_domain)); - if (nsec3_mod_domain == NULL) { - log_msg(LOG_ERR, - "memory allocation failure on modified domain"); - return ENOMEM; - } - nsec3_mod_domain->node.key = domain_dname(domain); - nsec3_mod_domain->domain = domain; - - if (rbtree_insert(db->nsec3_mod_domains, (rbnode_t *) nsec3_mod_domain) == NULL) { - region_recycle(db->nsec3_mod_region, nsec3_mod_domain, - sizeof(*nsec3_mod_domain)); - } - return 0; -} -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ diff --git a/usr.sbin/nsd/namedb.h b/usr.sbin/nsd/namedb.h index e50986a0fa4..dc0cb3fbff7 100644 --- a/usr.sbin/nsd/namedb.h +++ b/usr.sbin/nsd/namedb.h @@ -1,7 +1,7 @@ /* * namedb.h -- nsd(8) internal namespace database definitions * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -14,13 +14,12 @@ #include "dname.h" #include "dns.h" +#include "radtree.h" #include "rbtree.h" -#include "util.h" struct zone_options; struct nsd_options; - -#define NAMEDB_MAGIC "NSDdbV08" -#define NAMEDB_MAGIC_SIZE 8 +struct udb_base; +struct udb_ptr; typedef union rdata_atom rdata_atom_type; typedef struct rrset rrset_type; @@ -35,102 +34,104 @@ typedef struct zone zone_type; struct domain_table { - region_type *region; - rbtree_t *names_to_domains; - domain_type *root; + region_type* region; + struct radtree *nametree; + domain_type* root; + /* ptr to biggest domain.number and last in list. + * the root is the lowest and first in the list. */ + domain_type *numlist_last; +#ifdef NSEC3 + /* the prehash list, start of the list */ + domain_type* prehash_list; +#endif /* NSEC3 */ }; -struct domain -{ - rbnode_t node; - domain_type *parent; - domain_type *nextdiff; - domain_type *wildcard_child_closest_match; - rrset_type *rrsets; #ifdef NSEC3 - domain_type *nsec3_cover; /* != NULL is exact cover */ -#ifdef FULL_PREHASH - /* (if nsec3 chain complete) nsec_cover is always the covering nsec3 - record */ +struct nsec3_domain_data { + /* (if nsec3 chain complete) always the covering nsec3 record */ + domain_type* nsec3_cover; /* the nsec3 that covers the wildcard child of this domain. */ - domain_type *nsec3_wcard_child_cover; + domain_type* nsec3_wcard_child_cover; /* for the DS case we must answer on the parent side of zone cut */ - domain_type *nsec3_ds_parent_cover; - /* the NSEC3 domain that has a hash-base32 <= than this dname. */ - /* or NULL (no smaller one within this zone) - * this variable is used to look up the NSEC3 record that matches - * or covers a given b64-encoded-hash-string domain name. - * The result of the lookup is stored in the *_cover variables. - * The variable makes it possible to perform a rbtree lookup for - * a name, then take this 'jump' to the previous element that contains - * an NSEC3 record, with hopefully the correct parameters. */ - domain_type *nsec3_lookup; -#endif /* FULL_PREHASH */ + domain_type* nsec3_ds_parent_cover; + /* NSEC3 domains to prehash, prev and next on the list or cleared */ + domain_type* prehash_prev, *prehash_next; + /* entry in the nsec3tree (for NSEC3s in the chain in use) */ + rbnode_t nsec3_node; + /* entry in the hashtree (for precompiled domains) */ + rbnode_t hash_node; + /* entry in the wchashtree (the wildcard precompile) */ + rbnode_t wchash_node; + /* entry in the dshashtree (the parent ds precompile) */ + rbnode_t dshash_node; + + /* nsec3 hash */ + uint8_t nsec3_hash[NSEC3_HASH_LEN]; + /* nsec3 hash of wildcard before this name */ + uint8_t nsec3_wc_hash[NSEC3_HASH_LEN]; + /* parent-side DS hash */ + uint8_t nsec3_ds_parent_hash[NSEC3_HASH_LEN]; + /* if the nsec3 has is available */ + unsigned have_nsec3_hash : 1; + unsigned have_nsec3_wc_hash : 1; + unsigned have_nsec3_ds_parent_hash : 1; + /* if the domain has an NSEC3 for it, use cover ptr to get it. */ + unsigned nsec3_is_exact : 1; + /* same but on parent side */ + unsigned nsec3_ds_parent_is_exact : 1; +}; #endif /* NSEC3 */ - uint32_t number; /* Unique domain name number. */ + +struct domain +{ + struct radnode* rnode; + const dname_type* dname; + domain_type* parent; + domain_type* wildcard_child_closest_match; + rrset_type* rrsets; +#ifdef NSEC3 + struct nsec3_domain_data* nsec3; +#endif + /* double-linked list sorted by domain.number */ + domain_type* numlist_prev, *numlist_next; + size_t number; /* Unique domain name number. */ + size_t usage; /* number of ptrs to this from RRs(in rdata) and + from zone-apex pointers, also the root has one + more to make sure it cannot be deleted. */ /* * This domain name exists (see wildcard clarification draft). */ unsigned is_existing : 1; unsigned is_apex : 1; - unsigned has_SOA : 1; -#ifdef NSEC3 -#ifdef FULL_PREHASH - /* if the domain has an NSEC3 for it, use cover ptr to get it. */ - unsigned nsec3_is_exact : 1; - /* same but on parent side */ - unsigned nsec3_ds_parent_is_exact : 1; -#endif /* FULL_PREHASH */ -#endif /* NSEC3 */ }; struct zone { - zone_type *next; - domain_type *apex; - rrset_type *soa_rrset; - rrset_type *soa_nx_rrset; /* see bug #103 */ - rrset_type *ns_rrset; + struct radnode *node; /* this entry in zonetree */ + domain_type* apex; + rrset_type* soa_rrset; + rrset_type* soa_nx_rrset; /* see bug #103 */ + rrset_type* ns_rrset; #ifdef NSEC3 - rr_type *nsec3_soa_rr; /* rrset with SOA bit set */ - domain_type *nsec3_last; /* last domain with nsec3, wraps */ -#ifndef FULL_PREHASH - rbtree_t *nsec3_domains; -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ - -#if defined(BIND8_STATS) && defined(USE_ZONE_STATS) - struct nsdst st; -#endif /* defined(BIND8_STATS) && defined(USE_ZONE_STATS) */ - - struct zone_options *opts; - uint32_t number; - uint8_t* dirty; /* array of dirty-flags, per child */ + rr_type* nsec3_param; /* NSEC3PARAM RR of chain in use or NULL */ + domain_type* nsec3_last; /* last domain with nsec3, wraps */ + /* in these trees, the root contains an elem ptr to the radtree* */ + rbtree_t* nsec3tree; /* tree with relevant NSEC3 domains */ + rbtree_t* hashtree; /* tree, hashed NSEC3precompiled domains */ + rbtree_t* wchashtree; /* tree, wildcard hashed domains */ + rbtree_t* dshashtree; /* tree, ds-parent-hash domains */ +#endif + struct zone_options* opts; unsigned is_secure : 1; /* zone uses DNSSEC */ - unsigned updated : 1; /* zone SOA was updated */ unsigned is_ok : 1; /* zone has not expired. */ + unsigned is_changed : 1; /* zone was changed by AXFR */ }; -#ifdef NSEC3 -#ifndef FULL_PREHASH -struct nsec3_domain { - rbnode_t node; - struct domain *nsec3_domain; - struct domain *covers; -}; - -struct nsec3_mod_domain { - rbnode_t node; - struct domain *domain; -}; -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ - /* a RR in DNS */ struct rr { - domain_type *owner; - rdata_atom_type *rdatas; + domain_type* owner; + rdata_atom_type* rdatas; uint32_t ttl; uint16_t type; uint16_t klass; @@ -143,9 +144,9 @@ struct rr { */ struct rrset { - rrset_type *next; - zone_type *zone; - rr_type *rrs; + rrset_type* next; + zone_type* zone; + rr_type* rrs; uint16_t rr_count; }; @@ -157,10 +158,10 @@ struct rrset union rdata_atom { /* RDATA_WF_COMPRESSED_DNAME, RDATA_WF_UNCOMPRESSED_DNAME */ - domain_type *domain; + domain_type* domain; /* Default. */ - uint16_t *data; + uint16_t* data; }; /* @@ -171,8 +172,8 @@ domain_table_type *domain_table_create(region_type *region); /* * Search the domain table for a match and the closest encloser. */ -int domain_table_search(domain_table_type *table, - const dname_type *dname, +int domain_table_search(domain_table_type* table, + const dname_type* dname, domain_type **closest_match, domain_type **closest_encloser); @@ -181,17 +182,17 @@ int domain_table_search(domain_table_type *table, * root domain). */ static inline uint32_t -domain_table_count(domain_table_type *table) +domain_table_count(domain_table_type* table) { - return table->names_to_domains->count; + return table->nametree->count; } /* * Find the specified dname in the domain_table. NULL is returned if * there is no exact match. */ -domain_type *domain_table_find(domain_table_type *table, - const dname_type *dname); +domain_type* domain_table_find(domain_table_type* table, + const dname_type* dname); /* * Insert a domain name in the domain table. If the domain name is @@ -203,6 +204,17 @@ domain_type *domain_table_find(domain_table_type *table, domain_type *domain_table_insert(domain_table_type *table, const dname_type *dname); +/* put domain into nsec3 hash space tree */ +void zone_add_domain_in_hash_tree(region_type* region, rbtree_t** tree, + int (*cmpf)(const void*, const void*), domain_type* domain, + rbnode_t* node); +void zone_del_domain_in_hash_tree(rbtree_t* tree, rbnode_t* node); +void hash_tree_clear(rbtree_t* tree); +void hash_tree_delete(region_type* region, rbtree_t* tree); +void prehash_clear(domain_table_type* table); +void prehash_add(domain_table_type* table, domain_type* domain); +void prehash_del(domain_table_type* table, domain_type* domain); +int domain_is_prehash(domain_table_type* table, domain_type* domain); /* * Iterate over all the domain names in the domain tree. @@ -210,87 +222,80 @@ domain_type *domain_table_insert(domain_table_type *table, typedef int (*domain_table_iterator_type)(domain_type *node, void *user_data); -int domain_table_iterate(domain_table_type *table, +int domain_table_iterate(domain_table_type* table, domain_table_iterator_type iterator, - void *user_data); + void* user_data); /* * Add an RRset to the specified domain. Updates the is_existing flag * as required. */ -void domain_add_rrset(domain_type *domain, rrset_type *rrset); +void domain_add_rrset(domain_type* domain, rrset_type* rrset); -rrset_type *domain_find_rrset(domain_type *domain, zone_type *zone, uint16_t type); -rrset_type *domain_find_any_rrset(domain_type *domain, zone_type *zone); +rrset_type* domain_find_rrset(domain_type* domain, zone_type* zone, uint16_t type); +rrset_type* domain_find_any_rrset(domain_type* domain, zone_type* zone); -zone_type *domain_find_zone(domain_type *domain); -zone_type *domain_find_parent_zone(zone_type *zone); +zone_type* domain_find_zone(domain_type* domain); +zone_type* domain_find_parent_zone(zone_type* zone); -#ifndef FULL_PREHASH -domain_type *domain_find_zone_apex(domain_type *domain); -#endif /* !FULL_PREHASH */ -domain_type *domain_find_ns_rrsets(domain_type *domain, zone_type *zone, rrset_type **ns); +domain_type* domain_find_ns_rrsets(domain_type* domain, zone_type* zone, rrset_type **ns); -int domain_is_glue(domain_type *domain, zone_type *zone); +int domain_is_glue(domain_type* domain, zone_type* zone); -rrset_type *domain_find_non_cname_rrset(domain_type *domain, zone_type *zone); +rrset_type* domain_find_non_cname_rrset(domain_type* domain, zone_type* zone); -domain_type *domain_wildcard_child(domain_type *domain); +domain_type* domain_wildcard_child(domain_type* domain); -int zone_is_secure(zone_type *zone); +int zone_is_secure(zone_type* zone); static inline const dname_type * -domain_dname(domain_type *domain) +domain_dname(domain_type* domain) { - return (const dname_type *) domain->node.key; + return domain->dname; } static inline domain_type * -domain_previous(domain_type *domain) +domain_previous(domain_type* domain) { - rbnode_t *prev = rbtree_previous((rbnode_t *) domain); - return prev == RBTREE_NULL ? NULL : (domain_type *) prev; + struct radnode* prev = radix_prev(domain->rnode); + return prev == NULL ? NULL : (domain_type*)prev->elem; } static inline domain_type * -domain_next(domain_type *domain) +domain_next(domain_type* domain) { - rbnode_t *next = rbtree_next((rbnode_t *) domain); - return next == RBTREE_NULL ? NULL : (domain_type *) next; + struct radnode* next = radix_next(domain->rnode); + return next == NULL ? NULL : (domain_type*)next->elem; } +/* easy comparison for subdomain, true if d1 is subdomain of d2. */ +static inline int domain_is_subdomain(domain_type* d1, domain_type* d2) +{ return dname_is_subdomain(domain_dname(d1), domain_dname(d2)); } +/* easy printout, to static buffer of dname_to_string, fqdn. */ +static inline const char* domain_to_string(domain_type* domain) +{ return dname_to_string(domain_dname(domain), NULL); } + /* * The type covered by the signature in the specified RRSIG RR. */ -uint16_t rr_rrsig_type_covered(rr_type *rr); +uint16_t rr_rrsig_type_covered(rr_type* rr); typedef struct namedb namedb_type; struct namedb { - region_type *region; -#ifdef NSEC3 -#ifndef FULL_PREHASH - region_type *nsec3_region; - region_type *nsec3_mod_region; - rbtree_t *nsec3_mod_domains; -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ - domain_table_type *domains; - zone_type *zones; - size_t zone_count; - char *filename; - FILE *fd; + region_type* region; + domain_table_type* domains; + struct radtree* zonetree; + struct udb_base* udb; /* the timestamp on the ixfr.db file */ struct timeval diff_timestamp; - /* the CRC on the nsd.db file and position of CRC in the db file */ - uint32_t crc; - off_t crc_pos; /* if diff_skip=1, diff_pos contains the nsd.diff place to continue */ uint8_t diff_skip; off_t diff_pos; }; static inline int rdata_atom_is_domain(uint16_t type, size_t index); +static inline int rdata_atom_is_literal_domain(uint16_t type, size_t index); static inline domain_type * rdata_atom_domain(rdata_atom_type atom) @@ -311,27 +316,48 @@ rdata_atom_data(rdata_atom_type atom) } +/* Find the zone for the specified dname in DB. */ +zone_type *namedb_find_zone(namedb_type *db, const dname_type *dname); /* - * Find the zone for the specified DOMAIN in DB. + * Delete a domain name from the domain table. Removes dname_info node. + * Only deletes if usage is 0, has no rrsets and no children. Checks parents + * for deletion as well. Adjusts numberlist(domain.number), and + * wcard_child closest match. */ -zone_type *namedb_find_zone(namedb_type *db, domain_type *domain); - -/* dbcreate.c */ -struct namedb *namedb_new(const char *filename); -int namedb_save(struct namedb *db); -void namedb_discard(struct namedb *db); +void domain_table_deldomain(namedb_type* db, domain_type* domain); +/** dbcreate.c */ +int udb_write_rr(struct udb_base* udb, struct udb_ptr* z, rr_type* rr); +void udb_del_rr(struct udb_base* udb, struct udb_ptr* z, rr_type* rr); +int write_zone_to_udb(struct udb_base* udb, zone_type* zone, time_t mtime); +/** marshal rdata into buffer, must be MAX_RDLENGTH in size */ +size_t rr_marshal_rdata(rr_type* rr, uint8_t* rdata, size_t sz); /* dbaccess.c */ -int namedb_lookup (struct namedb *db, - const dname_type *dname, +int namedb_lookup (struct namedb* db, + const dname_type* dname, domain_type **closest_match, domain_type **closest_encloser); /* pass number of children (to alloc in dirty array */ -struct namedb *namedb_open(const char *filename, struct nsd_options* opt, - size_t num_children); -void namedb_fd_close(struct namedb *db); -void namedb_close(struct namedb *db); +struct namedb *namedb_open(const char *filename, struct nsd_options* opt); +void namedb_close_udb(struct namedb* db); +void namedb_close(struct namedb* db); +void namedb_check_zonefiles(struct namedb* db, struct nsd_options* opt, + struct udb_base* taskudb, struct udb_ptr* last_task); +void namedb_check_zonefile(struct namedb* db, struct udb_base* taskudb, + struct udb_ptr* last_task, struct zone_options* zo); +/** zone one zonefile into memory and revert on parse error, write to udb */ +void namedb_read_zonefile(struct namedb* db, struct zone* zone, + struct udb_base* taskudb, struct udb_ptr* last_task); +void apex_rrset_checks(struct namedb* db, rrset_type* rrset, + domain_type* domain); +zone_type* namedb_zone_create(namedb_type* db, const dname_type* dname, + struct zone_options* zopt); +void namedb_zone_delete(namedb_type* db, zone_type* zone); +void namedb_write_zonefile(namedb_type* db, struct zone_options* zopt); +void namedb_write_zonefiles(namedb_type* db, struct nsd_options* options); +int create_dirs(const char* path); +void allocate_domain_nsec3(domain_table_type *table, domain_type *result); static inline int rdata_atom_is_domain(uint16_t type, size_t index) @@ -343,6 +369,15 @@ rdata_atom_is_domain(uint16_t type, size_t index) || descriptor->wireformat[index] == RDATA_WF_UNCOMPRESSED_DNAME)); } +static inline int +rdata_atom_is_literal_domain(uint16_t type, size_t index) +{ + const rrtype_descriptor_type *descriptor + = rrtype_descriptor_by_type(type); + return (index < descriptor->maximum + && (descriptor->wireformat[index] == RDATA_WF_LITERAL_DNAME)); +} + static inline rdata_wireformat_type rdata_atom_wireformat_type(uint16_t type, size_t index) { @@ -353,7 +388,7 @@ rdata_atom_wireformat_type(uint16_t type, size_t index) } static inline uint16_t -rrset_rrtype(rrset_type *rrset) +rrset_rrtype(rrset_type* rrset) { assert(rrset); assert(rrset->rr_count > 0); @@ -361,35 +396,11 @@ rrset_rrtype(rrset_type *rrset) } static inline uint16_t -rrset_rrclass(rrset_type *rrset) +rrset_rrclass(rrset_type* rrset) { assert(rrset); assert(rrset->rr_count > 0); return rrset->rrs[0].klass; } -/** - * Allocate and initialize a struct namedb. - * Returns a pointer to a valid struct namedb or NULL on failure. - */ -struct namedb * namedb_create(void); - -/** - * Destroy a struct namedb created using the namedb_create function. - * Frees all regions associated with the namedb structure. - */ -void namedb_destroy(struct namedb *db); - -#ifdef NSEC3 -#ifndef FULL_PREHASH -int zone_nsec3_domains_create(struct namedb *db, struct zone *zone); -int zone_nsec3_domains_destroy(struct namedb *db, struct zone *zone); -int namedb_add_nsec3_domain(struct namedb *db, struct domain *domain, struct zone *zone); -int namedb_del_nsec3_domain(struct namedb *db, struct domain *domain, struct zone *zone); -int namedb_nsec3_mod_domains_create(struct namedb *db); -int namedb_nsec3_mod_domains_destroy(struct namedb *db); -int namedb_add_nsec3_mod_domain(struct namedb *db, struct domain *domain); -#endif /* !FULL_PREHASH */ -#endif /* NSEC3 */ - #endif diff --git a/usr.sbin/nsd/netio.c b/usr.sbin/nsd/netio.c index 2c64b6d1f67..ad8ee16ee60 100644 --- a/usr.sbin/nsd/netio.c +++ b/usr.sbin/nsd/netio.c @@ -1,7 +1,7 @@ /* * netio.c -- network I/O support. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -151,32 +151,7 @@ netio_dispatch(netio_type *netio, const struct timespec *timeout, const sigset_t max_fd = handler->fd; } if (handler->event_types & NETIO_EVENT_READ) { - extern int slowaccept; - extern struct timespec slowaccept_timeout; - - if ((handler->event_types & NETIO_EVENT_ACCEPT) && slowaccept) { - if (timespec_compare(&slowaccept_timeout, netio_current_time(netio)) < 0) { - slowaccept = 0; - } - if (slowaccept) { - /** Timeout after slowaccept timeout. */ - struct timespec relative; - relative.tv_sec = slowaccept_timeout.tv_sec; - relative.tv_nsec = slowaccept_timeout.tv_nsec; - timespec_subtract(&relative, netio_current_time(netio)); - if (!have_timeout || - timespec_compare(&relative, &minimum_timeout) < 0) { - have_timeout = 1; - minimum_timeout.tv_sec = relative.tv_sec; - minimum_timeout.tv_nsec = relative.tv_nsec; - } - } else { - FD_SET(handler->fd, &readfds); - } - } else { - /* Not accept event or not slow accept */ - FD_SET(handler->fd, &readfds); - } + FD_SET(handler->fd, &readfds); } if (handler->event_types & NETIO_EVENT_WRITE) { FD_SET(handler->fd, &writefds); diff --git a/usr.sbin/nsd/netio.h b/usr.sbin/nsd/netio.h index c6686afc26f..c8299b97adb 100644 --- a/usr.sbin/nsd/netio.h +++ b/usr.sbin/nsd/netio.h @@ -1,7 +1,7 @@ /* * netio.h -- network I/O support. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -50,8 +50,6 @@ #include "region-allocator.h" -#define NETIO_SLOW_ACCEPT_TIMEOUT 2 /* in seconds */ - /* * The type of events a handler is interested in. These can be OR'ed * together to specify multiple event types. @@ -62,7 +60,6 @@ enum netio_event_types { NETIO_EVENT_WRITE = 2, NETIO_EVENT_EXCEPT = 4, NETIO_EVENT_TIMEOUT = 8, - NETIO_EVENT_ACCEPT = 16 }; typedef enum netio_event_types netio_event_types_type; diff --git a/usr.sbin/nsd/nsd-control-setup.sh.in b/usr.sbin/nsd/nsd-control-setup.sh.in new file mode 100755 index 00000000000..394afb40c41 --- /dev/null +++ b/usr.sbin/nsd/nsd-control-setup.sh.in @@ -0,0 +1,160 @@ +#!/bin/sh +# +# nsd-control-setup.sh - set up SSL certificates for nsd-control +# +# Copyright (c) 2011, NLnet Labs. All rights reserved. +# +# This software is open source. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# Neither the name of the NLNET LABS nor the names of its contributors may +# be used to endorse or promote products derived from this software without +# specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +# settings: + +# directory for files +DESTDIR=@configdir@ + +# issuer and subject name for certificates +SERVERNAME=nsd +CLIENTNAME=nsd-control + +# validity period for certificates +DAYS=7200 + +# size of keys in bits +BITS=1536 + +# hash algorithm +HASH=sha256 + +# base name for nsd server keys +SVR_BASE=nsd_server + +# base name for nsd-control keys +CTL_BASE=nsd_control + +# we want -rw-r--- access (say you run this as root: grp=yes (server), all=no). +umask 0026 + +# end of options + +# functions: +error ( ) { + echo "$0 fatal error: $1" + exit 1 +} + +# check arguments: +while test $# -ne 0; do + case $1 in + -d) + if test $# -eq 1; then error "need argument for -d"; fi + DESTDIR="$2" + shift + ;; + *) + echo "nsd-control-setup.sh - setup SSL keys for nsd-control" + echo " -d dir use directory to store keys and certificates." + echo " default: $DESTDIR" + exit 1 + ;; + esac + shift +done + +# go!: +echo "setup in directory $DESTDIR" +cd "$DESTDIR" || error "could not cd to $DESTDIR" + +# create certificate keys; do not recreate if they already exist. +if test -f $SVR_BASE.key; then + echo "$SVR_BASE.key exists" +else + echo "generating $SVR_BASE.key" + openssl genrsa -out $SVR_BASE.key $BITS || error "could not genrsa" +fi +if test -f $CTL_BASE.key; then + echo "$CTL_BASE.key exists" +else + echo "generating $CTL_BASE.key" + openssl genrsa -out $CTL_BASE.key $BITS || error "could not genrsa" +fi + +# create self-signed cert for server +cat >request.cfg <<EOF +[req] +default_bits=$BITS +default_md=$HASH +prompt=no +distinguished_name=req_distinguished_name + +[req_distinguished_name] +commonName=$SERVERNAME +EOF +test -f request.cfg || error "could not create request.cfg" + +echo "create $SVR_BASE.pem (self signed certificate)" +openssl req -key $SVR_BASE.key -config request.cfg -new -x509 -days $DAYS -out $SVR_BASE.pem || error "could not create $SVR_BASE.pem" +# create trusted usage pem +openssl x509 -in $SVR_BASE.pem -addtrust serverAuth -out $SVR_BASE"_trust.pem" + +# create client request and sign it, piped +cat >request.cfg <<EOF +[req] +default_bits=$BITS +default_md=$HASH +prompt=no +distinguished_name=req_distinguished_name + +[req_distinguished_name] +commonName=$CLIENTNAME +EOF +test -f request.cfg || error "could not create request.cfg" + +echo "create $CTL_BASE.pem (signed client certificate)" +openssl req -key $CTL_BASE.key -config request.cfg -new | openssl x509 -req -days $DAYS -CA $SVR_BASE"_trust.pem" -CAkey $SVR_BASE.key -CAcreateserial -$HASH -out $CTL_BASE.pem +test -f $CTL_BASE.pem || error "could not create $CTL_BASE.pem" +# create trusted usage pem +# openssl x509 -in $CTL_BASE.pem -addtrust clientAuth -out $CTL_BASE"_trust.pem" + +# see details with openssl x509 -noout -text < $SVR_BASE.pem +# echo "create $CTL_BASE""_browser.pfx (web client certificate)" +# echo "create webbrowser PKCS#12 .PFX certificate file. In Firefox import in:" +# echo "preferences - advanced - encryption - view certificates - your certs" +# echo "empty password is used, simply click OK on the password dialog box." +# openssl pkcs12 -export -in $CTL_BASE"_trust.pem" -inkey $CTL_BASE.key -name "nsd remote control client cert" -out $CTL_BASE"_browser.pfx" -password "pass:" || error "could not create browser certificate" + +# remove unused permissions +chmod o-rw $SVR_BASE.pem $SVR_BASE.key $CTL_BASE.pem $CTL_BASE.key + +# remove crap +rm -f request.cfg +rm -f $CTL_BASE"_trust.pem" $SVR_BASE"_trust.pem" $SVR_BASE"_trust.srl" + +echo "Setup success. Certificates created. Enable in nsd.conf file to use" + +exit 0 diff --git a/usr.sbin/nsd/nsd-control.8.in b/usr.sbin/nsd/nsd-control.8.in new file mode 100644 index 00000000000..bf610f1097b --- /dev/null +++ b/usr.sbin/nsd/nsd-control.8.in @@ -0,0 +1,245 @@ +.TH "nsd\-control" "8" "Oct 29, 2013" "NLnet Labs" "nsd 4.0.0" +.\" Copyright (c) 2011, NLnet Labs. All rights reserved. +.\" See LICENSE for the license. +.SH "NAME" +.LP +.B nsd\-control, +.B nsd\-control\-setup +\- NSD remote server control utility. +.SH "SYNOPSIS" +.B nsd\-control +.RB [ \-c +.IR cfgfile ] +.RB [ \-s +.IR server ] +.IR command +.SH "DESCRIPTION" +.B nsd\-control +performs remote administration on the \fInsd\fR(8) DNS server. It reads +the configuration file, contacts the nsd server over SSL, sends the +command and displays the result. +.P +The available options are: +.TP +.B \-h +Show the version and commandline option help. +.TP +.B \-c \fIcfgfile +The config file to read with settings. If not given the default +config file @nsdconfigfile@ is used. +.TP +.B \-s \fIserver[@port] +IPv4 or IPv6 address of the server to contact. If not given, the +address is read from the config file. +.SH "COMMANDS" +There are several commands that the server understands. +.TP +.B start +Start the server. Simply execs \fInsd\fR(8). The nsd executable +is searched for in the \fBPATH\fR set in the environment. It is started +with the config file specified using \fI\-c\fR or the default config file. +.TP +.B stop +Stop the server. The server daemon exits. +.TP +.B reload [<zone>] +Reload zonefiles and reopen logfile. Without argument reads changed +zonefiles. With argument reads the zonefile for the given zone and +loads it. +.TP +.B reconfig +Reload nsd.conf and apply changes to TSIG keys and configuration patterns, +and apply the changes to add and remove zones that are mentioned in the config. +Other changes are not applied, such as listening ip address and port and chroot. +The pattern updates means that the configuration options for +zones (request\-xfr, zonefile, notify, ...) are updated. Also new +patterns are available for use with the addzone command. +.TP +.B repattern +Same as the reconfig option. +.TP +.B log_reopen +Reopen the logfile, for log rotate that wants to move the logfile away +and create a new logfile. The log can also be reopened with kill \-HUP +(which also reloads all zonefiles). +.TP +.B status +Display server status. Exit code 3 if not running (the connection to the +port is refused), 1 on error, 0 if running. +.TP +.B stats +Output a sequence of name=value lines with statistics information, requires +NSD to be compiled with this option enabled. +.TP +.B stats_noreset +Same as stats, but does not zero the counters. +.TP +.B addzone <zone name> <pattern name> +Add a new zone to the running server. The zone is added to the zonelist +file on disk, so it stays after a restart. The pattern name determines +the options for the new zone. For slave zones a zone transfer is +immediately attempted. For zones with a zonefile, the zone file is +attempted to be read in. +.TP +.B delzone <zone name> +Remove the zone from the running server. The zone is removed from the +zonelist file on disk, from the nsd.db file and from the memory. If it +had a zonefile, this remains (but may be outdated). Zones configured +inside nsd.conf itself cannot be removed this way because the daemon +does not write to the nsd.conf file, you need to add such zones to the +zonelist file to be able to delete them with the delzone command. +.TP +.B write [<zone>] +Write zonefiles to disk, or the given zonefile to disk. Zones that have +changed (via AXFR or IXFR) are written, or if the zonefile has not been +created yet then it is created. Directory components of the zonefile +path are created if necessary. +.TP +.B notify [<zone>] +Send NOTIFY messages to slave servers. Sends to the IP addresses +configured in the 'notify:' lists for the master zones hosted on this +server. Usually NSD sends NOTIFY messages right away when a master zone +serial is updated. If a zone is given, notifies are sent for that zone. +These slave servers are supposed to initiate a zone transfer request +later (to this server or another master), this can be allowed via +the 'provide\-xfr:' acl list configuration. +.TP +.B transfer [<zone>] +Attempt to update slave zones that are hosted on this server by contacting +the masters. The masters are configured via 'request\-xfr:' lists. +If a zone is given, that zone is updated. Usually NSD receives a NOTIFY +from the masters (configured via 'allow\-notify:' acl list) that a new zone +serial has to be transferred. +.TP +.B force_transfer [<zone>] +Force update slave zones that are hosted on this server. Even if the +master hosts the same serial number of the zone, a full AXFR is performed +to fetch it. If you want to use IXFR and check that the serial number +increases, use the 'transfer' command. +.TP +.B zonestatus [<zone>] +Print state of the zone, the serial numbers and since when they have +been acquired. Also prints the notify action (to which server), and +zone transfer (and from which master) if there is activity right now. +.TP +.B serverpid +Prints the PID of the server process. This is used for statistics (and +only works when NSD is compiled with statistics enabled). This pid is +not for sending unix signals, use the pid from nsd.pid for that, that pid +is also stable. +.TP +.B verbosity <number> +Change logging verbosity. +.SH "EXIT CODE" +The nsd\-control program exits with status code 1 on error, 0 on success. +.SH "SET UP" +The setup requires a self\-signed certificate and private keys for both +the server and client. The script \fInsd\-control\-setup\fR generates +these in the default run directory, or with \-d in another directory. +If you change the access control permissions on the key files you can decide +who can use nsd\-control, by default owner and group but not all users. +The script preserves private keys present in the directory. +After running the script as root, turn on \fBcontrol\-enable\fR in +\fInsd.conf\fR. +.SH "STATISTIC COUNTERS" +The \fIstats\fR command shows a number of statistic counters. +.TP +.I num.queries +number of queries received (the tcp and udp queries added up). +.TP +.I serverX.queries +number of queries handled by the server process. The number of +server processes is set with the config statement \fBserver\-count\fR. +.TP +.I time.boot +uptime in seconds since the server was started. With fractional seconds. +.TP +.I time.elapsed +time since the last stats report, in seconds. With fractional seconds. +Can be zero if polled quickly and the previous stats command resets the +counters, so that the next gets a fully zero, and zero elapsed time, report. +.TP +.I size.db.disk +size of nsd.db on disk, in bytes. +.TP +.I size.db.mem +size of the DNS database in memory, in bytes. +.TP +.I size.xfrd.mem +size of memory for zone transfers and notifies in xfrd process, excludes +TSIG data, in bytes. +.TP +.I size.config.disk +size of zonelist file on disk, excludes the nsd.conf size, in bytes. +.TP +.I size.config.mem +size of config data in memory, kept twice in server and xfrd process, +in bytes. +.TP +.I num.type.X +number of queries with this query type. +.TP +.I num.opcode.X +number of queries with this opcode. +.TP +.I num.class.X +number of queries with this query class. +.TP +.I num.rcode.X +number of answers that carried this return code. +.TP +.I num.edns +number of queries with EDNS OPT. +.TP +.I num.ednserr +number of queries which failed EDNS parse. +.TP +.I num.udp +number of queries over UDP ip4. +.TP +.I num.udp6 +number of queries over UDP ip6. +.TP +.I num.tcp +number of connections over TCP ip4. +.TP +.I num.tcp6 +number of connections over TCP ip6. +.TP +.I num.answer_wo_aa +number of answers with NOERROR rcode and without AA flag, this includes the referrals. +.TP +.I num.rxerr +number of queries for which the receive failed. +.TP +.I num.txerr +number of answers for which the transmit failed. +.TP +.I num.raxfr +number of AXFR requests from clients (that got served with reply). +.TP +.I num.truncated +number of answers with TC flag set. +.TP +.I num.dropped +number of queries that were dropped because they failed sanity check. +.TP +.I zone.master +number of master zones served. These are zones with no 'request\-xfr:' +entries. +.TP +.I zone.slave +number of slave zones served. These are zones with 'request\-xfr' +entries. +.SH "FILES" +.TP +.I @nsdconfigfile@ +nsd configuration file. +.TP +.I @configdir@ +directory with private keys (nsd_server.key and nsd_control.key) and +self\-signed certificates (nsd_server.pem and nsd_control.pem). +.SH "SEE ALSO" +\fInsd.conf\fR(5), +\fInsd\fR(8), +\fInsd\-checkconf\fR(8) diff --git a/usr.sbin/nsd/nsd-control.c b/usr.sbin/nsd/nsd-control.c new file mode 100644 index 00000000000..e9551851f17 --- /dev/null +++ b/usr.sbin/nsd/nsd-control.c @@ -0,0 +1,415 @@ +/* + * nsd-control.c - remote control utility for nsd. + * + * Copyright (c) 2011, NLnet Labs. All rights reserved. + * + * This software is open source. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of the NLNET LABS nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * \file + * + * The remote control utility contacts the nsd server over ssl and + * sends the command, receives the answer, and displays the result + * from the commandline. + */ + +#include "config.h" +#ifdef HAVE_SSL + +#include <sys/types.h> +#include <unistd.h> +#include <string.h> +#ifdef HAVE_OPENSSL_SSL_H +#include <openssl/ssl.h> +#endif +#ifdef HAVE_OPENSSL_ERR_H +#include <openssl/err.h> +#endif +#ifdef HAVE_OPENSSL_RAND_H +#include <openssl/rand.h> +#endif +#include "util.h" +#include "tsig.h" +#include "options.h" + +/** Give nsd-control usage, and exit (1). */ +static void +usage() +{ + printf("Usage: nsd-control [options] command\n"); + printf(" Remote control utility for nsd server.\n"); + printf("Version %s. Report bugs to <%s>.\n", + PACKAGE_VERSION, PACKAGE_BUGREPORT); + printf("Options:\n"); + printf(" -c file config file, default is %s\n", CONFIGFILE); + printf(" -s ip[@port] server address, if omitted config is used.\n"); + printf(" -h show this usage help.\n"); + printf("Commands:\n"); + printf(" start start server; runs nsd(8)\n"); + printf(" stop stops the server\n"); + printf(" reload [<zone>] reload modified zonefiles from disk\n"); + printf(" reconfig reload the config file\n"); + printf(" repattern the same as reconfig\n"); + printf(" log_reopen reopen logfile (for log rotate)\n"); + printf(" status display status of server\n"); + printf(" stats print statistics\n"); + printf(" stats_noreset peek at statistics\n"); + printf(" addzone <name> <pattern> add a new zone\n"); + printf(" delzone <name> remove a zone\n"); + printf(" write [<zone>] write changed zonefiles to disk\n"); + printf(" notify [<zone>] send NOTIFY messages to slave servers\n"); + printf(" transfer [<zone>] try to update slave zones to newer serial\n"); + printf(" force_transfer [<zone>] update slave zones with AXFR, no serial check\n"); + printf(" zonestatus [<zone>] print state, serial, activity\n"); + printf(" serverpid get pid of server process\n"); + printf(" verbosity <number> change logging detail\n"); + exit(1); +} + +/** exit with ssl error */ +static void ssl_err(const char* s) +{ + fprintf(stderr, "error: %s\n", s); + ERR_print_errors_fp(stderr); + exit(1); +} + +/** setup SSL context */ +static SSL_CTX* +setup_ctx(nsd_options_t* cfg) +{ + char* s_cert, *c_key, *c_cert; + SSL_CTX* ctx; + + s_cert = cfg->server_cert_file; + c_key = cfg->control_key_file; + c_cert = cfg->control_cert_file; + + /* filenames may be relative to zonesdir */ + if (cfg->zonesdir && cfg->zonesdir[0] && + (s_cert[0] != '/' || c_key[0] != '/' || c_cert[0] != '/')) { + if(chdir(cfg->zonesdir)) + ssl_err("could not chdir to zonesdir"); + } + + ctx = SSL_CTX_new(SSLv23_client_method()); + if(!ctx) + ssl_err("could not allocate SSL_CTX pointer"); + if(!(SSL_CTX_set_options(ctx, SSL_OP_NO_SSLv2) & SSL_OP_NO_SSLv2)) + ssl_err("could not set SSL_OP_NO_SSLv2"); + if(!SSL_CTX_use_certificate_file(ctx,c_cert,SSL_FILETYPE_PEM) || + !SSL_CTX_use_PrivateKey_file(ctx,c_key,SSL_FILETYPE_PEM) + || !SSL_CTX_check_private_key(ctx)) + ssl_err("Error setting up SSL_CTX client key and cert"); + if (SSL_CTX_load_verify_locations(ctx, s_cert, NULL) != 1) + ssl_err("Error setting up SSL_CTX verify, server cert"); + SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL); + + return ctx; +} + +/** contact the server with TCP connect */ +static int +contact_server(const char* svr, nsd_options_t* cfg, int statuscmd) +{ +#ifdef INET6 + struct sockaddr_storage addr; +#else + struct sockaddr_in addr; +#endif + socklen_t addrlen; + int fd; + int port = cfg->control_port; + /* use svr or a config entry */ + if(!svr) { + if(cfg->control_interface) + svr = cfg->control_interface->address; + else svr = "127.0.0.1"; + /* config 0 addr (everything), means ask localhost */ + if(strcmp(svr, "0.0.0.0") == 0) + svr = "127.0.0.1"; + else if(strcmp(svr, "::0") == 0 || + strcmp(svr, "0::0") == 0 || + strcmp(svr, "0::") == 0 || + strcmp(svr, "::") == 0) + svr = "::1"; + } + if(strchr(svr, '@')) { + char* ps = strchr(svr, '@'); + *ps++ = 0; + port = atoi(ps); + if(!port) { + fprintf(stderr, "could not parse port %s\n", ps); + exit(1); + } + } + if(strchr(svr, ':')) { + struct sockaddr_in6 sa; + addrlen = (socklen_t)sizeof(struct sockaddr_in6); + memset(&sa, 0, addrlen); + sa.sin6_family = AF_INET6; + sa.sin6_port = (in_port_t)htons((uint16_t)port); + if(inet_pton((int)sa.sin6_family, svr, &sa.sin6_addr) <= 0) { + fprintf(stderr, "could not parse IP: %s\n", svr); + exit(1); + } + memcpy(&addr, &sa, addrlen); + } else { /* ip4 */ + struct sockaddr_in sa; + addrlen = (socklen_t)sizeof(struct sockaddr_in); + memset(&sa, 0, addrlen); + sa.sin_family = AF_INET; + sa.sin_port = (in_port_t)htons((uint16_t)port); + if(inet_pton((int)sa.sin_family, svr, &sa.sin_addr) <= 0) { + fprintf(stderr, "could not parse IP: %s\n", svr); + exit(1); + } + memcpy(&addr, &sa, addrlen); + } + + fd = socket(strchr(svr, ':')?AF_INET6:AF_INET, SOCK_STREAM, 0); + if(fd == -1) { + fprintf(stderr, "socket: %s\n", strerror(errno)); + exit(1); + } + if(connect(fd, (struct sockaddr*)&addr, addrlen) < 0) { + fprintf(stderr, "error: connect (%s@%d): %s\n", svr, port, + strerror(errno)); + if(errno == ECONNREFUSED && statuscmd) { + printf("nsd is stopped\n"); + exit(3); + } + exit(1); + } + return fd; +} + +/** setup SSL on the connection */ +static SSL* +setup_ssl(SSL_CTX* ctx, int fd) +{ + SSL* ssl; + X509* x; + int r; + + ssl = SSL_new(ctx); + if(!ssl) + ssl_err("could not SSL_new"); + SSL_set_connect_state(ssl); + (void)SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY); + if(!SSL_set_fd(ssl, fd)) + ssl_err("could not SSL_set_fd"); + while(1) { + ERR_clear_error(); + if( (r=SSL_do_handshake(ssl)) == 1) + break; + r = SSL_get_error(ssl, r); + if(r != SSL_ERROR_WANT_READ && r != SSL_ERROR_WANT_WRITE) + ssl_err("SSL handshake failed"); + /* wants to be called again */ + } + + /* check authenticity of server */ + if(SSL_get_verify_result(ssl) != X509_V_OK) + ssl_err("SSL verification failed"); + x = SSL_get_peer_certificate(ssl); + if(!x) + ssl_err("Server presented no peer certificate"); + X509_free(x); + return ssl; +} + +/** send stdin to server */ +static void +send_file(SSL* ssl, FILE* in, char* buf, size_t sz) +{ + while(fgets(buf, (int)sz, in)) { + if(SSL_write(ssl, buf, (int)strlen(buf)) <= 0) + ssl_err("could not SSL_write contents"); + } +} + +/** send command and display result */ +static int +go_cmd(SSL* ssl, int argc, char* argv[]) +{ + char pre[10]; + const char* space=" "; + const char* newline="\n"; + int was_error = 0, first_line = 1; + int r, i; + char buf[1024]; + snprintf(pre, sizeof(pre), "NSDCT%d ", NSD_CONTROL_VERSION); + if(SSL_write(ssl, pre, (int)strlen(pre)) <= 0) + ssl_err("could not SSL_write"); + for(i=0; i<argc; i++) { + if(SSL_write(ssl, space, (int)strlen(space)) <= 0) + ssl_err("could not SSL_write"); + if(SSL_write(ssl, argv[i], (int)strlen(argv[i])) <= 0) + ssl_err("could not SSL_write"); + } + if(SSL_write(ssl, newline, (int)strlen(newline)) <= 0) + ssl_err("could not SSL_write"); + + /* TODO remove or use file upload */ + if(argc == 1 && strcmp(argv[0], "load_cache") == 0) { + send_file(ssl, stdin, buf, sizeof(buf)); + } + + while(1) { + ERR_clear_error(); + if((r = SSL_read(ssl, buf, (int)sizeof(buf)-1)) <= 0) { + if(SSL_get_error(ssl, r) == SSL_ERROR_ZERO_RETURN) { + /* EOF */ + break; + } + ssl_err("could not SSL_read"); + } + buf[r] = 0; + printf("%s", buf); + if(first_line && strncmp(buf, "error", 5) == 0) + was_error = 1; + first_line = 0; + } + return was_error; +} + +/** go ahead and read config, contact server and perform command and display */ +static int +go(const char* cfgfile, char* svr, int argc, char* argv[]) +{ + nsd_options_t* opt; + int fd, ret; + SSL_CTX* ctx; + SSL* ssl; + + /* read config */ + if(!(opt = nsd_options_create(region_create(xalloc, free)))) { + fprintf(stderr, "out of memory\n"); + exit(1); + } + tsig_init(opt->region); + if(!parse_options_file(opt, cfgfile, NULL, NULL)) { + fprintf(stderr, "could not read config file\n"); + exit(1); + } + if(!opt->control_enable) + fprintf(stderr, "warning: control-enable is 'no' in the config file.\n"); + ctx = setup_ctx(opt); + + /* contact server */ + fd = contact_server(svr, opt, argc>0&&strcmp(argv[0],"status")==0); + ssl = setup_ssl(ctx, fd); + + /* send command */ + ret = go_cmd(ssl, argc, argv); + + SSL_free(ssl); + close(fd); + SSL_CTX_free(ctx); + region_destroy(opt->region); + return ret; +} + +/** getopt global, in case header files fail to declare it. */ +extern int optind; +/** getopt global, in case header files fail to declare it. */ +extern char* optarg; + +/** Main routine for nsd-control */ +int main(int argc, char* argv[]) +{ + int c; + const char* cfgfile = CONFIGFILE; + char* svr = NULL; +#ifdef USE_WINSOCK + int r; + WSADATA wsa_data; +#endif + log_init("nsd-control"); + + ERR_load_crypto_strings(); + ERR_load_SSL_strings(); + OpenSSL_add_all_algorithms(); + (void)SSL_library_init(); + + if(!RAND_status()) { + /* try to seed it */ + unsigned char buf[256]; + unsigned int v, seed=(unsigned)time(NULL) ^ (unsigned)getpid(); + size_t i; + v = seed; + for(i=0; i<256/sizeof(v); i++) { + memmove(buf+i*sizeof(v), &v, sizeof(v)); + v = v*seed + (unsigned int)i; + } + RAND_seed(buf, 256); + fprintf(stderr, "warning: no entropy, seeding openssl PRNG with time\n"); + } + + /* parse the options */ + while( (c=getopt(argc, argv, "c:s:h")) != -1) { + switch(c) { + case 'c': + cfgfile = optarg; + break; + case 's': + svr = optarg; + break; + case '?': + case 'h': + default: + usage(); + } + } + argc -= optind; + argv += optind; + if(argc == 0) + usage(); + if(argc >= 1 && strcmp(argv[0], "start")==0) { + if(execl(NSD_START_PATH, "nsd", "-c", cfgfile, + (char*)NULL) < 0) { + fprintf(stderr, "could not exec %s: %s\n", + NSD_START_PATH, strerror(errno)); + exit(1); + } + } + + return go(cfgfile, svr, argc, argv); +} + +#else /* HAVE_SSL */ +int main(void) +{ + printf("error: NSD was compiled without SSL.\n"); + return 1; +} +#endif /* HAVE_SSL */ diff --git a/usr.sbin/nsd/nsd-mem.c b/usr.sbin/nsd/nsd-mem.c new file mode 100644 index 00000000000..0981eafef73 --- /dev/null +++ b/usr.sbin/nsd/nsd-mem.c @@ -0,0 +1,360 @@ +/* + * nsd-mem.c -- nsd-mem(8) + * + * Copyright (c) 2013, NLnet Labs. All rights reserved. + * + * See LICENSE for the license. + * + */ + +#include "config.h" + +#include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include <unistd.h> +#include <errno.h> + +#include "nsd.h" +#include "tsig.h" +#include "options.h" +#include "namedb.h" +#include "udb.h" +#include "udbzone.h" +#include "util.h" + +static void error(const char *format, ...) ATTR_FORMAT(printf, 1, 2); + +/* + * Print the help text. + * + */ +static void +usage (void) +{ + fprintf(stderr, "Usage: nsd-mem [-c configfile]\n"); + fprintf(stderr, "Version %s. Report bugs to <%s>.\n", + PACKAGE_VERSION, PACKAGE_BUGREPORT); +} + +/* + * Something went wrong, give error messages and exit. + * + */ +static void +error(const char *format, ...) +{ + va_list args; + va_start(args, format); + log_vmsg(LOG_ERR, format, args); + va_end(args); + exit(1); +} + +/* zone memory structure */ +struct zone_mem { + /* size of data (allocated in db.region) */ + size_t data; + /* unused space (in db.region) due to alignment */ + size_t data_unused; + /* udb data allocated */ + size_t udb_data; + /* udb overhead (chunk2**x - data) */ + size_t udb_overhead; + + /* count of number of domains */ + size_t domaincount; +}; + +/* total memory structure */ +struct tot_mem { + /* size of data (allocated in db.region) */ + size_t data; + /* unused space (in db.region) due to alignment */ + size_t data_unused; + /* udb data allocated */ + size_t udb_data; + /* udb overhead (chunk2**x - data) */ + size_t udb_overhead; + + /* count of number of domains */ + size_t domaincount; + + /* options data */ + size_t opt_data; + /* unused in options region */ + size_t opt_unused; + /* dname compression table */ + size_t compresstable; +#ifdef RATELIMIT + /* size of rrl tables */ + size_t rrl; +#endif + + /* total ram usage */ + size_t ram; + /* total nsd.db disk usage */ + size_t disk; +}; + +static void +account_zone(struct namedb* db, struct zone_mem* zmem) +{ + zmem->data = region_get_mem(db->region); + zmem->data_unused = region_get_mem_unused(db->region); + zmem->udb_data = (size_t)db->udb->alloc->disk->stat_data; + zmem->udb_overhead = (size_t)(db->udb->alloc->disk->stat_alloc - + db->udb->alloc->disk->stat_data); + zmem->domaincount = db->domains->nametree->count; +} + +static void +pretty_mem(size_t x, const char* s) +{ + char buf[32]; + memset(buf, 0, sizeof(buf)); + if(snprintf(buf, sizeof(buf), "%12lld", (long long)x) > 12) { + printf("%12lld %s\n", (long long)x, s); + return; + } + printf("%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c %s\n", + buf[0], buf[1], buf[2], (buf[2]==' '?' ':'.'), + buf[3], buf[4], buf[5], (buf[5]==' '?' ':'.'), + buf[6], buf[7], buf[8], (buf[8]==' '?' ':'.'), + buf[9], buf[10], buf[11], s); +} + +static void +print_zone_mem(struct zone_mem* z) +{ + pretty_mem(z->data, "zone data"); + pretty_mem(z->data_unused, "zone unused space (due to alignment)"); + pretty_mem(z->udb_data, "data in nsd.db"); + pretty_mem(z->udb_overhead, "overhead in nsd.db"); +} + +static void +account_total(nsd_options_t* opt, struct tot_mem* t) +{ + t->opt_data = region_get_mem(opt->region); + t->opt_unused = region_get_mem_unused(opt->region); + t->compresstable = sizeof(uint16_t) * + (t->domaincount + 1 + EXTRA_DOMAIN_NUMBERS); + t->compresstable *= opt->server_count; + +#ifdef RATELIMIT +#define SIZE_RRL_BUCKET (8 + 4 + 4 + 4 + 4 + 2) + t->rrl = opt->rrl_size * SIZE_RRL_BUCKET; + t->rrl *= opt->server_count; +#endif + + t->ram = t->data + t->data_unused + t->opt_data + t->opt_unused + + t->compresstable; +#ifdef RATELIMIT + t->ram += t->rrl; +#endif + t->disk = t->udb_data + t->udb_overhead; +} + +static void +print_tot_mem(struct tot_mem* t) +{ + printf("\ntotal\n"); + pretty_mem(t->data, "data"); + pretty_mem(t->data_unused, "unused space (due to alignment)"); + pretty_mem(t->opt_data, "options"); + pretty_mem(t->opt_unused, "options unused space (due to alignment)"); + pretty_mem(t->compresstable, "name table (depends on servercount)"); +#ifdef RATELIMIT + pretty_mem(t->rrl, "RRL table (depends on servercount)"); +#endif + pretty_mem(t->udb_data, "data in nsd.db"); + pretty_mem(t->udb_overhead, "overhead in nsd.db"); + printf("\nsummary\n"); + + pretty_mem(t->ram, "ram usage (excl space for buffers)"); + pretty_mem(t->disk, "disk usage (excl 12% space claimed for growth)"); +} + +static void +add_mem(struct tot_mem* t, struct zone_mem* z) +{ + t->data += z->data; + t->data_unused += z->data_unused; + t->udb_data += z->udb_data; + t->udb_overhead += z->udb_overhead; + t->domaincount += z->domaincount; +} + +static void +check_zone_mem(const char* tf, const char* df, zone_options_t* zo, + nsd_options_t* opt, struct tot_mem* totmem) +{ + struct namedb* db; + const dname_type* dname = (const dname_type*)zo->node.key; + zone_type* zone; + struct udb_base* taskudb; + udb_ptr last_task; + struct zone_mem zmem; + + printf("zone %s\n", zo->name); + + /* init*/ + memset(&zmem, 0, sizeof(zmem)); + db = namedb_open(df, opt); + if(!db) error("cannot open %s: %s", df, strerror(errno)); + zone = namedb_zone_create(db, dname, zo); + taskudb = udb_base_create_new(tf, &namedb_walkfunc, NULL); + udb_ptr_init(&last_task, taskudb); + + /* read the zone */ + namedb_read_zonefile(db, zone, taskudb, &last_task); + + /* account the memory for this zone */ + account_zone(db, &zmem); + + /* pretty print the memory for this zone */ + print_zone_mem(&zmem); + + /* delete the zone from memory */ + namedb_close(db); + udb_base_free(taskudb); + unlink(df); + unlink(tf); + + /* add up totals */ + add_mem(totmem, &zmem); +} + +static void +check_mem(nsd_options_t* opt) +{ + struct tot_mem totmem; + zone_options_t* zo; + char tf[512]; + char df[512]; + memset(&totmem, 0, sizeof(totmem)); + snprintf(tf, sizeof(tf), "./nsd-mem-task-%u.db", (unsigned)getpid()); + snprintf(df, sizeof(df), "./nsd-mem-db-%u.db", (unsigned)getpid()); + + /* read all zones and account memory */ + RBTREE_FOR(zo, zone_options_t*, opt->zone_options) { + check_zone_mem(tf, df, zo, opt, &totmem); + } + + /* calculate more total statistics */ + account_total(opt, &totmem); + /* print statistics */ + print_tot_mem(&totmem); + + /* final advice */ + printf("\nFinal advice estimate:\n"); + printf("(The partial mmap causes reload&AXFR to take longer(disk access))\n"); + pretty_mem(totmem.ram + totmem.disk, "data and big mmap"); + pretty_mem(totmem.ram + totmem.disk/6, "data and partial mmap"); +} + +/* dummy functions to link */ +struct nsd; +int writepid(struct nsd * ATTR_UNUSED(nsd)) +{ + return 0; +} +void unlinkpid(const char * ATTR_UNUSED(file)) +{ +} +void bind8_stats(struct nsd * ATTR_UNUSED(nsd)) +{ +} + +void sig_handler(int ATTR_UNUSED(sig)) +{ +} + +extern char *optarg; +extern int optind; + +int +main(int argc, char *argv[]) +{ + /* Scratch variables... */ + int c; + struct nsd nsd; + const char *configfile = CONFIGFILE; + memset(&nsd, 0, sizeof(nsd)); + + log_init("nsd-mem"); + + /* Parse the command line... */ + while ((c = getopt(argc, argv, "c:h" + )) != -1) { + switch (c) { + case 'c': + configfile = optarg; + break; + case 'h': + usage(); + exit(0); + case '?': + default: + usage(); + exit(1); + } + } + argc -= optind; + argv += optind; + + /* Commandline parse error */ + if (argc != 0) { + usage(); + exit(1); + } + + /* Read options */ + nsd.options = nsd_options_create(region_create_custom(xalloc, free, + DEFAULT_CHUNK_SIZE, DEFAULT_LARGE_OBJECT_SIZE, + DEFAULT_INITIAL_CLEANUP_SIZE, 1)); + tsig_init(nsd.options->region); + if(!parse_options_file(nsd.options, configfile, NULL, NULL)) { + error("could not read config: %s\n", configfile); + } + if(!parse_zone_list_file(nsd.options)) { + error("could not read zonelist file %s\n", + nsd.options->zonelistfile); + } + if (verbosity == 0) + verbosity = nsd.options->verbosity; + +#ifdef HAVE_CHROOT + if(nsd.chrootdir == 0) nsd.chrootdir = nsd.options->chroot; +#ifdef CHROOTDIR + /* if still no chrootdir, fallback to default */ + if(nsd.chrootdir == 0) nsd.chrootdir = CHROOTDIR; +#endif /* CHROOTDIR */ +#endif /* HAVE_CHROOT */ + if(nsd.options->zonesdir && nsd.options->zonesdir[0]) { + if(chdir(nsd.options->zonesdir)) { + error("cannot chdir to '%s': %s", + nsd.options->zonesdir, strerror(errno)); + } + DEBUG(DEBUG_IPC,1, (LOG_INFO, "changed directory to %s", + nsd.options->zonesdir)); + } + + /* Chroot */ +#ifdef HAVE_CHROOT + if (nsd.chrootdir && strlen(nsd.chrootdir)) { + if(chdir(nsd.chrootdir)) { + error("unable to chdir to chroot: %s", strerror(errno)); + } + DEBUG(DEBUG_IPC,1, (LOG_INFO, "changed root directory to %s", + nsd.chrootdir)); + } +#endif /* HAVE_CHROOT */ + + check_mem(nsd.options); + + exit(0); +} diff --git a/usr.sbin/nsd/nsd.conf.sample.in b/usr.sbin/nsd/nsd.conf.sample.in index fe1a4874c5c..002d40e7065 100644 --- a/usr.sbin/nsd/nsd.conf.sample.in +++ b/usr.sbin/nsd/nsd.conf.sample.in @@ -8,10 +8,15 @@ # This is a comment. # Sample configuration file +# include: "file" # include that file's text over here. # options for the nsd server server: - # uncomment to specify specific interfaces to bind (default wildcard interface). + # Number of NSD servers to fork. Put the number of CPUs to use here. + # server-count: 1 + + # uncomment to specify specific interfaces to bind (default are the + # wildcard interfaces 0.0.0.0 and ::0). # ip-address: 1.2.3.4 # ip-address: 1.2.3.4@5678 # ip-address: 12fe::8ef0 @@ -19,36 +24,65 @@ server: # Allow binding to non local addresses. Default no. # ip-transparent: no - # don't answer VERSION.BIND and VERSION.SERVER CHAOS class queries - # hide-version: no - # enable debug mode, does not fork daemon process into the background. # debug-mode: no - # listen only on IPv4 connections - # ip4-only: no + # listen on IPv4 connections + # do-ip4: yes + + # listen on IPv6 connections + # do-ip6: yes + + # port to answer queries on. default is 53. + # port: 53 + + # Verbosity level. + # verbosity: 0 - # listen only on IPv6 connections - # ip6-only: no + # After binding socket, drop user privileges. + # can be a username, id or id.gid. + # username: @user@ + + # Run NSD in a chroot-jail. + # make sure to have pidfile and database reachable from there. + # by default, no chroot-jail is used. + # chroot: "@configdir@" + + # The directory for zonefile: files. The daemon chdirs here. + # zonesdir: "@zonesdir@" + # the list of dynamically added zones. + # zonelistfile: "@zonelistfile@" + # the database to use # database: "@dbfile@" + # log messages to file. Default to stderr and syslog (with + # facility LOG_DAEMON). stderr disappears when daemon goes to bg. + # logfile: "@logfile@" + + # File to store pid for nsd in. + # pidfile: "@pidfile@" + + # The file where secondary zone refresh and expire timeouts are kept. + # If you delete this file, all secondary zones are forced to be + # 'refreshing' (as if nsd got a notify). + # xfrdfile: "@xfrdfile@" + + # The directory where zone transfers are stored, in a subdir of it. + # xfrdir: "@xfrdir@" + + # don't answer VERSION.BIND and VERSION.SERVER CHAOS class queries + # hide-version: no + # identify the server (CH TXT ID.SERVER entry). # identity: "unidentified server" # NSID identity (hex string). default disabled. # nsid: "aabbccdd" - # log messages to file. Default to stderr and syslog (with facility LOG_DAEMON). - # logfile: "@logfile@" - - # Number of NSD servers to fork. - # server-count: 1 - # Maximum number of concurrent TCP connections per server. - # This option should have a value below 1000. - # tcp-count: 10 + # tcp-count: 100 # Maximum number of queries served on a single TCP connection. # By default 0, which means no maximum. @@ -63,44 +97,14 @@ server: # Preferred EDNS buffer size for IPv6. # ipv6-edns-size: 4096 - # File to store pid for nsd in. - # pidfile: "@pidfile@" - - # port to answer queries on. default is 53. - # port: 53 - - # statistics are produced every number of seconds. + # statistics are produced every number of seconds. Prints to log. # statistics: 3600 - # if per zone statistics is enabled, file to store statistics. - # zone-stats-file: "@zonestatsfile@" - - # Run NSD in a chroot-jail. - # make sure to have pidfile and database reachable from there. - # by default, no chroot-jail is used. - # chroot: "@configdir@" - - # After binding socket, drop user privileges. - # can be a username, id or id.gid. - # username: @user@ - - # The directory for zonefile: files. - # zonesdir: "@zonesdir@" - - # The file where incoming zone transfers are stored. - # run nsd-patch to update zone files, then you can safely delete it. - # difffile: "@difffile@" - - # The file where secondary zone refresh and expire timeouts are kept. - # If you delete this file, all secondary zones are forced to be - # 'refreshing' (as if nsd got a notify). - # xfrdfile: "@xfrdfile@" - # Number of seconds between reloads triggered by xfrd. - # xfrd-reload-timeout: 10 + # xfrd-reload-timeout: 1 - # Verbosity level. - # verbosity: 0 + # check mtime of all zone files on start and sighup + # zonefiles-check: yes # RRLconfig # Response Rate Limiting, size of the hashtable. Default 1000000. @@ -132,79 +136,113 @@ server: # rrl-whitelist-ratelimit: 2000 # RRLend -# key for zone 1 -key: - name: mskey - algorithm: hmac-md5 - secret: "K2tf3TRjvQkVCmJF3/Z9vA==" +# Remote control config section. +remote-control: + # Enable remote control with nsd-control(8) here. + # set up the keys and certificates with nsd-control-setup. + # control-enable: no -# Sample zone 1 -zone: - name: "example.com" - zonefile: "example.com.zone" + # what interfaces are listened to for control, default is on localhost. + # control-interface: 127.0.0.1 + # control-interface: ::1 - # This is a slave zone. Masters are listed below. - # If no access control elements are provided, this zone - # will not be served to/from other servers. + # port number for remote control operations (uses TLS over TCP). + # control-port: 8952 - # master 1 - allow-notify: 168.192.44.42 mskey - request-xfr: 168.192.44.42 mskey + # nsd server key file for remote control. + # server-key-file: "@configdir@/nsd_server.key" - # master 2 - allow-notify: 10.0.0.11 NOKEY - request-xfr: 10.0.0.11 NOKEY + # nsd server certificate file for remote control. + # server-cert-file: "@configdir@/nsd_server.pem" - # By default, a slave will request a zone transfer with IXFR/TCP. - # If you want to make use of IXFR/UDP use - allow-notify: 10.0.0.12 NOKEY - request-xfr: UDP 10.0.0.12 NOKEY + # nsd-control key file. + # control-key-file: "@configdir@/nsd_control.key" - # for a master that only speaks AXFR (like NSD) use - allow-notify: 10.0.0.13 NOKEY - request-xfr: AXFR 10.0.0.13 NOKEY + # nsd-control certificate file. + # control-cert-file: "@configdir@/nsd_control.pem" - # Attention: You cannot use UDP and AXFR together. AXFR is always over - # TCP. If you use UDP, we higly recommend you to deploy TSIG. - # Allow AXFR fallback if the master does not support IXFR. Default - # is yes. - allow-axfr-fallback: "yes" +# Secret keys for TSIGs that secure zone transfers. +# You could include: "secret.keys" and put the 'key:' statements in there, +# and give that file special access control permissions. +# +# key: + # The key name is sent to the other party, it must be the same + #name: "keyname" + # algorithm hmac-md5, or hmac-sha1, or hmac-sha256 (if compiled in) + #algorithm: hmac-sha256 + # secret material, must be the same as the other party uses. + # base64 encoded random number. + # e.g. from dd if=/dev/random of=/dev/stdout count=1 bs=32 | base64 + #secret: "K2tf3TRjvQkVCmJF3/Z9vA==" + + +# Patterns have zone configuration and they are shared by one or more zones. +# +# pattern: + # name by which the pattern is referred to + #name: "myzones" + # the zonefile for the zones that use this pattern. + # if relative then from the zonesdir (inside the chroot). + # the name is processed: %s - zone name (as appears in zone:name). + # %1 - first character of zone name, %2 second, %3 third. + # %z - topleveldomain label of zone, %y, %x next labels in name. + # if label or character does not exist you get a dot '.'. + # for example "%s.zone" or "zones/%1/%2/%3/%s" or "secondary/%z/%s" + #zonefile: "%s.zone" + + # If no master and slave access control elements are provided, + # this zone will not be served to/from other servers. + + # A master zone needs notify: and provide-xfr: lists. A slave + # may also allow zone transfer (for debug or other secondaries). + # notify these slaves when the master zone changes, address TSIG|NOKEY + # IP can be ipv4 and ipv6, with @port for a nondefault port number. + #notify: 192.0.2.1 NOKEY + # allow these IPs and TSIG to transfer zones, addr TSIG|NOKEY|BLOCKED + # address range 192.0.2.0/24, 1.2.3.4&255.255.0.0, 3.0.2.20-3.0.2.40 + #provide-xfr: 192.0.2.0/24 my_tsig_key_name + # set the number of retries for notify. + #notify-retry: 5 # uncomment to provide AXFR to all the world # provide-xfr: 0.0.0.0/0 NOKEY # provide-xfr: ::0/0 NOKEY + # A slave zone needs allow-notify: and request-xfr: lists. + #allow-notify: 2001:db8::0/64 my_tsig_key_name + # By default, a slave will request a zone transfer with IXFR/TCP. + # If you want to make use of IXFR/UDP use: UDP addr tsigkey + # for a master that only speaks AXFR (like NSD) use AXFR addr tsigkey + #request-xfr: 192.0.2.2 the_tsig_key_name + # Attention: You cannot use UDP and AXFR together. AXFR is always over + # TCP. If you use UDP, we higly recommend you to deploy TSIG. + # Allow AXFR fallback if the master does not support IXFR. Default + # is yes. + #allow-axfr-fallback: yes # set local interface for sending zone transfer requests. - outgoing-interface: 10.0.0.10 - -# Sample zone 2 -zone: - name: "example.net" - zonefile: "example.net.signed.zone" - - # This is a master zone. Slaves are listed below. - # If no access control elements are provided, this zone - # will not be served to/from other servers. + # default is let the OS choose. + #outgoing-interface: 10.0.0.10 - # secondary 1. Uses port 5300. - notify: 10.0.0.14@5300 sec1_key - provide-xfr: 10.0.0.14@5300 sec1_key + # if you give another pattern name here, at this point the settings + # from that pattern are inserted into this one (as if it were a + # macro). The statement can be given in between other statements, + # because the order of access control elements can make a difference + # (which master to request from first, which slave to notify first). + #include-pattern: "common-masters" - # secondary 2. - notify: 10.11.12.14 sec2_key - provide-xfr: 10.11.12.14 sec2_key - - # also provide xfr to operator's network. - provide-xfr: 169.192.85.0/24 NOKEY - # uncomment to disable xfr for the address. - # provide-xfr: 169.192.85.66 BLOCKED - - # set the number of retries for notify. - notify-retry: 5 - # set local interface for sending notifies - outgoing-interface: 10.0.0.15 +# Fixed zone entries. Here you can config zones that cannot be deleted. +# Zones that are dynamically added and deleted are put in the zonelist file. +# +# zone: + # name: "example.com" + # you can give a pattern here, all the settings from that pattern + # are then inserted at this point + # include-pattern: "master" + # You can also specify (additional) options directly for this zone. + # zonefile: "example.com.zone" + # request-xfr: 192.0.2.1 example.com.key # RRLconfig # Response Rate Limiting, whitelist types @@ -220,20 +258,3 @@ zone: # rrl-whitelist: all # RRLend - -# keys for zone 2 -key: - name: "sec1_key" - algorithm: hmac-md5 - secret: "6KM6qiKfwfEpamEq72HQdA==" - -key: - name: sec2_key - algorithm: hmac-sha1 - secret: "m83H2x8R0zbDf3yRKhrqgw==" - -key: - name: sec3_key - algorithm: hmac-sha256 - secret: "m83H2x8R0zbDf3yRKhrqgw==" - diff --git a/usr.sbin/nsd/nsd.h b/usr.sbin/nsd/nsd.h index 2dd4676937e..955fc4fbae2 100644 --- a/usr.sbin/nsd/nsd.h +++ b/usr.sbin/nsd/nsd.h @@ -1,7 +1,7 @@ /* * nsd.h -- nsd(8) definitions and prototypes * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -14,9 +14,10 @@ #include "dns.h" #include "edns.h" -#include "util.h" struct netio_handler; struct nsd_options; +struct udb_base; +struct daemon_remote; /* The NSD runtime states and NSD ipc command values */ #define NSD_RUN 0 @@ -26,42 +27,38 @@ struct nsd_options; #define NSD_REAP_CHILDREN 4 #define NSD_QUIT 5 /* - * NSD_SOA_INFO is followed by u16(len in network byte order), dname, - * and then nothing (no info) or soa info. - */ -#define NSD_SOA_INFO 6 -/* * PASS_TO_XFRD is followed by the u16(len in network order) and * then network packet contents. packet is a notify(acl checked), or * xfr reply from a master(acl checked). * followed by u32(acl number that matched from notify/xfr acl). */ -#define NSD_PASS_TO_XFRD 7 +#define NSD_PASS_TO_XFRD 6 /* - * NSD_ZONE_STATE is followed by u16(len in network byte order), - * octet 0: zone is expired, 1: zone ok. and dname of zone. + * RELOAD_REQ is sent when parent receives a SIGHUP and tells + * xfrd that it wants to initiate a reload (and thus task swap). */ -#define NSD_ZONE_STATE 8 +#define NSD_RELOAD_REQ 7 /* - * SOA BEGIN is sent at the start of a reload SOA_INFO pass - * xfrd will not send to the parent (deadlock prevention). - */ -#define NSD_SOA_BEGIN 9 -/* - * SOA END is sent at the end of a reload SOA_INFO pass. + * RELOAD_DONE is sent at the end of a reload pass. * xfrd then knows that reload phase is over. */ -#define NSD_SOA_END 10 +#define NSD_RELOAD_DONE 8 /* * QUIT_SYNC is sent to signify a synchronisation of ipc * channel content during reload */ -#define NSD_QUIT_SYNC 11 +#define NSD_QUIT_SYNC 9 +/* + * QUIT_WITH_STATS is sent during a reload when BIND8_STATS is defined, + * from parent to children. The stats are transferred too from child to + * parent with this commandvalue, when the child is exiting. + */ +#define NSD_QUIT_WITH_STATS 10 /* * QUIT_CHILD is sent at exit, to make sure the child has exited so that * port53 is free when all of nsd's processes have exited at shutdown time */ -#define NSD_QUIT_CHILD 12 +#define NSD_QUIT_CHILD 11 #define NSD_SERVER_MAIN 0x0U #define NSD_SERVER_UDP 0x1U @@ -76,29 +73,20 @@ struct nsd_options; #ifdef BIND8_STATS -#define LASTELEM(arr) (sizeof(arr) / sizeof(arr[0]) - 1) - -#define STATUP(nsd, stc) nsd->st.stc++ -#define STATUP2(nsd, stc, i) nsd->st.stc[(i) <= (LASTELEM(nsd->st.stc) - 1) ? i : LASTELEM(nsd->st.stc)]++ - -# ifdef USE_ZONE_STATS +/* Counter for statistics */ +typedef unsigned long stc_t; -# define ZTATUP(zone, stc) zone->st.stc++ -# define ZTATUP2(zone, stc, i) zone->st.stc[(i) <= (LASTELEM(zone->st.stc) - 1) ? i : LASTELEM(zone->st.stc)]++ - -# else - -# define ZTATUP(zone, stc) /* Nothing */ -# define ZTATUP2(zone, stc, i) /* Nothing */ +#define LASTELEM(arr) (sizeof(arr) / sizeof(arr[0]) - 1) -# endif /* USE_ZONE_STATS */ +#define STATUP(nsd, stc) nsd->st.stc++ +/* #define STATUP2(nsd, stc, i) ((i) <= (LASTELEM(nsd->st.stc) - 1)) ? nsd->st.stc[(i)]++ : \ + nsd->st.stc[LASTELEM(nsd->st.stc)]++ */ -#else /* BIND8_STATS */ +#define STATUP2(nsd, stc, i) nsd->st.stc[(i) <= (LASTELEM(nsd->st.stc) - 1) ? i : LASTELEM(nsd->st.stc)]++ +#else /* BIND8_STATS */ #define STATUP(nsd, stc) /* Nothing */ #define STATUP2(nsd, stc, i) /* Nothing */ -#define ZTATUP(zone, stc) /* Nothing */ -#define ZTATUP2(zone, stc, i) /* Nothing */ #endif /* BIND8_STATS */ @@ -133,12 +121,15 @@ struct nsd_child */ uint8_t need_to_send_STATS, need_to_send_QUIT; uint8_t need_to_exit, has_exited; - stack_type* dirty_zones; /* stack of type zone_type* */ /* * The handler for handling the commands from the child. */ struct netio_handler* handler; + +#ifdef BIND8_STATS + stc_t query_count; +#endif }; /* NSD configuration and run-time variables */ @@ -153,6 +144,7 @@ struct nsd /* Run-time variables */ pid_t pid; volatile sig_atomic_t mode; + volatile sig_atomic_t signal_hint_reload_hup; volatile sig_atomic_t signal_hint_reload; volatile sig_atomic_t signal_hint_child; volatile sig_atomic_t signal_hint_quit; @@ -170,12 +162,15 @@ struct nsd /* NULL if this is the parent process. */ struct nsd_child *this_child; + /* mmaps with data exchange from xfrd and reload */ + struct udb_base* task[2]; + int mytask; /* the base used by this process */ + struct netio_handler* xfrd_listener; + struct daemon_remote* rc; + /* Configuration */ const char *dbfile; const char *pidfile; -#ifdef USE_ZONE_STATS - const char *zonestatsfile; -#endif const char *log_filename; const char *username; uid_t uid; @@ -210,7 +205,20 @@ struct nsd size_t ipv6_edns_size; #ifdef BIND8_STATS - struct nsdst st; + + struct nsdst { + time_t boot; + int period; /* Produce statistics dump every st_period seconds */ + stc_t qtype[257]; /* Counters per qtype */ + stc_t qclass[4]; /* Class IN or Class CH or other */ + stc_t qudp, qudp6; /* Number of queries udp and udp6 */ + stc_t ctcp, ctcp6; /* Number of tcp and tcp6 connections */ + stc_t rcode[17], opcode[6]; /* Rcodes & opcodes */ + /* Dropped, truncated, queries for nonconfigured zone, tx errors */ + stc_t dropped, truncated, wrongzone, txerr, rxerr; + stc_t edns, ednserr, raxfr, nona; + uint64_t db_disk, db_mem; + } st; #endif /* BIND8_STATS */ struct nsd_options* options; @@ -230,7 +238,16 @@ void server_main(struct nsd *nsd); void server_child(struct nsd *nsd); void server_shutdown(struct nsd *nsd); void server_close_all_sockets(struct nsd_socket sockets[], size_t n); +struct event_base* nsd_child_event_base(void); /* extra domain numbers for temporary domains */ #define EXTRA_DOMAIN_NUMBERS 1024 +#define SLOW_ACCEPT_TIMEOUT 2 /* in seconds */ +/* allocate and init xfrd variables */ +void server_prepare_xfrd(struct nsd *nsd); +/* start xfrdaemon (again) */ +void server_start_xfrd(struct nsd *nsd, int del_db, int reload_active); +/* send SOA serial numbers to xfrd */ +void server_send_soa_xfrd(struct nsd *nsd, int shortsoa); +ssize_t block_read(struct nsd* nsd, int s, void* p, ssize_t sz, int timeout); #endif /* _NSD_H_ */ diff --git a/usr.sbin/nsd/nsec3.h b/usr.sbin/nsd/nsec3.h index d55b4825394..96c4367ff33 100644 --- a/usr.sbin/nsd/nsec3.h +++ b/usr.sbin/nsd/nsec3.h @@ -1,7 +1,7 @@ /* * nsec3.h -- nsec3 handling. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -9,9 +9,8 @@ #ifndef NSEC3_H #define NSEC3_H -#include "config.h" #ifdef NSEC3 - +struct udb_ptr; struct domain; struct dname; struct region; @@ -19,40 +18,23 @@ struct zone; struct namedb; struct query; struct answer; -#ifndef FULL_PREHASH struct rr; -struct nsec3_domain; -#endif /* - * Create the hashed name of the nsec3 record - * for the given dname. + * calculate prehash information for zone. */ -const struct dname *nsec3_hash_dname(struct region *region, - struct zone *zone, const struct dname *dname); - +void prehash_zone(struct namedb* db, struct zone* zone); /* - * calculate prehash information for all zones, - * selects only updated=1 zones if bool set. + * calculate prehash for zone, assumes no partial precompile or prehashlist */ -void prehash(struct namedb* db, int updated_only); -#ifndef FULL_PREHASH -void prehash_zone(struct namedb *db, struct zone *zone); -void prehash_zone_incremental(struct namedb *db, struct zone *zone); -#endif +void prehash_zone_complete(struct namedb* db, struct zone* zone); /* - * finds nsec3 that covers the given domain dname. + * finds nsec3 that covers the given domain hash. * returns true if the find is exact. - * hashname is the already hashed dname for the NSEC3. */ -#ifdef FULL_PREHASH -int nsec3_find_cover(struct namedb* db, struct zone* zone, - const struct dname* hashname, struct domain** result); -#else -int nsec3_find_cover(struct namedb* ATTR_UNUSED(db), struct zone* zone, - const struct dname* hashname, struct nsec3_domain** result); -#endif +int nsec3_find_cover(struct zone* zone, uint8_t* hash, size_t hashlen, + struct domain** result); /* * _answer_ Routines used to add the correct nsec3 record to a query answer. @@ -62,9 +44,8 @@ int nsec3_find_cover(struct namedb* ATTR_UNUSED(db), struct zone* zone, * add proof for wildcards that the name below the wildcard.parent * does not exist */ -void nsec3_answer_wildcard(struct query *query, struct answer *answer, - struct domain *wildcard, struct namedb* db, - const struct dname *qname); +void nsec3_answer_wildcard(struct query* query, struct answer* answer, + struct domain* wildcard, const struct dname* qname); /* * add NSEC3 to provide domain name but not rrset exists, @@ -84,7 +65,7 @@ void nsec3_answer_delegation(struct query *query, struct answer *answer); */ void nsec3_answer_authoritative(struct domain** match, struct query *query, struct answer *answer, struct domain* closest_encloser, - struct namedb* db, const struct dname* qname); + const struct dname* qname); /* * True if domain is a NSEC3 (+RRSIG) data only variety. @@ -92,5 +73,48 @@ void nsec3_answer_authoritative(struct domain** match, struct query *query, */ int domain_has_only_NSEC3(struct domain* domain, struct zone* zone); +/* get hashed bytes */ +void nsec3_hash_and_store(struct zone* zone, const struct dname* dname, + uint8_t* store); +/* see if NSEC3 record uses the params in use for the zone */ +int nsec3_rr_uses_params(struct rr* rr, struct zone* zone); +/* number of NSEC3s that are in the zone chain */ +int nsec3_in_chain_count(struct domain* domain, struct zone* zone); +/* find previous NSEC3, or, lastinzone, or, NULL */ +struct domain* nsec3_chain_find_prev(struct zone* zone, struct domain* domain); +/* clear nsec3 precompile for the zone */ +void nsec3_clear_precompile(struct namedb* db, struct zone* zone); +/* if domain is part of nsec3hashed domains of a zone */ +int nsec3_domain_part_of_zone(struct domain* d, struct zone* z); +/* condition when a domain is precompiled */ +int nsec3_condition_hash(struct domain* d, struct zone* z); +/* condition when a domain is ds precompiled */ +int nsec3_condition_dshash(struct domain* d, struct zone* z); +/* set nsec3param for this zone or NULL if no NSEC3 available */ +void nsec3_find_zone_param(struct namedb* db, struct zone* zone, + struct udb_ptr* z); +/* hash domain and wcchild, and lookup nsec3 in tree, and precompile */ +void nsec3_precompile_domain(struct namedb* db, struct domain* domain, + struct zone* zone, struct region* tmpregion); +/* hash ds_parent_cover, and lookup nsec3 and precompile */ +void nsec3_precompile_domain_ds(struct namedb* db, struct domain* domain, + struct zone* zone); +/* put nsec3 into nsec3tree and adjust zonelast */ +void nsec3_precompile_nsec3rr(struct namedb* db, struct domain* domain, + struct zone* zone); +/* precompile entire zone, assumes all is null at start */ +void nsec3_precompile_newparam(struct namedb* db, struct zone* zone); +/* create b32.zone for a hash, allocated in the region */ +const struct dname* nsec3_b32_create(struct region* region, struct zone* zone, + unsigned char* hash); +/* create trees for nsec3 updates and lookups in zone */ +void nsec3_zone_trees_create(struct region* region, struct zone* zone); +/* clear trees for nsec3 in zone */ +void nsec3_hash_tree_clear(struct zone* zone); +/* lookup zone that contains domain's nsec3 trees */ +struct zone* nsec3_tree_zone(struct namedb* db, struct domain* domain); +/* lookup zone that contains domain's ds tree */ +struct zone* nsec3_tree_dszone(struct namedb* db, struct domain* domain); + #endif /* NSEC3 */ #endif /* NSEC3_H*/ diff --git a/usr.sbin/nsd/options.c b/usr.sbin/nsd/options.c index 39cfa610864..221a0f7eb35 100644 --- a/usr.sbin/nsd/options.c +++ b/usr.sbin/nsd/options.c @@ -1,7 +1,7 @@ /* * options.c -- options functions. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -13,10 +13,11 @@ #include "options.h" #include "query.h" #include "tsig.h" +#include "difffile.h" #include "rrl.h" #include "configyyrename.h" -nsd_options_t* nsd_options = 0; +#include "configparser.h" config_parser_state_t* cfg_parser = 0; extern FILE* c_in, *c_out; int c_parse(void); @@ -24,28 +25,36 @@ int c_lex(void); int c_wrap(void); void c_error(const char *message); -nsd_options_t* nsd_options_create(region_type* region) +static int +rbtree_strcmp(const void* p1, const void* p2) +{ + return strcmp((const char*)p1, (const char*)p2); +} + +nsd_options_t* +nsd_options_create(region_type* region) { nsd_options_t* opt; opt = (nsd_options_t*)region_alloc(region, sizeof(nsd_options_t)); opt->region = region; opt->zone_options = rbtree_create(region, (int (*)(const void *, const void *)) dname_compare); - opt->keys = NULL; - opt->numkeys = 0; + opt->configfile = NULL; + opt->patterns = rbtree_create(region, rbtree_strcmp); + opt->keys = rbtree_create(region, rbtree_strcmp); opt->ip_addresses = NULL; opt->ip_transparent = 0; opt->debug_mode = 0; opt->verbosity = 0; opt->hide_version = 0; - opt->ip4_only = 0; - opt->ip6_only = 0; + opt->do_ip4 = 1; + opt->do_ip6 = 1; opt->database = DBFILE; opt->identity = 0; opt->nsid = 0; opt->logfile = 0; opt->server_count = 1; - opt->tcp_count = 10; + opt->tcp_count = 100; opt->tcp_query_count = 0; opt->tcp_timeout = TCP_TIMEOUT; opt->ipv4_edns_size = EDNS_MAX_MESSAGE_LEN; @@ -54,17 +63,12 @@ nsd_options_t* nsd_options_create(region_type* region) opt->port = UDP_PORT; /* deprecated? opt->port = TCP_PORT; */ opt->statistics = 0; -#ifdef USE_ZONE_STATS - opt->zonestatsfile = ZONESTATSFILE; -#else - opt->zonestatsfile = 0; -#endif opt->chroot = 0; opt->username = USER; opt->zonesdir = ZONESDIR; - opt->difffile = DIFFFILE; opt->xfrdfile = XFRDFILE; - opt->xfrd_reload_timeout = 10; + opt->xfrdir = XFRDIR; + opt->zonelistfile = ZONELISTFILE; #ifdef RATELIMIT opt->rrl_size = RRL_BUCKETS; opt->rrl_ratelimit = RRL_LIMIT/2; @@ -73,11 +77,20 @@ nsd_options_t* nsd_options_create(region_type* region) opt->rrl_ipv6_prefix_length = RRL_IPV6_PREFIX_LENGTH; opt->rrl_whitelist_ratelimit = RRL_WLIST_LIMIT/2; #endif - nsd_options = opt; + opt->zonefiles_check = 1; + opt->xfrd_reload_timeout = 1; + opt->control_enable = 0; + opt->control_interface = NULL; + opt->control_port = NSD_CONTROL_PORT; + opt->server_key_file = CONFIGDIR"/nsd_server.key"; + opt->server_cert_file = CONFIGDIR"/nsd_server.pem"; + opt->control_key_file = CONFIGDIR"/nsd_control.key"; + opt->control_cert_file = CONFIGDIR"/nsd_control.pem"; return opt; } -int nsd_options_insert_zone(nsd_options_t* opt, zone_options_t* zone) +int +nsd_options_insert_zone(nsd_options_t* opt, zone_options_t* zone) { /* create dname for lookup */ const dname_type* dname = dname_parse(opt->region, zone->name); @@ -89,23 +102,40 @@ int nsd_options_insert_zone(nsd_options_t* opt, zone_options_t* zone) return 1; } -int parse_options_file(nsd_options_t* opt, const char* file) +int +nsd_options_insert_pattern(nsd_options_t* opt, pattern_options_t* pat) +{ + if(!pat->pname) + return 0; + pat->node.key = pat->pname; + if(!rbtree_insert(opt->patterns, (rbnode_t*)pat)) + return 0; + return 1; +} + +int +parse_options_file(nsd_options_t* opt, const char* file, + void (*err)(void*,const char*), void* err_arg) { FILE *in = 0; - zone_options_t* zone; + pattern_options_t* pat; acl_options_t* acl; - if(!cfg_parser) + if(!cfg_parser) { cfg_parser = (config_parser_state_t*)region_alloc( opt->region, sizeof(config_parser_state_t)); + cfg_parser->chroot = 0; + } + cfg_parser->err = err; + cfg_parser->err_arg = err_arg; cfg_parser->filename = file; cfg_parser->line = 1; cfg_parser->errors = 0; + cfg_parser->server_settings_seen = 0; cfg_parser->opt = opt; + cfg_parser->current_pattern = 0; cfg_parser->current_zone = 0; - cfg_parser->current_key = opt->keys; - while(cfg_parser->current_key && cfg_parser->current_key->next) - cfg_parser->current_key = cfg_parser->current_key->next; + cfg_parser->current_key = 0; cfg_parser->current_ip_address_option = opt->ip_addresses; while(cfg_parser->current_ip_address_option && cfg_parser->current_ip_address_option->next) cfg_parser->current_ip_address_option = cfg_parser->current_ip_address_option->next; @@ -113,16 +143,34 @@ int parse_options_file(nsd_options_t* opt, const char* file) cfg_parser->current_request_xfr = 0; cfg_parser->current_notify = 0; cfg_parser->current_provide_xfr = 0; - + in = fopen(cfg_parser->filename, "r"); if(!in) { - fprintf(stderr, "Could not open %s: %s\n", file, strerror(errno)); + if(err) { + char m[MAXSYSLOGMSGLEN]; + snprintf(m, sizeof(m), "Could not open %s: %s\n", + file, strerror(errno)); + err(err_arg, m); + } else { + fprintf(stderr, "Could not open %s: %s\n", + file, strerror(errno)); + } return 0; } c_in = in; c_parse(); fclose(in); + opt->configfile = region_strdup(opt->region, file); + if(cfg_parser->current_pattern) { + if(!cfg_parser->current_pattern->pname) + c_error("last pattern has no name"); + else { + if(!nsd_options_insert_pattern(cfg_parser->opt, + cfg_parser->current_pattern)) + c_error("duplicate pattern"); + } + } if(cfg_parser->current_zone) { if(!cfg_parser->current_zone->name) c_error("last zone has no name"); @@ -131,83 +179,499 @@ int parse_options_file(nsd_options_t* opt, const char* file) cfg_parser->current_zone)) c_error("duplicate zone"); } - if(!cfg_parser->current_zone->zonefile) - c_error("last zone has no zonefile"); + if(!cfg_parser->current_zone->pattern) + c_error("last zone has no pattern"); } - if(opt->keys) + if(cfg_parser->current_key) { - if(!opt->keys->name) + if(!cfg_parser->current_key->name) c_error("last key has no name"); - if(!opt->keys->algorithm) + if(!cfg_parser->current_key->algorithm) c_error("last key has no algorithm"); - if(!opt->keys->secret) + if(!cfg_parser->current_key->secret) c_error("last key has no secret blob"); + key_options_insert(opt, cfg_parser->current_key); } - RBTREE_FOR(zone, zone_options_t*, opt->zone_options) + RBTREE_FOR(pat, pattern_options_t*, opt->patterns) { - if(!zone->name) - continue; - if(!zone->zonefile) - continue; /* lookup keys for acls */ - for(acl=zone->allow_notify; acl; acl=acl->next) + for(acl=pat->allow_notify; acl; acl=acl->next) { if(acl->nokey || acl->blocked) continue; acl->key_options = key_options_find(opt, acl->key_name); if(!acl->key_options) - c_error_msg("key %s in zone %s could not be found", - acl->key_name, zone->name); + c_error_msg("key %s in pattern %s could not be found", + acl->key_name, pat->pname); } - for(acl=zone->notify; acl; acl=acl->next) + for(acl=pat->notify; acl; acl=acl->next) { if(acl->nokey || acl->blocked) continue; acl->key_options = key_options_find(opt, acl->key_name); if(!acl->key_options) - c_error_msg("key %s in zone %s could not be found", - acl->key_name, zone->name); + c_error_msg("key %s in pattern %s could not be found", + acl->key_name, pat->pname); } - for(acl=zone->request_xfr; acl; acl=acl->next) + for(acl=pat->request_xfr; acl; acl=acl->next) { if(acl->nokey || acl->blocked) continue; acl->key_options = key_options_find(opt, acl->key_name); if(!acl->key_options) - c_error_msg("key %s in zone %s could not be found", - acl->key_name, zone->name); + c_error_msg("key %s in pattern %s could not be found", + acl->key_name, pat->pname); } - for(acl=zone->provide_xfr; acl; acl=acl->next) + for(acl=pat->provide_xfr; acl; acl=acl->next) { if(acl->nokey || acl->blocked) continue; acl->key_options = key_options_find(opt, acl->key_name); if(!acl->key_options) - c_error_msg("key %s in zone %s could not be found", - acl->key_name, zone->name); + c_error_msg("key %s in pattern %s could not be found", + acl->key_name, pat->pname); } } if(cfg_parser->errors > 0) { - fprintf(stderr, "read %s failed: %d errors in configuration file\n", - cfg_parser->filename, - cfg_parser->errors); + if(err) { + char m[MAXSYSLOGMSGLEN]; + snprintf(m, sizeof(m), "read %s failed: %d errors in " + "configuration file\n", cfg_parser->filename, + cfg_parser->errors); + err(err_arg, m); + } else { + fprintf(stderr, "read %s failed: %d errors in " + "configuration file\n", cfg_parser->filename, + cfg_parser->errors); + } return 0; } return 1; } -void c_error_va_list(const char *fmt, va_list args) +#define ZONELIST_HEADER "# NSD zone list\n# name pattern\n" +static int +comp_zonebucket(const void* a, const void* b) +{ + return *(const int*)b - *(const int*)a; +} + +/* insert free entry into zonelist free buckets */ +static void +zone_list_free_insert(nsd_options_t* opt, int linesize, off_t off) +{ + struct zonelist_free* e; + struct zonelist_bucket* b = (struct zonelist_bucket*)rbtree_search( + opt->zonefree, &linesize); + if(!b) { + b = region_alloc_zero(opt->region, sizeof(*b)); + b->linesize = linesize; + b->node = *RBTREE_NULL; + b->node.key = &b->linesize; + rbtree_insert(opt->zonefree, &b->node); + } + e = (struct zonelist_free*)region_alloc_zero(opt->region, sizeof(*e)); + e->next = b->list; + b->list = e; + e->off = off; + opt->zonefree_number++; +} + +zone_options_t* +zone_list_zone_insert(nsd_options_t* opt, const char* nm, const char* patnm, + int linesize, off_t off) +{ + pattern_options_t* pat = pattern_options_find(opt, patnm); + zone_options_t* zone; + if(!pat) { + log_msg(LOG_ERR, "pattern does not exist for zone %s " + "pattern %s", nm, patnm); + return NULL; + } + zone = zone_options_create(opt->region); + zone->part_of_config = 0; + zone->name = region_strdup(opt->region, nm); + zone->linesize = linesize; + zone->off = off; + zone->pattern = pat; + if(!nsd_options_insert_zone(opt, zone)) { + log_msg(LOG_ERR, "bad domain name or duplicate zone '%s' " + "pattern %s", nm, patnm); + region_recycle(opt->region, (void*)zone->name, strlen(nm)+1); + region_recycle(opt->region, zone, sizeof(*zone)); + return NULL; + } + return zone; +} + +int +parse_zone_list_file(nsd_options_t* opt) +{ + /* zonelist looks like this: + # name pattern + add example.com master + del example.net slave + add foo.bar.nl slave + add rutabaga.uk config + */ + char buf[1024]; + + /* create empty data structures */ + opt->zonefree = rbtree_create(opt->region, comp_zonebucket); + opt->zonelist = NULL; + opt->zonefree_number = 0; + opt->zonelist_off = 0; + + /* try to open the zonelist file, an empty or nonexist file is OK */ + opt->zonelist = fopen(opt->zonelistfile, "r+"); + if(!opt->zonelist) { + if(errno == ENOENT) + return 1; /* file does not exist, it is created later */ + log_msg(LOG_ERR, "could not open zone list %s: %s", opt->zonelistfile, + strerror(errno)); + return 0; + } + /* read header */ + buf[strlen(ZONELIST_HEADER)] = 0; + if(fread(buf, 1, strlen(ZONELIST_HEADER), opt->zonelist) != + strlen(ZONELIST_HEADER) || strncmp(buf, ZONELIST_HEADER, + strlen(ZONELIST_HEADER)) != 0) { + log_msg(LOG_ERR, "zone list %s contains bad header\n", opt->zonelistfile); + fclose(opt->zonelist); + opt->zonelist = NULL; + return 0; + } + + /* read entries in file */ + while(fgets(buf, sizeof(buf), opt->zonelist)) { + /* skip comments and empty lines */ + if(buf[0] == 0 || buf[0] == '\n' || buf[0] == '#') + continue; + if(strncmp(buf, "add ", 4) == 0) { + int linesize = strlen(buf); + /* parse the 'add' line */ + /* pick last space on the line, so that the domain + * name can have a space in it (but not the pattern)*/ + char* space = strrchr(buf+4, ' '); + char* nm, *patnm; + if(!space) { + /* parse error */ + log_msg(LOG_ERR, "parse error in %s: '%s'", + opt->zonelistfile, buf); + continue; + } + nm = buf+4; + *space = 0; + patnm = space+1; + if(linesize && buf[linesize-1] == '\n') + buf[linesize-1] = 0; + + /* store offset and line size for zone entry */ + /* and create zone entry in zonetree */ + (void)zone_list_zone_insert(opt, nm, patnm, linesize, + ftello(opt->zonelist)-linesize); + } else if(strncmp(buf, "del ", 4) == 0) { + /* store offset and line size for deleted entry */ + int linesize = strlen(buf); + zone_list_free_insert(opt, linesize, + ftello(opt->zonelist)-linesize); + } else { + log_msg(LOG_WARNING, "bad data in %s, '%s'", opt->zonelistfile, + buf); + } + } + /* store EOF offset */ + opt->zonelist_off = ftello(opt->zonelist); + return 1; +} + +void +zone_options_delete(nsd_options_t* opt, zone_options_t* zone) +{ + rbtree_delete(opt->zone_options, zone->node.key); + region_recycle(opt->region, (void*)zone->node.key, dname_total_size( + (dname_type*)zone->node.key)); + region_recycle(opt->region, zone, sizeof(*zone)); +} + +/* add a new zone to the zonelist */ +zone_options_t* +zone_list_add(nsd_options_t* opt, const char* zname, const char* pname) +{ + int r; + struct zonelist_free* e; + struct zonelist_bucket* b; + int linesize = 6 + strlen(zname) + strlen(pname); + /* create zone entry */ + zone_options_t* zone = zone_list_zone_insert(opt, zname, pname, + linesize, 0); + if(!zone) + return NULL; + + /* use free entry or append to file or create new file */ + if(!opt->zonelist || opt->zonelist_off == 0) { + /* create new file */ + if(opt->zonelist) fclose(opt->zonelist); + opt->zonelist = fopen(opt->zonelistfile, "w+"); + if(!opt->zonelist) { + log_msg(LOG_ERR, "could not create zone list %s: %s", + opt->zonelistfile, strerror(errno)); + log_msg(LOG_ERR, "zone %s could not be added", zname); + zone_options_delete(opt, zone); + return NULL; + } + r = fprintf(opt->zonelist, ZONELIST_HEADER); + if(r != strlen(ZONELIST_HEADER)) { + if(r == -1) + log_msg(LOG_ERR, "could not write to %s: %s", + opt->zonelistfile, strerror(errno)); + else log_msg(LOG_ERR, "partial write to %s: disk full", + opt->zonelistfile); + log_msg(LOG_ERR, "zone %s could not be added", zname); + zone_options_delete(opt, zone); + return NULL; + } + zone->off = ftello(opt->zonelist); + if(zone->off == -1) + log_msg(LOG_ERR, "ftello(%s): %s", opt->zonelistfile, strerror(errno)); + r = fprintf(opt->zonelist, "add %s %s\n", zname, pname); + if(r != zone->linesize) { + if(r == -1) + log_msg(LOG_ERR, "could not write to %s: %s", + opt->zonelistfile, strerror(errno)); + else log_msg(LOG_ERR, "partial write to %s: disk full", + opt->zonelistfile); + log_msg(LOG_ERR, "zone %s could not be added", zname); + zone_options_delete(opt, zone); + return NULL; + } + opt->zonelist_off = ftello(opt->zonelist); + if(opt->zonelist_off == -1) + log_msg(LOG_ERR, "ftello(%s): %s", opt->zonelistfile, strerror(errno)); + if(fflush(opt->zonelist) != 0) { + log_msg(LOG_ERR, "fflush %s: %s", opt->zonelistfile, strerror(errno)); + } + return zone; + } + b = (struct zonelist_bucket*)rbtree_search(opt->zonefree, + &zone->linesize); + if(!b || b->list == NULL) { + /* no empty place, append to file */ + zone->off = opt->zonelist_off; + if(fseeko(opt->zonelist, zone->off, SEEK_SET) == -1) { + log_msg(LOG_ERR, "fseeko(%s): %s", opt->zonelistfile, strerror(errno)); + log_msg(LOG_ERR, "zone %s could not be added", zname); + zone_options_delete(opt, zone); + return NULL; + } + r = fprintf(opt->zonelist, "add %s %s\n", zname, pname); + if(r != zone->linesize) { + if(r == -1) + log_msg(LOG_ERR, "could not write to %s: %s", + opt->zonelistfile, strerror(errno)); + else log_msg(LOG_ERR, "partial write to %s: disk full", + opt->zonelistfile); + log_msg(LOG_ERR, "zone %s could not be added", zname); + zone_options_delete(opt, zone); + return NULL; + } + opt->zonelist_off += linesize; + if(fflush(opt->zonelist) != 0) { + log_msg(LOG_ERR, "fflush %s: %s", opt->zonelistfile, strerror(errno)); + } + return zone; + } + /* reuse empty spot */ + e = b->list; + zone->off = e->off; + if(fseeko(opt->zonelist, zone->off, SEEK_SET) == -1) { + log_msg(LOG_ERR, "fseeko(%s): %s", opt->zonelistfile, strerror(errno)); + log_msg(LOG_ERR, "zone %s could not be added", zname); + zone_options_delete(opt, zone); + return NULL; + } + r = fprintf(opt->zonelist, "add %s %s\n", zname, pname); + if(r != zone->linesize) { + if(r == -1) + log_msg(LOG_ERR, "could not write to %s: %s", + opt->zonelistfile, strerror(errno)); + else log_msg(LOG_ERR, "partial write to %s: disk full", + opt->zonelistfile); + log_msg(LOG_ERR, "zone %s could not be added", zname); + zone_options_delete(opt, zone); + return NULL; + } + if(fflush(opt->zonelist) != 0) { + log_msg(LOG_ERR, "fflush %s: %s", opt->zonelistfile, strerror(errno)); + } + + /* snip off and recycle element */ + b->list = e->next; + region_recycle(opt->region, e, sizeof(*e)); + if(b->list == NULL) { + rbtree_delete(opt->zonefree, &b->linesize); + region_recycle(opt->region, b, sizeof(*b)); + } + opt->zonefree_number--; + return zone; +} + +/* remove a zone on the zonelist */ +void +zone_list_del(nsd_options_t* opt, zone_options_t* zone) +{ + /* put its space onto the free entry */ + if(fseeko(opt->zonelist, zone->off, SEEK_SET) == -1) { + log_msg(LOG_ERR, "fseeko(%s): %s", opt->zonelistfile, strerror(errno)); + return; + } + fprintf(opt->zonelist, "del"); + zone_list_free_insert(opt, zone->linesize, zone->off); + + /* remove zone_options_t */ + zone_options_delete(opt, zone); + + /* see if we need to compact: it is going to halve the zonelist */ + if(opt->zonefree_number > opt->zone_options->count) { + zone_list_compact(opt); + } else { + if(fflush(opt->zonelist) != 0) { + log_msg(LOG_ERR, "fflush %s: %s", opt->zonelistfile, strerror(errno)); + } + } +} +/* postorder delete of zonelist free space tree */ +static void +delbucket(region_type* region, struct zonelist_bucket* b) +{ + struct zonelist_free* e, *f; + if(!b || (rbnode_t*)b==RBTREE_NULL) + return; + delbucket(region, (struct zonelist_bucket*)b->node.left); + delbucket(region, (struct zonelist_bucket*)b->node.right); + e = b->list; + while(e) { + f = e->next; + region_recycle(region, e, sizeof(*e)); + e = f; + } + region_recycle(region, b, sizeof(*b)); +} + +/* compact zonelist file */ +void +zone_list_compact(nsd_options_t* opt) +{ + char outname[1024]; + FILE* out; + zone_options_t* zone; + off_t off; + int r; + snprintf(outname, sizeof(outname), "%s~", opt->zonelistfile); + /* useful, when : count-of-free > count-of-used */ + /* write zonelist to zonelist~ */ + out = fopen(outname, "w+"); + if(!out) { + log_msg(LOG_ERR, "could not open %s: %s", outname, strerror(errno)); + return; + } + r = fprintf(out, ZONELIST_HEADER); + if(r == -1) { + log_msg(LOG_ERR, "write %s failed: %s", outname, + strerror(errno)); + fclose(out); + return; + } else if(r != strlen(ZONELIST_HEADER)) { + log_msg(LOG_ERR, "write %s was partial: disk full", + outname); + fclose(out); + return; + } + off = ftello(out); + if(off == -1) { + log_msg(LOG_ERR, "ftello(%s): %s", outname, strerror(errno)); + fclose(out); + return; + } + RBTREE_FOR(zone, zone_options_t*, opt->zone_options) { + if(zone->part_of_config) + continue; + r = fprintf(out, "add %s %s\n", zone->name, + zone->pattern->pname); + if(r < 0) { + log_msg(LOG_ERR, "write %s failed: %s", outname, + strerror(errno)); + fclose(out); + return; + } else if(r != zone->linesize) { + log_msg(LOG_ERR, "write %s was partial: disk full", + outname); + fclose(out); + return; + } + } + if(fflush(out) != 0) { + log_msg(LOG_ERR, "fflush %s: %s", outname, strerror(errno)); + } + + /* rename zonelist~ onto zonelist */ + if(rename(outname, opt->zonelistfile) == -1) { + log_msg(LOG_ERR, "rename(%s to %s) failed: %s", + outname, opt->zonelistfile, strerror(errno)); + fclose(out); + return; + } + fclose(opt->zonelist); + /* set offsets */ + RBTREE_FOR(zone, zone_options_t*, opt->zone_options) { + if(zone->part_of_config) + continue; + zone->off = off; + off += zone->linesize; + } + /* empty the free tree */ + delbucket(opt->region, (struct zonelist_bucket*)opt->zonefree->root); + opt->zonefree->root = RBTREE_NULL; + opt->zonefree->count = 0; + opt->zonefree_number = 0; + /* finish */ + opt->zonelist = out; + opt->zonelist_off = off; +} + +/* close zonelist file */ +void +zone_list_close(nsd_options_t* opt) +{ + fclose(opt->zonelist); + opt->zonelist = NULL; +} + + +void +c_error_va_list(const char* fmt, va_list args) { cfg_parser->errors++; + if(cfg_parser->err) { + char m[MAXSYSLOGMSGLEN]; + snprintf(m, sizeof(m), "%s:%d: error: ", cfg_parser->filename, + cfg_parser->line); + (*cfg_parser->err)(cfg_parser->err_arg, m); + vsnprintf(m, sizeof(m), fmt, args); + (*cfg_parser->err)(cfg_parser->err_arg, m); + (*cfg_parser->err)(cfg_parser->err_arg, "\n"); + return; + } fprintf(stderr, "%s:%d: error: ", cfg_parser->filename, cfg_parser->line); vfprintf(stderr, fmt, args); fprintf(stderr, "\n"); } -void c_error_msg(const char* fmt, ...) +void +c_error_msg(const char* fmt, ...) { va_list args; va_start(args, fmt); @@ -215,62 +679,546 @@ void c_error_msg(const char* fmt, ...) va_end(args); } -void c_error(const char *str) +void +c_error(const char* str) { - cfg_parser->errors++; - fprintf(stderr, "%s:%d: error: %s\n", cfg_parser->filename, - cfg_parser->line, str); + c_error_msg("%s", str); } -int c_wrap() +int +c_wrap() { return 1; } -zone_options_t* zone_options_create(region_type* region) +zone_options_t* +zone_options_create(region_type* region) { zone_options_t* zone; zone = (zone_options_t*)region_alloc(region, sizeof(zone_options_t)); zone->node = *RBTREE_NULL; zone->name = 0; - zone->zonefile = 0; - zone->allow_notify = 0; - zone->request_xfr = 0; - zone->notify = 0; - zone->notify_retry = 5; - zone->provide_xfr = 0; - zone->outgoing_interface = 0; - zone->allow_axfr_fallback = 1; + zone->pattern = 0; + zone->part_of_config = 0; + return zone; +} + +/* true is booleans are the same truth value */ +#define booleq(x,y) ( ((x) && (y)) || (!(x) && !(y)) ) + +int +acl_equal(acl_options_t* p, acl_options_t* q) +{ + if(!booleq(p->use_axfr_only, q->use_axfr_only)) return 0; + if(!booleq(p->allow_udp, q->allow_udp)) return 0; + if(strcmp(p->ip_address_spec, q->ip_address_spec)!=0) return 0; + /* the ip6, port, addr, mask, type: are derived from the ip_address_spec */ + if(!booleq(p->nokey, q->nokey)) return 0; + if(!booleq(p->blocked, q->blocked)) return 0; + if(p->key_name && q->key_name) { + if(strcmp(p->key_name, q->key_name)!=0) return 0; + } else if(p->key_name && !q->key_name) return 0; + else if(!p->key_name && q->key_name) return 0; + /* key_options is derived from key_name */ + return 1; +} + +int +acl_list_equal(acl_options_t* p, acl_options_t* q) +{ + /* must be same and in same order */ + while(p && q) { + if(!acl_equal(p, q)) + return 0; + p = p->next; + q = q->next; + } + if(!p && !q) return 1; + /* different lengths */ + return 0; +} + +pattern_options_t* +pattern_options_create(region_type* region) +{ + pattern_options_t* p; + p = (pattern_options_t*)region_alloc(region, sizeof(pattern_options_t)); + p->node = *RBTREE_NULL; + p->pname = 0; + p->zonefile = 0; + p->allow_notify = 0; + p->request_xfr = 0; + p->notify = 0; + p->provide_xfr = 0; + p->outgoing_interface = 0; + p->notify_retry = 5; + p->notify_retry_is_default = 1; + p->allow_axfr_fallback = 1; + p->allow_axfr_fallback_is_default = 1; + p->implicit = 0; + p->xfrd_flags = 0; #ifdef RATELIMIT - zone->rrl_whitelist = 0; + p->rrl_whitelist = 0; #endif - return zone; + return p; +} + +static void +acl_delete(region_type* region, acl_options_t* acl) +{ + if(acl->ip_address_spec) + region_recycle(region, (void*)acl->ip_address_spec, + strlen(acl->ip_address_spec)+1); + if(acl->key_name) + region_recycle(region, (void*)acl->key_name, + strlen(acl->key_name)+1); + /* key_options is a convenience pointer, not owned by the acl */ + region_recycle(region, acl, sizeof(*acl)); +} + +static void +acl_list_delete(region_type* region, acl_options_t* list) +{ + acl_options_t* n; + while(list) { + n = list->next; + acl_delete(region, list); + list = n; + } } -key_options_t* key_options_create(region_type* region) +void +pattern_options_remove(nsd_options_t* opt, const char* name) +{ + pattern_options_t* p = (pattern_options_t*)rbtree_delete( + opt->patterns, name); + /* delete p and its contents */ + if (!p) + return; + if(p->pname) + region_recycle(opt->region, (void*)p->pname, + strlen(p->pname)+1); + if(p->zonefile) + region_recycle(opt->region, (void*)p->zonefile, + strlen(p->zonefile)+1); + acl_list_delete(opt->region, p->allow_notify); + acl_list_delete(opt->region, p->request_xfr); + acl_list_delete(opt->region, p->notify); + acl_list_delete(opt->region, p->provide_xfr); + acl_list_delete(opt->region, p->outgoing_interface); + + region_recycle(opt->region, p, sizeof(pattern_options_t)); +} + +static acl_options_t* +copy_acl(region_type* region, acl_options_t* a) +{ + acl_options_t* b; + if(!a) return NULL; + b = (acl_options_t*)region_alloc(region, sizeof(*b)); + /* copy the whole lot */ + *b = *a; + /* fix the pointers */ + if(a->ip_address_spec) + b->ip_address_spec = region_strdup(region, a->ip_address_spec); + if(a->key_name) + b->key_name = region_strdup(region, a->key_name); + b->next = NULL; + b->key_options = NULL; + return b; +} + +static acl_options_t* +copy_acl_list(nsd_options_t* opt, acl_options_t* a) +{ + acl_options_t* b, *blast = NULL, *blist = NULL; + while(a) { + b = copy_acl(opt->region, a); + /* fixup key_options */ + if(b->key_name) + b->key_options = key_options_find(opt, b->key_name); + else b->key_options = NULL; + + /* link as last into list */ + b->next = NULL; + if(!blist) blist = b; + else blast->next = b; + blast = b; + + a = a->next; + } + return blist; +} + +static void +copy_changed_acl(nsd_options_t* opt, acl_options_t** orig, + acl_options_t* anew) +{ + if(!acl_list_equal(*orig, anew)) { + acl_list_delete(opt->region, *orig); + *orig = copy_acl_list(opt, anew); + } +} + +static void +copy_pat_fixed(region_type* region, pattern_options_t* orig, + pattern_options_t* p) +{ + orig->allow_axfr_fallback = p->allow_axfr_fallback; + orig->allow_axfr_fallback_is_default = + p->allow_axfr_fallback_is_default; + orig->notify_retry = p->notify_retry; + orig->notify_retry_is_default = p->notify_retry_is_default; + orig->implicit = p->implicit; + if(p->zonefile) + orig->zonefile = region_strdup(region, p->zonefile); + else orig->zonefile = NULL; +#ifdef RATELIMIT + orig->rrl_whitelist = p->rrl_whitelist; +#endif +} + +void +pattern_options_add_modify(nsd_options_t* opt, pattern_options_t* p) +{ + pattern_options_t* orig = pattern_options_find(opt, p->pname); + if(!orig) { + /* needs to be copied to opt region */ + orig = pattern_options_create(opt->region); + orig->pname = region_strdup(opt->region, p->pname); + copy_pat_fixed(opt->region, orig, p); + orig->allow_notify = copy_acl_list(opt, p->allow_notify); + orig->request_xfr = copy_acl_list(opt, p->request_xfr); + orig->notify = copy_acl_list(opt, p->notify); + orig->provide_xfr = copy_acl_list(opt, p->provide_xfr); + orig->outgoing_interface = copy_acl_list(opt, + p->outgoing_interface); + nsd_options_insert_pattern(opt, orig); + } else { + /* modify in place so pointers stay valid (and copy + into region). Do not touch unchanged acls. */ + if(orig->zonefile) + region_recycle(opt->region, (char*)orig->zonefile, + strlen(orig->zonefile)+1); + copy_pat_fixed(opt->region, orig, p); + copy_changed_acl(opt, &orig->allow_notify, p->allow_notify); + copy_changed_acl(opt, &orig->request_xfr, p->request_xfr); + copy_changed_acl(opt, &orig->notify, p->notify); + copy_changed_acl(opt, &orig->provide_xfr, p->provide_xfr); + copy_changed_acl(opt, &orig->outgoing_interface, + p->outgoing_interface); + } +} + +pattern_options_t* +pattern_options_find(nsd_options_t* opt, const char* name) +{ + return (pattern_options_t*)rbtree_search(opt->patterns, name); +} + +int +pattern_options_equal(pattern_options_t* p, pattern_options_t* q) +{ + if(strcmp(p->pname, q->pname) != 0) return 0; + if(!p->zonefile && q->zonefile) return 0; + else if(p->zonefile && !q->zonefile) return 0; + else if(p->zonefile && q->zonefile) { + if(strcmp(p->zonefile, q->zonefile) != 0) return 0; + } + if(!booleq(p->allow_axfr_fallback, q->allow_axfr_fallback)) return 0; + if(!booleq(p->allow_axfr_fallback_is_default, + q->allow_axfr_fallback_is_default)) return 0; + if(p->notify_retry != q->notify_retry) return 0; + if(!booleq(p->notify_retry_is_default, + q->notify_retry_is_default)) return 0; + if(!booleq(p->implicit, q->implicit)) return 0; + if(!acl_list_equal(p->allow_notify, q->allow_notify)) return 0; + if(!acl_list_equal(p->request_xfr, q->request_xfr)) return 0; + if(!acl_list_equal(p->notify, q->notify)) return 0; + if(!acl_list_equal(p->provide_xfr, q->provide_xfr)) return 0; + if(!acl_list_equal(p->outgoing_interface, q->outgoing_interface)) + return 0; +#ifdef RATELIMIT + if(p->rrl_whitelist != q->rrl_whitelist) return 0; +#endif + return 1; +} + +static void +marshal_u8(struct buffer* b, uint8_t v) +{ + buffer_reserve(b, 1); + buffer_write_u8(b, v); +} + +static uint8_t +unmarshal_u8(struct buffer* b) +{ + return buffer_read_u8(b); +} + +#ifdef RATELIMIT +static void +marshal_u16(struct buffer* b, uint16_t v) +{ + buffer_reserve(b, 2); + buffer_write_u16(b, v); +} +#endif + +#ifdef RATELIMIT +static uint16_t +unmarshal_u16(struct buffer* b) +{ + return buffer_read_u16(b); +} +#endif + +static void +marshal_str(struct buffer* b, const char* s) +{ + if(!s) marshal_u8(b, 0); + else { + size_t len = strlen(s); + marshal_u8(b, 1); + buffer_reserve(b, len+1); + buffer_write(b, s, len+1); + } +} + +static char* +unmarshal_str(region_type* r, struct buffer* b) +{ + uint8_t nonnull = unmarshal_u8(b); + if(nonnull) { + char* result = region_strdup(r, (char*)buffer_current(b)); + size_t len = strlen((char*)buffer_current(b)); + buffer_skip(b, len+1); + return result; + } else return NULL; +} + +static void +marshal_acl(struct buffer* b, acl_options_t* acl) +{ + buffer_reserve(b, sizeof(*acl)); + buffer_write(b, acl, sizeof(*acl)); + marshal_str(b, acl->ip_address_spec); + marshal_str(b, acl->key_name); +} + +static acl_options_t* +unmarshal_acl(region_type* r, struct buffer* b) +{ + acl_options_t* acl = (acl_options_t*)region_alloc(r, sizeof(*acl)); + buffer_read(b, acl, sizeof(*acl)); + acl->next = NULL; + acl->key_options = NULL; + acl->ip_address_spec = unmarshal_str(r, b); + acl->key_name = unmarshal_str(r, b); + return acl; +} + +static void +marshal_acl_list(struct buffer* b, acl_options_t* list) +{ + while(list) { + marshal_u8(b, 1); /* is there a next one marker */ + marshal_acl(b, list); + list = list->next; + } + marshal_u8(b, 0); /* end of list marker */ +} + +static acl_options_t* +unmarshal_acl_list(region_type* r, struct buffer* b) +{ + acl_options_t* a, *last=NULL, *list=NULL; + while(unmarshal_u8(b)) { + a = unmarshal_acl(r, b); + /* link in */ + a->next = NULL; + if(!list) list = a; + else last->next = a; + last = a; + } + return list; +} + +void +pattern_options_marshal(struct buffer* b, pattern_options_t* p) +{ + marshal_str(b, p->pname); + marshal_str(b, p->zonefile); +#ifdef RATELIMIT + marshal_u16(b, p->rrl_whitelist); +#endif + marshal_u8(b, p->allow_axfr_fallback); + marshal_u8(b, p->allow_axfr_fallback_is_default); + marshal_u8(b, p->notify_retry); + marshal_u8(b, p->notify_retry_is_default); + marshal_u8(b, p->implicit); + marshal_acl_list(b, p->allow_notify); + marshal_acl_list(b, p->request_xfr); + marshal_acl_list(b, p->notify); + marshal_acl_list(b, p->provide_xfr); + marshal_acl_list(b, p->outgoing_interface); +} + +pattern_options_t* +pattern_options_unmarshal(region_type* r, struct buffer* b) +{ + pattern_options_t* p = pattern_options_create(r); + p->pname = unmarshal_str(r, b); + p->zonefile = unmarshal_str(r, b); +#ifdef RATELIMIT + p->rrl_whitelist = unmarshal_u16(b); +#endif + p->allow_axfr_fallback = unmarshal_u8(b); + p->allow_axfr_fallback_is_default = unmarshal_u8(b); + p->notify_retry = unmarshal_u8(b); + p->notify_retry_is_default = unmarshal_u8(b); + p->implicit = unmarshal_u8(b); + p->allow_notify = unmarshal_acl_list(r, b); + p->request_xfr = unmarshal_acl_list(r, b); + p->notify = unmarshal_acl_list(r, b); + p->provide_xfr = unmarshal_acl_list(r, b); + p->outgoing_interface = unmarshal_acl_list(r, b); + return p; +} + +key_options_t* +key_options_create(region_type* region) { key_options_t* key; - key = (key_options_t*)region_alloc(region, sizeof(key_options_t)); - key->name = 0; - key->next = 0; - key->algorithm = 0; - key->secret = 0; - key->tsig_key = 0; + key = (key_options_t*)region_alloc_zero(region, sizeof(key_options_t)); return key; } -key_options_t* key_options_find(nsd_options_t* opt, const char* name) +void +key_options_insert(nsd_options_t* opt, key_options_t* key) +{ + if(!key->name) return; + key->node.key = key->name; + (void)rbtree_insert(opt->keys, &key->node); +} + +key_options_t* +key_options_find(nsd_options_t* opt, const char* name) { - key_options_t* key = opt->keys; - while(key) { - if(strcmp(key->name, name)==0) - return key; - key = key->next; + return (key_options_t*)rbtree_search(opt->keys, name); +} + +/** remove tsig_key contents */ +void +key_options_desetup(region_type* region, key_options_t* key) +{ + /* keep tsig_key pointer so that existing references keep valid */ + if(!key->tsig_key) + return; + /* name stays the same */ + if(key->tsig_key->data) { + /* wipe secret! */ + memset(key->tsig_key->data, 0xdd, key->tsig_key->size); + region_recycle(region, key->tsig_key->data, + key->tsig_key->size); + key->tsig_key->data = NULL; + key->tsig_key->size = 0; } - return 0; } -int acl_check_incoming(acl_options_t* acl, struct query* q, +/** add tsig_key contents */ +void +key_options_setup(region_type* region, key_options_t* key) +{ + uint8_t data[16384]; /* 16KB */ + int size; + if(!key->tsig_key) { + /* create it */ + key->tsig_key = (tsig_key_type *) region_alloc(region, + sizeof(tsig_key_type)); + /* create name */ + key->tsig_key->name = dname_parse(region, key->name); + if(!key->tsig_key->name) { + log_msg(LOG_ERR, "Failed to parse tsig key name %s", + key->name); + /* key and base64 were checked during syntax parse */ + exit(1); + } + key->tsig_key->size = 0; + key->tsig_key->data = NULL; + } + size = b64_pton(key->secret, data, sizeof(data)); + if(size == -1) { + log_msg(LOG_ERR, "Failed to parse tsig key data %s", + key->name); + /* key and base64 were checked during syntax parse */ + exit(1); + } + key->tsig_key->size = size; + key->tsig_key->data = (uint8_t *)region_alloc_init(region, data, size); +} + +void +key_options_remove(nsd_options_t* opt, const char* name) +{ + key_options_t* k = key_options_find(opt, name); + if(!k) return; + (void)rbtree_delete(opt->keys, name); + if(k->name) + region_recycle(opt->region, k->name, strlen(k->name)+1); + if(k->algorithm) + region_recycle(opt->region, k->algorithm, strlen(k->algorithm)+1); + if(k->secret) { + memset(k->secret, 0xdd, strlen(k->secret)); /* wipe secret! */ + region_recycle(opt->region, k->secret, strlen(k->secret)+1); + } + if(k->tsig_key) { + tsig_del_key(k->tsig_key); + if(k->tsig_key->name) + region_recycle(opt->region, (void*)k->tsig_key->name, + dname_total_size(k->tsig_key->name)); + key_options_desetup(opt->region, k); + region_recycle(opt->region, k->tsig_key, sizeof(tsig_key_type)); + } + region_recycle(opt->region, k, sizeof(key_options_t)); +} + +int +key_options_equal(key_options_t* p, key_options_t* q) +{ + return strcmp(p->name, q->name)==0 && strcmp(p->algorithm, + q->algorithm)==0 && strcmp(p->secret, q->secret)==0; +} + +void +key_options_add_modify(nsd_options_t* opt, key_options_t* key) +{ + key_options_t* orig = key_options_find(opt, key->name); + if(!orig) { + /* needs to be copied to opt region */ + orig = key_options_create(opt->region); + orig->name = region_strdup(opt->region, key->name); + orig->algorithm = region_strdup(opt->region, key->algorithm); + orig->secret = region_strdup(opt->region, key->secret); + key_options_setup(opt->region, orig); + tsig_add_key(orig->tsig_key); + key_options_insert(opt, orig); + } else { + /* modify entries in existing key, and copy to opt region */ + key_options_desetup(opt->region, orig); + region_recycle(opt->region, orig->algorithm, + strlen(orig->algorithm)+1); + orig->algorithm = region_strdup(opt->region, key->algorithm); + region_recycle(opt->region, orig->secret, + strlen(orig->secret)+1); + orig->secret = region_strdup(opt->region, key->secret); + key_options_setup(opt->region, orig); + } +} + +int +acl_check_incoming(acl_options_t* acl, struct query* q, acl_options_t** reason) { /* check each acl element. @@ -311,7 +1259,8 @@ int acl_check_incoming(acl_options_t* acl, struct query* q, } #ifdef INET6 -int acl_addr_matches_ipv6host(acl_options_t* acl, struct sockaddr_storage* addr_storage, unsigned int port) +int +acl_addr_matches_ipv6host(acl_options_t* acl, struct sockaddr_storage* addr_storage, unsigned int port) { struct sockaddr_in6* addr = (struct sockaddr_in6*)addr_storage; if(acl->port != 0 && acl->port != port) @@ -339,7 +1288,8 @@ int acl_addr_matches_ipv6host(acl_options_t* acl, struct sockaddr_storage* addr_ } #endif -int acl_addr_matches_ipv4host(acl_options_t* acl, struct sockaddr_in* addr, unsigned int port) +int +acl_addr_matches_ipv4host(acl_options_t* acl, struct sockaddr_in* addr, unsigned int port) { if(acl->port != 0 && acl->port != port) return 0; @@ -365,7 +1315,8 @@ int acl_addr_matches_ipv4host(acl_options_t* acl, struct sockaddr_in* addr, unsi return 1; } -int acl_addr_matches_host(acl_options_t* acl, acl_options_t* host) +int +acl_addr_matches_host(acl_options_t* acl, acl_options_t* host) { if(acl->is_ipv6) { @@ -387,7 +1338,8 @@ int acl_addr_matches_host(acl_options_t* acl, acl_options_t* host) return 0; } -int acl_addr_matches(acl_options_t* acl, struct query* q) +int +acl_addr_matches(acl_options_t* acl, struct query* q) { if(acl->is_ipv6) { @@ -411,7 +1363,8 @@ int acl_addr_matches(acl_options_t* acl, struct query* q) return 0; } -int acl_addr_match_mask(uint32_t* a, uint32_t* b, uint32_t* mask, size_t sz) +int +acl_addr_match_mask(uint32_t* a, uint32_t* b, uint32_t* mask, size_t sz) { size_t i; #ifndef NDEBUG @@ -427,7 +1380,8 @@ int acl_addr_match_mask(uint32_t* a, uint32_t* b, uint32_t* mask, size_t sz) return 1; } -int acl_addr_match_range(uint32_t* minval, uint32_t* x, uint32_t* maxval, size_t sz) +int +acl_addr_match_range(uint32_t* minval, uint32_t* x, uint32_t* maxval, size_t sz) { size_t i; uint8_t checkmin = 1, checkmax = 1; @@ -456,7 +1410,8 @@ int acl_addr_match_range(uint32_t* minval, uint32_t* x, uint32_t* maxval, size_t return 1; } -int acl_key_matches(acl_options_t* acl, struct query* q) +int +acl_key_matches(acl_options_t* acl, struct query* q) { if(acl->blocked) return 1; @@ -527,42 +1482,93 @@ acl_same_host(acl_options_t* a, acl_options_t* b) } #if defined(HAVE_SSL) -void key_options_tsig_add(nsd_options_t* opt) +void +key_options_tsig_add(nsd_options_t* opt) { key_options_t* optkey; - uint8_t data[4000]; - tsig_key_type* tsigkey; - const dname_type* dname; - int size; - - for(optkey = opt->keys; optkey; optkey = optkey->next) - { - dname = dname_parse(opt->region, optkey->name); - if(!dname) { - log_msg(LOG_ERR, "Failed to parse tsig key name %s", optkey->name); - continue; - } - size = b64_pton(optkey->secret, data, sizeof(data)); - if(size == -1) { - log_msg(LOG_ERR, "Failed to parse tsig key data %s", optkey->name); - continue; - } - tsigkey = (tsig_key_type *) region_alloc(opt->region, sizeof(tsig_key_type)); - tsigkey->name = dname; - tsigkey->size = size; - tsigkey->data = (uint8_t *) region_alloc_init(opt->region, data, tsigkey->size); - tsig_add_key(tsigkey); - optkey->tsig_key = tsigkey; + RBTREE_FOR(optkey, key_options_t*, opt->keys) { + key_options_setup(opt->region, optkey); + tsig_add_key(optkey->tsig_key); } } #endif -int zone_is_slave(zone_options_t* opt) +int +zone_is_slave(zone_options_t* opt) +{ + return opt && opt->pattern && opt->pattern->request_xfr != 0; +} + +/* get a character in string (or replacement char if not long enough) */ +static const char* +get_char(const char* str, size_t i) +{ + static char res[2]; + if(i >= strlen(str)) + return "."; + res[0] = str[i]; + res[1] = 0; + return res; +} +/* get end label of the zone name (or .) */ +static const char* +get_end_label(zone_options_t* zone, int i) +{ + const dname_type* d = (const dname_type*)zone->node.key; + if(i >= d->label_count) { + return "."; + } + return wirelabel2str(dname_label(d, i)); +} +/* replace occurrences of one with two */ +void +replace_str(char* str, size_t len, const char* one, const char* two) +{ + char* pos; + char* at = str; + while( (pos=strstr(at, one)) ) { + if(strlen(str)+strlen(two)-strlen(one) >= len) + return; /* no more space to replace */ + /* stuff before pos is fine */ + /* move the stuff after pos to make space for two, add + * one to length of remainder to also copy the 0 byte end */ + memmove(pos+strlen(two), pos+strlen(one), + strlen(pos+strlen(one))+1); + /* copy in two */ + memmove(pos, two, strlen(two)); + /* at is end of the newly inserted two (avoids recursion if + * two contains one) */ + at = pos+strlen(two); + } +} + +const char* +config_make_zonefile(zone_options_t* zone) { - return opt->request_xfr != 0; + static char f[1024]; + /* if not a template, return as-is */ + if(!strchr(zone->pattern->zonefile, '%')) + return zone->pattern->zonefile; + strlcpy(f, zone->pattern->zonefile, sizeof(f)); + if(strstr(f, "%1")) + replace_str(f, sizeof(f), "%1", get_char(zone->name, 0)); + if(strstr(f, "%2")) + replace_str(f, sizeof(f), "%2", get_char(zone->name, 1)); + if(strstr(f, "%3")) + replace_str(f, sizeof(f), "%3", get_char(zone->name, 2)); + if(strstr(f, "%z")) + replace_str(f, sizeof(f), "%z", get_end_label(zone, 1)); + if(strstr(f, "%y")) + replace_str(f, sizeof(f), "%y", get_end_label(zone, 2)); + if(strstr(f, "%x")) + replace_str(f, sizeof(f), "%x", get_end_label(zone, 3)); + if(strstr(f, "%s")) + replace_str(f, sizeof(f), "%s", zone->name); + return f; } -zone_options_t* zone_options_find(nsd_options_t* opt, const struct dname* apex) +zone_options_t* +zone_options_find(nsd_options_t* opt, const struct dname* apex) { return (zone_options_t*) rbtree_search(opt->zone_options, apex); } @@ -583,7 +1589,8 @@ acl_find_num(acl_options_t* acl, int num) } /* true if ipv6 address, false if ipv4 */ -int parse_acl_is_ipv6(const char* p) +int +parse_acl_is_ipv6(const char* p) { /* see if addr is ipv6 or ipv4 -- by : and . */ while(*p) { @@ -595,7 +1602,8 @@ int parse_acl_is_ipv6(const char* p) } /* returns range type. mask is the 2nd part of the range */ -int parse_acl_range_type(char* ip, char** mask) +int +parse_acl_range_type(char* ip, char** mask) { char *p; if((p=strchr(ip, '&'))!=0) { @@ -618,7 +1626,8 @@ int parse_acl_range_type(char* ip, char** mask) } /* parses subnet mask, fills 0 mask as well */ -void parse_acl_range_subnet(char* p, void* addr, int maxbits) +void +parse_acl_range_subnet(char* p, void* addr, int maxbits) { int subnet_bits = atoi(p); uint8_t* addr_bytes = (uint8_t*)addr; @@ -641,7 +1650,8 @@ void parse_acl_range_subnet(char* p, void* addr, int maxbits) } } -acl_options_t* parse_acl_info(region_type* region, char* ip, const char* key) +acl_options_t* +parse_acl_info(region_type* region, char* ip, const char* key) { char* p; acl_options_t* acl = (acl_options_t*)region_alloc(region, sizeof(acl_options_t)); @@ -704,7 +1714,62 @@ acl_options_t* parse_acl_info(region_type* region, char* ip, const char* key) return acl; } -void nsd_options_destroy(nsd_options_t* opt) +/* copy acl list at end of parser start, update current */ +static +void append_acl(acl_options_t** start, acl_options_t** cur, + acl_options_t* list) +{ + while(list) { + acl_options_t* acl = copy_acl(cfg_parser->opt->region, list); + acl->next = NULL; + if(*cur) + (*cur)->next = acl; + else *start = acl; + *cur = acl; + list = list->next; + } +} + +void +config_apply_pattern(const char* name) +{ + /* find the pattern */ + pattern_options_t* pat = pattern_options_find(cfg_parser->opt, name); + pattern_options_t* a = cfg_parser->current_pattern; + if(!pat) { + c_error_msg("could not find pattern %s", name); + return; + } + + /* apply settings */ + if(pat->zonefile) + a->zonefile = region_strdup(cfg_parser->opt->region, + pat->zonefile); + if(!pat->allow_axfr_fallback_is_default) { + a->allow_axfr_fallback = pat->allow_axfr_fallback; + a->allow_axfr_fallback_is_default = 0; + } + if(!pat->notify_retry_is_default) { + a->notify_retry = pat->notify_retry; + a->notify_retry_is_default = 0; + } +#ifdef RATELIMIT + a->rrl_whitelist |= pat->rrl_whitelist; +#endif + /* append acl items */ + append_acl(&a->allow_notify, &cfg_parser->current_allow_notify, + pat->allow_notify); + append_acl(&a->request_xfr, &cfg_parser->current_request_xfr, + pat->request_xfr); + append_acl(&a->notify, &cfg_parser->current_notify, pat->notify); + append_acl(&a->provide_xfr, &cfg_parser->current_provide_xfr, + pat->provide_xfr); + append_acl(&a->outgoing_interface, &cfg_parser-> + current_outgoing_interface, pat->outgoing_interface); +} + +void +nsd_options_destroy(nsd_options_t* opt) { region_destroy(opt->region); } diff --git a/usr.sbin/nsd/options.h b/usr.sbin/nsd/options.h index cab7d5749cf..4cad972a683 100644 --- a/usr.sbin/nsd/options.h +++ b/usr.sbin/nsd/options.h @@ -1,7 +1,7 @@ /* * options.h -- nsd.conf options definitions and prototypes * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -17,8 +17,10 @@ struct query; struct dname; struct tsig_key; +struct buffer; typedef struct nsd_options nsd_options_t; +typedef struct pattern_options pattern_options_t; typedef struct zone_options zone_options_t; typedef struct ipaddress_option ip_address_option_t; typedef struct acl_options acl_options_t; @@ -28,12 +30,24 @@ typedef struct config_parser_state config_parser_state_t; * Options global for nsd. */ struct nsd_options { + /* config file name */ + char* configfile; /* options for zones, by apex, contains zone_options_t */ rbtree_t* zone_options; + /* patterns, by name, contains pattern_options_t */ + rbtree_t* patterns; - /* list of keys defined */ - key_options_t* keys; - size_t numkeys; + /* free space in zonelist file, contains zonelist_bucket */ + rbtree_t* zonefree; + /* number of free space lines in zonelist file */ + size_t zonefree_number; + /* zonelist file if open */ + FILE* zonelist; + /* last offset in file (or 0 if none) */ + off_t zonelist_off; + + /* rbtree of keys defined, by name */ + rbtree_t* keys; /* list of ip adresses to bind to (or NULL for all) */ ip_address_option_t* ip_addresses; @@ -42,8 +56,8 @@ struct nsd_options { int debug_mode; int verbosity; int hide_version; - int ip4_only; - int ip6_only; + int do_ip4; + int do_ip6; const char* database; const char* identity; const char* logfile; @@ -56,14 +70,30 @@ struct nsd_options { const char* pidfile; const char* port; int statistics; - const char* zonestatsfile; const char* chroot; const char* username; const char* zonesdir; - const char* difffile; const char* xfrdfile; + const char* xfrdir; + const char* zonelistfile; const char* nsid; int xfrd_reload_timeout; + int zonefiles_check; + + /** remote control section. enable toggle. */ + int control_enable; + /** the interfaces the remote control should listen on */ + ip_address_option_t* control_interface; + /** port number for the control port */ + int control_port; + /** private key file for server */ + char* server_key_file; + /** certificate file for server */ + char* server_cert_file; + /** private key file for nsd-control */ + char* control_key_file; + /** certificate file for nsd-control */ + char* control_cert_file; #ifdef RATELIMIT /** number of buckets in rrl hashtable */ @@ -88,14 +118,11 @@ struct ipaddress_option { }; /* - * Options for a zone + * Pattern of zone options, used to contain options for zone(s). */ -struct zone_options { - /* key is dname of apex */ +struct pattern_options { rbnode_t node; - - /* is apex of the zone */ - const char* name; + const char* pname; /* name of the pattern, key of rbtree */ const char* zonefile; acl_options_t* allow_notify; acl_options_t* request_xfr; @@ -106,7 +133,32 @@ struct zone_options { uint16_t rrl_whitelist; /* bitmap with rrl types */ #endif uint8_t allow_axfr_fallback; + uint8_t allow_axfr_fallback_is_default; uint8_t notify_retry; + uint8_t notify_retry_is_default; + uint8_t implicit; /* pattern is implicit, part_of_config zone used */ + uint8_t xfrd_flags; +}; + +#define PATTERN_IMPLICIT_MARKER "_implicit_" + +/* + * Options for a zone + */ +struct zone_options { + /* key is dname of apex */ + rbnode_t node; + + /* is apex of the zone */ + const char* name; + /* if not part of config, the offset and linesize of zonelist entry */ + off_t off; + int linesize; + /* pattern for the zone options, if zone is part_of_config, this is + * a anonymous pattern created in-place */ + pattern_options_t* pattern; + /* zone is fixed into the main config, not in zonelist, cannot delete */ + uint8_t part_of_config; }; union acl_addr_storage { @@ -125,10 +177,10 @@ struct acl_options { acl_options_t* next; /* options */ - uint8_t use_axfr_only; - uint8_t allow_udp; time_t ixfr_disabled; int bad_xfr_count; + uint8_t use_axfr_only; + uint8_t allow_udp; /* ip address range */ const char* ip_address_spec; @@ -154,21 +206,36 @@ struct acl_options { * Key definition */ struct key_options { - key_options_t* next; - const char* name; - const char* algorithm; - const char* secret; + rbnode_t node; /* key of tree is name */ + char* name; + char* algorithm; + char* secret; struct tsig_key* tsig_key; }; +/** zone list free space */ +struct zonelist_free { + struct zonelist_free* next; + off_t off; +}; +/** zonelist free bucket for a particular line length */ +struct zonelist_bucket { + rbnode_t node; /* key is ptr to linesize */ + int linesize; + struct zonelist_free* list; +}; + /* * Used during options parsing */ struct config_parser_state { const char* filename; + const char* chroot; int line; int errors; + int server_settings_seen; nsd_options_t* opt; + pattern_options_t* current_pattern; zone_options_t* current_zone; key_options_t* current_key; ip_address_option_t* current_ip_address_option; @@ -177,6 +244,8 @@ struct config_parser_state { acl_options_t* current_notify; acl_options_t* current_provide_xfr; acl_options_t* current_outgoing_interface; + void (*err)(void*,const char*); + void* err_arg; }; extern config_parser_state_t* cfg_parser; @@ -188,14 +257,41 @@ static inline size_t nsd_options_num_zones(nsd_options_t* opt) { return opt->zone_options->count; } /* insert a zone into the main options tree, returns 0 on error */ int nsd_options_insert_zone(nsd_options_t* opt, zone_options_t* zone); +/* insert a pattern into the main options tree, returns 0 on error */ +int nsd_options_insert_pattern(nsd_options_t* opt, pattern_options_t* pat); -/* parses options file. Returns false on failure */ -int parse_options_file(nsd_options_t* opt, const char* file); +/* parses options file. Returns false on failure. callback, if nonNULL, + * gets called with error strings, default prints. */ +int parse_options_file(nsd_options_t* opt, const char* file, + void (*err)(void*,const char*), void* err_arg); zone_options_t* zone_options_create(region_type* region); +void zone_options_delete(nsd_options_t* opt, zone_options_t* zone); /* find a zone by apex domain name, or NULL if not found. */ zone_options_t* zone_options_find(nsd_options_t* opt, const struct dname* apex); +pattern_options_t* pattern_options_create(region_type* region); +pattern_options_t* pattern_options_find(nsd_options_t* opt, const char* name); +int pattern_options_equal(pattern_options_t* p, pattern_options_t* q); +void pattern_options_remove(nsd_options_t* opt, const char* name); +void pattern_options_add_modify(nsd_options_t* opt, pattern_options_t* p); +void pattern_options_marshal(struct buffer* buffer, pattern_options_t* p); +pattern_options_t* pattern_options_unmarshal(region_type* r, struct buffer* b); key_options_t* key_options_create(region_type* region); +void key_options_insert(nsd_options_t* opt, key_options_t* key); key_options_t* key_options_find(nsd_options_t* opt, const char* name); +void key_options_remove(nsd_options_t* opt, const char* name); +int key_options_equal(key_options_t* p, key_options_t* q); +void key_options_add_modify(nsd_options_t* opt, key_options_t* key); +/* read in zone list file. Returns false on failure */ +int parse_zone_list_file(nsd_options_t* opt); +/* create zone entry and add to the zonelist file */ +zone_options_t* zone_list_add(nsd_options_t* opt, const char* zname, + const char* pname); +/* create zonelist entry, do not insert in file (called by _add) */ +zone_options_t* zone_list_zone_insert(nsd_options_t* opt, const char* nm, + const char* patnm, int linesize, off_t off); +void zone_list_del(nsd_options_t* opt, zone_options_t* zone); +void zone_list_compact(nsd_options_t* opt); +void zone_list_close(nsd_options_t* opt); #if defined(HAVE_SSL) /* tsig must be inited, adds all keys in options to tsig. */ @@ -218,8 +314,18 @@ int acl_same_host(acl_options_t* a, acl_options_t* b); /* find acl by number in the list */ acl_options_t* acl_find_num(acl_options_t* acl, int num); +/* see if two acl lists are the same (same elements in same order, or empty) */ +int acl_list_equal(acl_options_t* p, acl_options_t* q); +/* see if two acl are the same */ +int acl_equal(acl_options_t* p, acl_options_t* q); + /* see if a zone is a slave or a master zone */ int zone_is_slave(zone_options_t* opt); +/* create zonefile name, returns static pointer (perhaps to options data) */ +const char* config_make_zonefile(zone_options_t* zone); + +#define ZONEC_PCT_TIME 5 /* seconds, then it starts to print pcts */ +#define ZONEC_PCT_COUNT 100000 /* elements before pct check is done */ /* parsing helpers */ void c_error(const char* msg); @@ -233,5 +339,9 @@ int parse_acl_range_type(char* ip, char** mask); void parse_acl_range_subnet(char* p, void* addr, int maxbits); /* clean up options */ void nsd_options_destroy(nsd_options_t* opt); +/* replace occurrences of one with two in buf, pass length of buffer */ +void replace_str(char* buf, size_t len, const char* one, const char* two); +/* apply pattern to the existing pattern in the parser */ +void config_apply_pattern(const char* name); #endif /* OPTIONS_H */ diff --git a/usr.sbin/nsd/packet.c b/usr.sbin/nsd/packet.c index a4ab76e9511..4cba1600c8f 100644 --- a/usr.sbin/nsd/packet.c +++ b/usr.sbin/nsd/packet.c @@ -1,7 +1,7 @@ /* * packet.c -- low-level DNS packet encoding and decoding functions. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -22,7 +22,7 @@ encode_dname(query_type *q, domain_type *domain) query_put_dname_offset(q, domain, buffer_position(q->packet)); DEBUG(DEBUG_NAME_COMPRESSION, 2, (LOG_INFO, "dname: %s, number: %lu, offset: %u\n", - dname_to_string(domain_dname(domain), NULL), + domain_to_string(domain), (unsigned long) domain->number, query_get_dname_offset(q, domain))); buffer_write(q->packet, dname_name(domain_dname(domain)), @@ -32,7 +32,7 @@ encode_dname(query_type *q, domain_type *domain) if (domain->parent) { DEBUG(DEBUG_NAME_COMPRESSION, 2, (LOG_INFO, "dname: %s, number: %lu, pointer: %u\n", - dname_to_string(domain_dname(domain), NULL), + domain_to_string(domain), (unsigned long) domain->number, query_get_dname_offset(q, domain))); assert(query_get_dname_offset(q, domain) <= MAX_COMPRESSION_OFFSET); diff --git a/usr.sbin/nsd/packet.h b/usr.sbin/nsd/packet.h index c9a34061b74..2efa288b91e 100644 --- a/usr.sbin/nsd/packet.h +++ b/usr.sbin/nsd/packet.h @@ -1,7 +1,7 @@ /* * packet.h -- low-level DNS packet encoding and decoding functions. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * diff --git a/usr.sbin/nsd/query.h b/usr.sbin/nsd/query.h index 24fafd447ca..4ff21f770c5 100644 --- a/usr.sbin/nsd/query.h +++ b/usr.sbin/nsd/query.h @@ -1,7 +1,7 @@ /* * query.h -- manipulation with the queries * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -76,9 +76,6 @@ struct query { /* The zone used to answer the query. */ zone_type *zone; - /* The domain used to answer the query. */ - domain_type *domain; - /* The delegation domain, if any. */ domain_type *delegation_domain; @@ -106,10 +103,10 @@ struct query { * query name when generated from a wildcard record. */ uint16_t *compressed_dname_offsets; - uint32_t compressed_dname_offsets_size; + size_t compressed_dname_offsets_size; /* number of temporary domains used for the query */ - uint32_t number_temporary_domains; + size_t number_temporary_domains; /* * Used for AXFR processing. @@ -175,7 +172,7 @@ void query_add_compression_domain(struct query *query, */ query_type *query_create(region_type *region, uint16_t *compressed_dname_offsets, - uint32_t compressed_dname_size); + size_t compressed_dname_size); /* * Reset a query structure so it is ready for receiving and processing diff --git a/usr.sbin/nsd/radtree.c b/usr.sbin/nsd/radtree.c new file mode 100644 index 00000000000..11bfb4fcd30 --- /dev/null +++ b/usr.sbin/nsd/radtree.c @@ -0,0 +1,1411 @@ +/* + * radtree -- generic radix tree for binary strings. + * + * Copyright (c) 2010, NLnet Labs. See LICENSE for license. + */ +#include "config.h" +#include <assert.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <time.h> +#include "radtree.h" +#include "util.h" +#include "region-allocator.h" + +#include <stdio.h> +#include <ctype.h> + +struct radtree* radix_tree_create(struct region* region) +{ + struct radtree* rt = (struct radtree*)region_alloc(region, sizeof(*rt)); + if(!rt) return NULL; + rt->region = region; + radix_tree_init(rt); + return rt; +} + +void radix_tree_init(struct radtree* rt) +{ + rt->root = NULL; + rt->count = 0; +} + +/** delete radnodes in postorder recursion */ +static void radnode_del_postorder(struct region* region, struct radnode* n) +{ + unsigned i; + if(!n) return; + for(i=0; i<n->len; i++) { + radnode_del_postorder(region, n->array[i].node); + region_recycle(region, n->array[i].str, n->array[i].len); + } + region_recycle(region, n->array, n->capacity*sizeof(struct radsel)); + region_recycle(region, n, sizeof(*n)); +} + +void radix_tree_clear(struct radtree* rt) +{ + radnode_del_postorder(rt->region, rt->root); + rt->root = NULL; + rt->count = 0; +} + +void radix_tree_delete(struct radtree* rt) +{ + if(!rt) return; + radix_tree_clear(rt); + region_recycle(rt->region, rt, sizeof(*rt)); +} + +/** return last elem-containing node in this subtree (excl self) */ +static struct radnode* +radnode_last_in_subtree(struct radnode* n) +{ + int idx; + /* try last entry in array first */ + for(idx=((int)n->len)-1; idx >= 0; idx--) { + if(n->array[idx].node) { + /* does it have entries in its subtrees? */ + if(n->array[idx].node->len > 0) { + struct radnode* s = radnode_last_in_subtree( + n->array[idx].node); + if(s) return s; + } + /* no, does it have an entry itself? */ + if(n->array[idx].node->elem) + return n->array[idx].node; + } + } + return NULL; +} + +/** last in subtree, incl self */ +static struct radnode* +radnode_last_in_subtree_incl_self(struct radnode* n) +{ + struct radnode* s = radnode_last_in_subtree(n); + if(s) return s; + if(n->elem) return n; + return NULL; +} + +/** return first elem-containing node in this subtree (excl self) */ +static struct radnode* +radnode_first_in_subtree(struct radnode* n) +{ + unsigned idx; + struct radnode* s; + /* try every subnode */ + for(idx=0; idx<n->len; idx++) { + if(n->array[idx].node) { + /* does it have elem itself? */ + if(n->array[idx].node->elem) + return n->array[idx].node; + /* try its subtrees */ + if((s=radnode_first_in_subtree(n->array[idx].node))!=0) + return s; + } + } + return NULL; +} + +/** Find an entry in arrays from idx-1 to 0 */ +static struct radnode* +radnode_find_prev_from_idx(struct radnode* n, unsigned from) +{ + unsigned idx = from; + while(idx > 0) { + idx --; + if(n->array[idx].node) { + struct radnode* s = radnode_last_in_subtree_incl_self( + n->array[idx].node); + if(s) return s; + } + } + return NULL; +} + +/** + * Find a prefix of the key, in whole-nodes. + * Finds the longest prefix that corresponds to a whole radnode entry. + * There may be a slightly longer prefix in one of the array elements. + * @param result: the longest prefix, the entry itself if *respos==len, + * otherwise an array entry, residx. + * @param respos: pos in string where next unmatched byte is, if == len an + * exact match has been found. If == 0 then a "" match was found. + * @return false if no prefix found, not even the root "" prefix. + */ +static int radix_find_prefix_node(struct radtree* rt, uint8_t* k, + radstrlen_t len, struct radnode** result, radstrlen_t* respos) +{ + struct radnode* n = rt->root; + radstrlen_t pos = 0; + uint8_t byte; + *respos = 0; + *result = n; + if(!n) return 0; + while(n) { + if(pos == len) { + return 1; + } + byte = k[pos]; + if(byte < n->offset) { + return 1; + } + byte -= n->offset; + if(byte >= n->len) { + return 1; + } + pos++; + if(n->array[byte].len != 0) { + /* must match additional string */ + if(pos+n->array[byte].len > len) { + return 1; + } + if(memcmp(&k[pos], n->array[byte].str, + n->array[byte].len) != 0) { + return 1; + } + pos += n->array[byte].len; + } + n = n->array[byte].node; + if(!n) return 1; + *respos = pos; + *result = n; + } + return 1; +} + +/** grow array to at least the given size, offset unchanged */ +static int +radnode_array_grow(struct region* region, struct radnode* n, unsigned want) +{ + unsigned ns = ((unsigned)n->capacity)*2; + struct radsel* a; + assert(want <= 256); /* cannot be more, range of uint8 */ + if(want > ns) + ns = want; + if(ns > 256) ns = 256; + /* we do not use realloc, because we want to keep the old array + * in case alloc fails, so that the tree is still usable */ + a = (struct radsel*)region_alloc(region, ns*sizeof(struct radsel)); + if(!a) return 0; + assert(n->len <= n->capacity); + assert(n->capacity < ns); + memcpy(&a[0], &n->array[0], n->len*sizeof(struct radsel)); + region_recycle(region, n->array, n->capacity*sizeof(struct radsel)); + n->array = a; + n->capacity = ns; + return 1; +} + +/** make space in radnode array for another byte */ +static int +radnode_array_space(struct region* region, struct radnode* n, uint8_t byte) +{ + /* is there an array? */ + if(!n->array || n->capacity == 0) { + n->array = (struct radsel*)region_alloc(region, + sizeof(struct radsel)); + if(!n->array) return 0; + memset(&n->array[0], 0, sizeof(struct radsel)); + n->len = 1; + n->capacity = 1; + n->offset = byte; + /* is the array unused? */ + } else if(n->len == 0 && n->capacity != 0) { + n->len = 1; + n->offset = byte; + memset(&n->array[0], 0, sizeof(struct radsel)); + /* is it below the offset? */ + } else if(byte < n->offset) { + /* is capacity enough? */ + unsigned idx; + unsigned need = n->offset-byte; + if(n->len+need > n->capacity) { + /* grow array */ + if(!radnode_array_grow(region, n, n->len+need)) + return 0; + } + /* reshuffle items to end */ + memmove(&n->array[need], &n->array[0], + n->len*sizeof(struct radsel)); + /* fixup pidx */ + for(idx = 0; idx < n->len; idx++) { + if(n->array[idx+need].node) + n->array[idx+need].node->pidx = idx+need; + } + /* zero the first */ + memset(&n->array[0], 0, need*sizeof(struct radsel)); + n->len += need; + n->offset = byte; + /* is it above the max? */ + } else if(byte-n->offset >= n->len) { + /* is capacity enough? */ + unsigned need = (byte-n->offset) - n->len + 1; + /* grow array */ + if(n->len + need > n->capacity) { + if(!radnode_array_grow(region, n, n->len+need)) + return 0; + } + /* zero added entries */ + memset(&n->array[n->len], 0, need*sizeof(struct radsel)); + /* grow length */ + n->len += need; + } + return 1; +} + +/** create a prefix in the array strs */ +static int +radsel_str_create(struct region* region, struct radsel* r, uint8_t* k, + radstrlen_t pos, radstrlen_t len) +{ + r->str = (uint8_t*)region_alloc(region, sizeof(uint8_t)*(len-pos)); + if(!r->str) + return 0; /* out of memory */ + memmove(r->str, k+pos, len-pos); + r->len = len-pos; + return 1; +} + +/** see if one byte string p is a prefix of another x (equality is true) */ +static int +bstr_is_prefix(uint8_t* p, radstrlen_t plen, uint8_t* x, radstrlen_t xlen) +{ + /* if plen is zero, it is an (empty) prefix */ + if(plen == 0) + return 1; + /* if so, p must be shorter */ + if(plen > xlen) + return 0; + return (memcmp(p, x, plen) == 0); +} + +/** number of bytes in common for the two strings */ +static radstrlen_t +bstr_common(uint8_t* x, radstrlen_t xlen, uint8_t* y, radstrlen_t ylen) +{ + unsigned i, max = ((xlen<ylen)?xlen:ylen); + for(i=0; i<max; i++) { + if(x[i] != y[i]) + return i; + } + return max; +} + + +int +bstr_is_prefix_ext(uint8_t* p, radstrlen_t plen, uint8_t* x, radstrlen_t xlen) +{ + return bstr_is_prefix(p, plen, x, xlen); +} + +radstrlen_t +bstr_common_ext(uint8_t* x, radstrlen_t xlen, uint8_t* y, radstrlen_t ylen) +{ + return bstr_common(x, xlen, y, ylen); +} + +/** allocate remainder from prefixes for a split: + * plen: len prefix, l: longer bstring, llen: length of l. */ +static int +radsel_prefix_remainder(struct region* region, radstrlen_t plen, + uint8_t* l, radstrlen_t llen, + uint8_t** s, radstrlen_t* slen) +{ + *slen = llen - plen; + *s = (uint8_t*)region_alloc(region, (*slen)*sizeof(uint8_t)); + if(!*s) + return 0; + memmove(*s, l+plen, llen-plen); + return 1; +} + +/** radsel create a split when two nodes have shared prefix. + * @param r: radsel that gets changed, it contains a node. + * @param k: key byte string + * @param pos: position where the string enters the radsel (e.g. r.str) + * @param len: length of k. + * @param add: additional node for the string k. + * removed by called on failure. + * @return false on alloc failure, no changes made. + */ +static int +radsel_split(struct region* region, struct radsel* r, uint8_t* k, + radstrlen_t pos, radstrlen_t len, struct radnode* add) +{ + uint8_t* addstr = k+pos; + radstrlen_t addlen = len-pos; + if(bstr_is_prefix(addstr, addlen, r->str, r->len)) { + uint8_t* split_str=NULL, *dupstr=NULL; + radstrlen_t split_len=0; + /* 'add' is a prefix of r.node */ + /* also for empty addstr */ + /* set it up so that the 'add' node has r.node as child */ + /* so, r.node gets moved below the 'add' node, but we do + * this so that the r.node stays the same pointer for its + * key name */ + assert(addlen != r->len); + assert(addlen < r->len); + if(r->len-addlen > 1) { + /* shift one because a char is in the lookup array */ + if(!radsel_prefix_remainder(region, addlen+1, r->str, + r->len, &split_str, &split_len)) + return 0; + } + if(addlen != 0) { + dupstr = (uint8_t*)region_alloc(region, + addlen*sizeof(uint8_t)); + if(!dupstr) { + region_recycle(region, split_str, split_len); + return 0; + } + memcpy(dupstr, addstr, addlen); + } + if(!radnode_array_space(region, add, r->str[addlen])) { + region_recycle(region, split_str, split_len); + region_recycle(region, dupstr, addlen); + return 0; + } + /* alloc succeeded, now link it in */ + add->parent = r->node->parent; + add->pidx = r->node->pidx; + add->array[0].node = r->node; + add->array[0].str = split_str; + add->array[0].len = split_len; + r->node->parent = add; + r->node->pidx = 0; + + r->node = add; + region_recycle(region, r->str, r->len); + r->str = dupstr; + r->len = addlen; + } else if(bstr_is_prefix(r->str, r->len, addstr, addlen)) { + uint8_t* split_str = NULL; + radstrlen_t split_len = 0; + /* r.node is a prefix of 'add' */ + /* set it up so that the 'r.node' has 'add' as child */ + /* and basically, r.node is already completely fine, + * we only need to create a node as its child */ + assert(addlen != r->len); + assert(r->len < addlen); + if(addlen-r->len > 1) { + /* shift one because a character goes into array */ + if(!radsel_prefix_remainder(region, r->len+1, addstr, + addlen, &split_str, &split_len)) + return 0; + } + if(!radnode_array_space(region, r->node, addstr[r->len])) { + region_recycle(region, split_str, split_len); + return 0; + } + /* alloc succeeded, now link it in */ + add->parent = r->node; + add->pidx = addstr[r->len] - r->node->offset; + r->node->array[add->pidx].node = add; + r->node->array[add->pidx].str = split_str; + r->node->array[add->pidx].len = split_len; + } else { + /* okay we need to create a new node that chooses between + * the nodes 'add' and r.node + * We do this so that r.node stays the same pointer for its + * key name. */ + struct radnode* com; + uint8_t* common_str=NULL, *s1_str=NULL, *s2_str=NULL; + radstrlen_t common_len, s1_len=0, s2_len=0; + common_len = bstr_common(r->str, r->len, addstr, addlen); + assert(common_len < r->len); + assert(common_len < addlen); + + /* create the new node for choice */ + com = (struct radnode*)region_alloc_zero(region, sizeof(*com)); + if(!com) return 0; /* out of memory */ + + /* create the two substrings for subchoices */ + if(r->len-common_len > 1) { + /* shift by one char because it goes in lookup array */ + if(!radsel_prefix_remainder(region, common_len+1, + r->str, r->len, &s1_str, &s1_len)) { + region_recycle(region, com, sizeof(*com)); + return 0; + } + } + if(addlen-common_len > 1) { + if(!radsel_prefix_remainder(region, common_len+1, + addstr, addlen, &s2_str, &s2_len)) { + region_recycle(region, com, sizeof(*com)); + region_recycle(region, s1_str, s1_len); + return 0; + } + } + + /* create the shared prefix to go in r */ + if(common_len > 0) { + common_str = (uint8_t*)region_alloc(region, + common_len*sizeof(uint8_t*)); + if(!common_str) { + region_recycle(region, com, sizeof(*com)); + region_recycle(region, s1_str, s1_len); + region_recycle(region, s2_str, s2_len); + return 0; + } + memcpy(common_str, addstr, common_len); + } + + /* make space in the common node array */ + if(!radnode_array_space(region, com, r->str[common_len]) || + !radnode_array_space(region, com, addstr[common_len])) { + region_recycle(region, com->array, com->capacity*sizeof(struct radsel)); + region_recycle(region, com, sizeof(*com)); + region_recycle(region, common_str, common_len); + region_recycle(region, s1_str, s1_len); + region_recycle(region, s2_str, s2_len); + return 0; + } + + /* allocs succeeded, proceed to link it all up */ + com->parent = r->node->parent; + com->pidx = r->node->pidx; + r->node->parent = com; + r->node->pidx = r->str[common_len]-com->offset; + add->parent = com; + add->pidx = addstr[common_len]-com->offset; + com->array[r->node->pidx].node = r->node; + com->array[r->node->pidx].str = s1_str; + com->array[r->node->pidx].len = s1_len; + com->array[add->pidx].node = add; + com->array[add->pidx].str = s2_str; + com->array[add->pidx].len = s2_len; + region_recycle(region, r->str, r->len); + r->str = common_str; + r->len = common_len; + r->node = com; + } + return 1; +} + +struct radnode* radix_insert(struct radtree* rt, uint8_t* k, radstrlen_t len, + void* elem) +{ + struct radnode* n; + radstrlen_t pos = 0; + /* create new element to add */ + struct radnode* add = (struct radnode*)region_alloc_zero(rt->region, + sizeof(*add)); + if(!add) return NULL; /* out of memory */ + add->elem = elem; + + /* find out where to add it */ + if(!radix_find_prefix_node(rt, k, len, &n, &pos)) { + /* new root */ + assert(rt->root == NULL); + if(len == 0) { + rt->root = add; + } else { + /* add a root to point to new node */ + n = (struct radnode*)region_alloc_zero(rt->region, + sizeof(*n)); + if(!n) return NULL; + if(!radnode_array_space(rt->region, n, k[0])) { + region_recycle(rt->region, n->array, + n->capacity*sizeof(struct radsel)); + region_recycle(rt->region, n, sizeof(*n)); + region_recycle(rt->region, add, sizeof(*add)); + return NULL; + } + add->parent = n; + add->pidx = 0; + n->array[0].node = add; + if(len > 1) { + if(!radsel_prefix_remainder(rt->region, 1, k, len, + &n->array[0].str, &n->array[0].len)) { + region_recycle(rt->region, n->array, + n->capacity*sizeof(struct radsel)); + region_recycle(rt->region, n, sizeof(*n)); + region_recycle(rt->region, add, sizeof(*add)); + return NULL; + } + } + rt->root = n; + } + } else if(pos == len) { + /* found an exact match */ + if(n->elem) { + /* already exists, failure */ + region_recycle(rt->region, add, sizeof(*add)); + return NULL; + } + n->elem = elem; + region_recycle(rt->region, add, sizeof(*add)); + add = n; + } else { + /* n is a node which can accomodate */ + uint8_t byte; + assert(pos < len); + byte = k[pos]; + + /* see if it falls outside of array */ + if(byte < n->offset || byte-n->offset >= n->len) { + /* make space in the array for it; adjusts offset */ + if(!radnode_array_space(rt->region, n, byte)) { + region_recycle(rt->region, add, sizeof(*add)); + return NULL; + } + assert(byte>=n->offset && byte-n->offset<n->len); + byte -= n->offset; + /* see if more prefix needs to be split off */ + if(pos+1 < len) { + if(!radsel_str_create(rt->region, &n->array[byte], + k, pos+1, len)) { + region_recycle(rt->region, add, sizeof(*add)); + return NULL; + } + } + /* insert the new node in the new bucket */ + add->parent = n; + add->pidx = byte; + n->array[byte].node = add; + /* so a bucket exists and byte falls in it */ + } else if(n->array[byte-n->offset].node == NULL) { + /* use existing bucket */ + byte -= n->offset; + if(pos+1 < len) { + /* split off more prefix */ + if(!radsel_str_create(rt->region, &n->array[byte], + k, pos+1, len)) { + region_recycle(rt->region, add, sizeof(*add)); + return NULL; + } + } + /* insert the new node in the new bucket */ + add->parent = n; + add->pidx = byte; + n->array[byte].node = add; + } else { + /* use bucket but it has a shared prefix, + * split that out and create a new intermediate + * node to split out between the two. + * One of the two might exactmatch the new + * intermediate node */ + if(!radsel_split(rt->region, &n->array[byte-n->offset], + k, pos+1, len, add)) { + region_recycle(rt->region, add, sizeof(*add)); + return NULL; + } + } + } + + rt->count ++; + return add; +} + +/** Delete a radnode */ +static void radnode_delete(struct region* region, struct radnode* n) +{ + unsigned i; + if(!n) return; + for(i=0; i<n->len; i++) { + /* safe to free NULL str */ + region_recycle(region, n->array[i].str, n->array[i].len); + } + region_recycle(region, n->array, n->capacity*sizeof(struct radsel)); + region_recycle(region, n, sizeof(*n)); +} + +/** Cleanup node with one child, it is removed and joined into parent[x] str */ +static int +radnode_cleanup_onechild(struct region* region, struct radnode* n, + struct radnode* par) +{ + uint8_t* join; + radstrlen_t joinlen; + uint8_t pidx = n->pidx; + struct radnode* child = n->array[0].node; + /* node had one child, merge them into the parent. */ + /* keep the child node, so its pointers stay valid. */ + + /* at parent, append child->str to array str */ + assert(pidx < par->len); + joinlen = par->array[pidx].len + n->array[0].len + 1; + join = (uint8_t*)region_alloc(region, joinlen*sizeof(uint8_t)); + if(!join) { + /* cleanup failed due to out of memory */ + /* the tree is inefficient, with node n still existing */ + return 0; + } + /* we know that .str and join are malloced, thus aligned */ + memcpy(join, par->array[pidx].str, par->array[pidx].len); + /* the array lookup is gone, put its character in the lookup string*/ + join[par->array[pidx].len] = child->pidx + n->offset; + /* but join+len may not be aligned */ + memmove(join+par->array[pidx].len+1, n->array[0].str, n->array[0].len); + region_recycle(region, par->array[pidx].str, par->array[pidx].len); + par->array[pidx].str = join; + par->array[pidx].len = joinlen; + /* and set the node to our child. */ + par->array[pidx].node = child; + child->parent = par; + child->pidx = pidx; + /* we are unlinked, delete our node */ + radnode_delete(region, n); + return 1; +} + +/** remove array of nodes */ +static void +radnode_array_clean_all(struct region* region, struct radnode* n) +{ + n->offset = 0; + n->len = 0; + /* shrink capacity */ + region_recycle(region, n->array, n->capacity*sizeof(struct radsel)); + n->array = NULL; + n->capacity = 0; +} + +/** see if capacity can be reduced for the given node array */ +static void +radnode_array_reduce_if_needed(struct region* region, struct radnode* n) +{ + if(n->len <= n->capacity/2 && n->len != n->capacity) { + struct radsel* a = (struct radsel*)region_alloc(region, + sizeof(*a)*n->len); + if(!a) return; + memcpy(a, n->array, sizeof(*a)*n->len); + region_recycle(region, n->array, n->capacity*sizeof(*a)); + n->array = a; + n->capacity = n->len; + } +} + +/** remove NULL nodes from front of array */ +static void +radnode_array_clean_front(struct region* region, struct radnode* n) +{ + /* move them up and adjust offset */ + unsigned idx, shuf = 0; + /* remove until a nonNULL entry */ + while(shuf < n->len && n->array[shuf].node == NULL) + shuf++; + if(shuf == 0) + return; + if(shuf == n->len) { + /* the array is empty, the tree is inefficient */ + radnode_array_clean_all(region, n); + return; + } + assert(shuf < n->len); + assert((int)shuf <= 255-(int)n->offset); + memmove(&n->array[0], &n->array[shuf], + (n->len - shuf)*sizeof(struct radsel)); + n->offset += shuf; + n->len -= shuf; + for(idx=0; idx<n->len; idx++) + if(n->array[idx].node) + n->array[idx].node->pidx = idx; + /* see if capacity can be reduced */ + radnode_array_reduce_if_needed(region, n); +} + +/** remove NULL nodes from end of array */ +static void +radnode_array_clean_end(struct region* region, struct radnode* n) +{ + /* shorten it */ + unsigned shuf = 0; + /* remove until a nonNULL entry */ + while(shuf < n->len && n->array[n->len-1-shuf].node == NULL) + shuf++; + if(shuf == 0) + return; + if(shuf == n->len) { + /* the array is empty, the tree is inefficient */ + radnode_array_clean_all(region, n); + return; + } + assert(shuf < n->len); + n->len -= shuf; + /* array elements can stay where they are */ + /* see if capacity can be reduced */ + radnode_array_reduce_if_needed(region, n); +} + +/** clean up radnode leaf, where we know it has a parent */ +static void +radnode_cleanup_leaf(struct region* region, struct radnode* n, + struct radnode* par) +{ + uint8_t pidx; + /* node was a leaf */ + /* delete leaf node, but store parent+idx */ + pidx = n->pidx; + radnode_delete(region, n); + + /* set parent+idx entry to NULL str and node.*/ + assert(pidx < par->len); + region_recycle(region, par->array[pidx].str, par->array[pidx].len); + par->array[pidx].str = NULL; + par->array[pidx].len = 0; + par->array[pidx].node = NULL; + + /* see if par offset or len must be adjusted */ + if(par->len == 1) { + /* removed final element from array */ + radnode_array_clean_all(region, par); + } else if(pidx == 0) { + /* removed first element from array */ + radnode_array_clean_front(region, par); + } else if(pidx == par->len-1) { + /* removed last element from array */ + radnode_array_clean_end(region, par); + } +} + +/** + * Cleanup a radix node that was made smaller, see if it can + * be merged with others. + * @param rt: tree to remove root if needed. + * @param n: node to cleanup + * @return false on alloc failure. + */ +static int +radnode_cleanup(struct radtree* rt, struct radnode* n) +{ + while(n) { + if(n->elem) { + /* cannot delete node with a data element */ + return 1; + } else if(n->len == 1 && n->parent) { + return radnode_cleanup_onechild(rt->region, n, n->parent); + } else if(n->len == 0) { + struct radnode* par = n->parent; + if(!par) { + /* root deleted */ + radnode_delete(rt->region, n); + rt->root = NULL; + return 1; + } + /* remove and delete the leaf node */ + radnode_cleanup_leaf(rt->region, n, par); + /* see if parent can now be cleaned up */ + n = par; + } else { + /* node cannot be cleaned up */ + return 1; + } + } + /* ENOTREACH */ + return 1; +} + +void radix_delete(struct radtree* rt, struct radnode* n) +{ + if(!n) return; + n->elem = NULL; + rt->count --; + if(!radnode_cleanup(rt, n)) { + /* out of memory in cleanup. the elem ptr is NULL, but + * the radix tree could be inefficient. */ + } +} + +struct radnode* radix_search(struct radtree* rt, uint8_t* k, radstrlen_t len) +{ + struct radnode* n = rt->root; + radstrlen_t pos = 0; + uint8_t byte; + while(n) { + if(pos == len) + return n->elem?n:NULL; + byte = k[pos]; + if(byte < n->offset) + return NULL; + byte -= n->offset; + if(byte >= n->len) + return NULL; + pos++; + if(n->array[byte].len != 0) { + /* must match additional string */ + if(pos+n->array[byte].len > len) + return NULL; /* no match */ + if(memcmp(&k[pos], n->array[byte].str, + n->array[byte].len) != 0) + return NULL; /* no match */ + pos += n->array[byte].len; + } + n = n->array[byte].node; + } + return NULL; +} + +/** return self or a previous element */ +static int ret_self_or_prev(struct radnode* n, struct radnode** result) +{ + if(n->elem) + *result = n; + else *result = radix_prev(n); + return 0; +} + +int radix_find_less_equal(struct radtree* rt, uint8_t* k, radstrlen_t len, + struct radnode** result) +{ + struct radnode* n = rt->root; + radstrlen_t pos = 0; + uint8_t byte; + int r; + if(!n) { + /* empty tree */ + *result = NULL; + return 0; + } + while(pos < len) { + byte = k[pos]; + if(byte < n->offset) { + /* so the previous is the element itself */ + /* or something before this element */ + return ret_self_or_prev(n, result); + } + byte -= n->offset; + if(byte >= n->len) { + /* so, the previous is the last of array, or itself */ + /* or something before this element */ + if((*result=radnode_last_in_subtree_incl_self(n))==0) + *result = radix_prev(n); + return 0; + } + pos++; + if(!n->array[byte].node) { + /* no match */ + /* Find an entry in arrays from byte-1 to 0 */ + *result = radnode_find_prev_from_idx(n, byte); + if(*result) + return 0; + /* this entry or something before it */ + return ret_self_or_prev(n, result); + } + if(n->array[byte].len != 0) { + /* must match additional string */ + if(pos+n->array[byte].len > len) { + /* the additional string is longer than key*/ + if( (memcmp(&k[pos], n->array[byte].str, + len-pos)) <= 0) { + /* and the key is before this node */ + *result = radix_prev(n->array[byte].node); + } else { + /* the key is after the additional + * string, thus everything in that + * subtree is smaller. */ + *result=radnode_last_in_subtree_incl_self(n->array[byte].node); + /* if somehow that is NULL, + * then we have an inefficient tree: + * byte+1 is larger than us, so find + * something in byte-1 and before */ + if(!*result) + *result = radix_prev(n->array[byte].node); + } + return 0; /* no match */ + } + if( (r=memcmp(&k[pos], n->array[byte].str, + n->array[byte].len)) < 0) { + *result = radix_prev(n->array[byte].node); + return 0; /* no match */ + } else if(r > 0) { + /* the key is larger than the additional + * string, thus everything in that subtree + * is smaller */ + *result=radnode_last_in_subtree_incl_self(n->array[byte].node); + /* if we have an inefficient tree */ + if(!*result) *result = radix_prev(n->array[byte].node); + return 0; /* no match */ + } + pos += n->array[byte].len; + } + n = n->array[byte].node; + } + if(n->elem) { + /* exact match */ + *result = n; + return 1; + } + /* there is a node which is an exact match, but it has no element */ + *result = radix_prev(n); + return 0; +} + + +struct radnode* radix_first(struct radtree* rt) +{ + struct radnode* n; + if(!rt || !rt->root) return NULL; + n = rt->root; + if(n->elem) return n; + return radix_next(n); +} + +struct radnode* radix_last(struct radtree* rt) +{ + if(!rt || !rt->root) return NULL; + return radnode_last_in_subtree_incl_self(rt->root); +} + +struct radnode* radix_next(struct radnode* n) +{ + if(n->len) { + /* go down */ + struct radnode* s = radnode_first_in_subtree(n); + if(s) return s; + } + /* go up - the parent->elem is not useful, because it is before us */ + while(n->parent) { + unsigned idx = n->pidx; + n = n->parent; + idx++; + for(; idx < n->len; idx++) { + /* go down the next branch */ + if(n->array[idx].node) { + struct radnode* s; + /* node itself */ + if(n->array[idx].node->elem) + return n->array[idx].node; + /* or subtree */ + s = radnode_first_in_subtree( + n->array[idx].node); + if(s) return s; + } + } + } + return NULL; +} + +struct radnode* radix_prev(struct radnode* n) +{ + /* must go up, since all array nodes are after this node */ + while(n->parent) { + uint8_t idx = n->pidx; + struct radnode* s; + n = n->parent; + assert(n->len > 0); /* since we are a child */ + /* see if there are elements in previous branches there */ + s = radnode_find_prev_from_idx(n, idx); + if(s) return s; + /* the current node is before the array */ + if(n->elem) + return n; + } + return NULL; +} + +/** convert one character from domain-name to radname */ +static uint8_t char_d2r(uint8_t c) +{ + if(c < 'A') return c+1; /* make space for 00 */ + else if(c <= 'Z') return c-'A'+'a'; /* lowercase */ + else return c; +} + +/** convert one character from radname to domain-name (still lowercased) */ +static uint8_t char_r2d(uint8_t c) +{ + assert(c != 0); /* end of label */ + if(c <= 'A') return c-1; + else return c; +} + +/** copy and convert a range of characters */ +static void cpy_d2r(uint8_t* to, const uint8_t* from, int len) +{ + int i; + for(i=0; i<len; i++) + to[i] = char_d2r(from[i]); +} + +/** copy and convert a range of characters */ +static void cpy_r2d(uint8_t* to, uint8_t* from, uint8_t len) +{ + uint8_t i; + for(i=0; i<len; i++) + to[i] = char_r2d(from[i]); +} + +/* radname code: domain to radix-bstring */ +void radname_d2r(uint8_t* k, radstrlen_t* len, const uint8_t* dname, + size_t dlen) +{ + /* the domain name is converted as follows, + * to preserve the normal (NSEC) ordering of domain names. + * lowercased, and 'end-of-label' is a '00' byte, + * bytes 00-'A' are +1 moved to make space for 00 byte. + * final root label is not appended (string ends). + * because the only allowed empty label is the final root label, + * we can also remove the last 00 label-end. + * The total result length is one-or-two less than the dname. + * + * examples (numbers are bytes, letters are ascii): + * - root: dname: 0, radname: '' + * - nl.: dname: 3nl0, radname: 'nl' + * - labs.nl: dname 4labs3nl0, radname: 'nl0labs' + * - x.labs.nl: dname 1x4labs3nl0, radname: 'nl0labs0x' + */ + + /* conversion by putting the label starts on a stack */ + const uint8_t* labstart[130]; + unsigned int lab = 0, kpos, dpos = 0; + /* sufficient space */ + assert(k && dname); + assert(dlen <= 256); /* and therefore not more than 128 labels */ + assert(*len >= dlen); + assert(dlen > 0); /* even root label has dlen=1 */ + + /* root */ + if(dlen == 1) { + assert(dname[0] == 0); + *len = 0; + return; + } + + /* walk through domain name and remember label positions */ + do { + /* compression pointers not allowed */ + if((dname[dpos] & 0xc0)) { + *len = 0; + return; /* format error */ + } + labstart[lab++] = &dname[dpos]; + if(dpos + dname[dpos] + 1 >= dlen) { + *len = 0; + return; /* format error */ + } + /* skip the label contents */ + dpos += dname[dpos]; + dpos ++; + } while(dname[dpos] != 0); + /* exit condition makes root label not in labelstart stack */ + /* because the root was handled before, we know there is some text */ + assert(lab > 0); + lab-=1; + kpos = *labstart[lab]; + cpy_d2r(k, labstart[lab]+1, kpos); + /* if there are more labels, copy them over */ + while(lab) { + /* put 'end-of-label' 00 to end previous label */ + k[kpos++]=0; + /* append the label */ + lab--; + cpy_d2r(k+kpos, labstart[lab]+1, *labstart[lab]); + kpos += *labstart[lab]; + } + /* done */ + assert(kpos == dlen-2); /* no rootlabel, one less label-marker */ + *len = kpos; +} + +/* radname code: radix-bstring to domain */ +void radname_r2d(uint8_t* k, radstrlen_t len, uint8_t* dname, size_t* dlen) +{ + /* find labels and push on stack */ + uint8_t* labstart[130]; + uint8_t lablen[130]; + unsigned int lab = 0, dpos, kpos = 0; + /* sufficient space */ + assert(k && dname); + assert((size_t)*dlen >= (size_t)len+2); + assert(len <= 256); + /* root label */ + if(len == 0) { + assert(*dlen > 0); + dname[0]=0; + *dlen=1; + return; + } + /* find labels */ + while(kpos < len) { + lablen[lab]=0; + labstart[lab]=&k[kpos]; + /* skip to next label */ + while(kpos < len && k[kpos] != 0) { + lablen[lab]++; + kpos++; + } + lab++; + /* skip 00 byte for label-end */ + if(kpos < len) { + assert(k[kpos] == 0); + kpos++; + } + } + /* copy the labels over to the domain name */ + dpos = 0; + while(lab) { + lab--; + /* label length */ + dname[dpos++] = lablen[lab]; + /* label content */ + cpy_r2d(dname+dpos, labstart[lab], lablen[lab]); + dpos += lablen[lab]; + } + /* append root label */ + dname[dpos++] = 0; + /* assert the domain name is wellformed */ + assert((int)dpos == (int)len+2); + assert(dname[dpos-1] == 0); /* ends with root label */ + *dlen = dpos; +} + +/** insert by domain name */ +struct radnode* +radname_insert(struct radtree* rt, const uint8_t* d, size_t max, void* elem) +{ + /* convert and insert */ + uint8_t radname[300]; + radstrlen_t len = (radstrlen_t)sizeof(radname); + if(max > sizeof(radname)) + return NULL; /* too long */ + radname_d2r(radname, &len, d, max); + return radix_insert(rt, radname, len, elem); +} + +/** delete by domain name */ +void +radname_delete(struct radtree* rt, const uint8_t* d, size_t max) +{ + /* search and remove */ + struct radnode* n = radname_search(rt, d, max); + if(n) radix_delete(rt, n); +} + +/* search for exact match of domain name, converted to radname in tree */ +struct radnode* radname_search(struct radtree* rt, const uint8_t* d, + size_t max) +{ + /* stack of labels in the domain name */ + const uint8_t* labstart[130]; + unsigned int lab, dpos, lpos; + struct radnode* n = rt->root; + uint8_t byte; + radstrlen_t i; + uint8_t b; + + /* search for root? it is '' */ + if(max < 1) + return NULL; + if(d[0] == 0) { + if(!n) return NULL; + return n->elem?n:NULL; + } + + /* find labels stack in domain name */ + lab = 0; + dpos = 0; + /* must have one label, since root is specialcased */ + do { + if((d[dpos] & 0xc0)) + return NULL; /* compression ptrs not allowed error */ + labstart[lab++] = &d[dpos]; + if(dpos + d[dpos] + 1 >= max) + return NULL; /* format error: outside of bounds */ + /* skip the label contents */ + dpos += d[dpos]; + dpos ++; + } while(d[dpos] != 0); + /* exit condition makes that root label is not in the labstarts */ + /* now: dpos+1 is length of domain name. lab is number of labels-1 */ + + /* start processing at the last label */ + lab-=1; + lpos = 0; + while(n) { + /* fetch next byte this label */ + if(lpos < *labstart[lab]) + /* lpos+1 to skip labelstart, lpos++ to move forward */ + byte = char_d2r(labstart[lab][++lpos]); + else { + if(lab == 0) /* last label - we're done */ + return n->elem?n:NULL; + /* next label, search for byte 00 */ + lpos = 0; + lab--; + byte = 0; + } + /* find that byte in the array */ + if(byte < n->offset) + return NULL; + byte -= n->offset; + if(byte >= n->len) + return NULL; + if(n->array[byte].len != 0) { + /* must match additional string */ + /* see how many bytes we need and start matching them*/ + for(i=0; i<n->array[byte].len; i++) { + /* next byte to match */ + if(lpos < *labstart[lab]) + b = char_d2r(labstart[lab][++lpos]); + else { + /* if last label, no match since + * we are in the additional string */ + if(lab == 0) + return NULL; + /* next label, search for byte 00 */ + lpos = 0; + lab--; + b = 0; + } + if(n->array[byte].str[i] != b) + return NULL; /* not matched */ + } + } + n = n->array[byte].node; + } + return NULL; +} + +/* find domain name or smaller or equal domain name in radix tree */ +int radname_find_less_equal(struct radtree* rt, const uint8_t* d, size_t max, + struct radnode** result) +{ + /* stack of labels in the domain name */ + const uint8_t* labstart[130]; + unsigned int lab, dpos, lpos; + struct radnode* n = rt->root; + uint8_t byte; + radstrlen_t i; + uint8_t b; + + /* empty tree */ + if(!n) { + *result = NULL; + return 0; + } + + /* search for root? it is '' */ + if(max < 1) { + *result = NULL; + return 0; /* parse error, out of bounds */ + } + if(d[0] == 0) { + if(n->elem) { + *result = n; + return 1; + } + /* no smaller element than the root */ + *result = NULL; + return 0; + } + + /* find labels stack in domain name */ + lab = 0; + dpos = 0; + /* must have one label, since root is specialcased */ + do { + if((d[dpos] & 0xc0)) { + *result = NULL; + return 0; /* compression ptrs not allowed error */ + } + labstart[lab++] = &d[dpos]; + if(dpos + d[dpos] + 1 >= max) { + *result = NULL; /* format error: outside of bounds */ + return 0; + } + /* skip the label contents */ + dpos += d[dpos]; + dpos ++; + } while(d[dpos] != 0); + /* exit condition makes that root label is not in the labstarts */ + /* now: dpos+1 is length of domain name. lab is number of labels-1 */ + + /* start processing at the last label */ + lab-=1; + lpos = 0; + while(1) { + /* fetch next byte this label */ + if(lpos < *labstart[lab]) + /* lpos+1 to skip labelstart, lpos++ to move forward */ + byte = char_d2r(labstart[lab][++lpos]); + else { + if(lab == 0) { + /* last label - we're done */ + /* exact match */ + if(n->elem) { + *result = n; + return 1; + } + /* there is a node which is an exact match, + * but there no element in it */ + *result = radix_prev(n); + return 0; + } + /* next label, search for byte 0 the label separator */ + lpos = 0; + lab--; + byte = 0; + } + /* find that byte in the array */ + if(byte < n->offset) + /* so the previous is the element itself */ + /* or something before this element */ + return ret_self_or_prev(n, result); + byte -= n->offset; + if(byte >= n->len) { + /* so, the previous is the last of array, or itself */ + /* or something before this element */ + *result = radnode_last_in_subtree_incl_self(n); + if(!*result) + *result = radix_prev(n); + return 0; + } + if(!n->array[byte].node) { + /* no match */ + /* Find an entry in arrays from byte-1 to 0 */ + *result = radnode_find_prev_from_idx(n, byte); + if(*result) + return 0; + /* this entry or something before it */ + return ret_self_or_prev(n, result); + } + if(n->array[byte].len != 0) { + /* must match additional string */ + /* see how many bytes we need and start matching them*/ + for(i=0; i<n->array[byte].len; i++) { + /* next byte to match */ + if(lpos < *labstart[lab]) + b = char_d2r(labstart[lab][++lpos]); + else { + /* if last label, no match since + * we are in the additional string */ + if(lab == 0) { + /* dname ended, thus before + * this array element */ + *result =radix_prev( + n->array[byte].node); + return 0; + } + /* next label, search for byte 00 */ + lpos = 0; + lab--; + b = 0; + } + if(b < n->array[byte].str[i]) { + *result =radix_prev( + n->array[byte].node); + return 0; + } else if(b > n->array[byte].str[i]) { + /* the key is after the additional, + * so everything in its subtree is + * smaller */ + *result = radnode_last_in_subtree_incl_self(n->array[byte].node); + /* if that is NULL, we have an + * inefficient tree, find in byte-1*/ + if(!*result) + *result = radix_prev(n->array[byte].node); + return 0; + } + } + } + n = n->array[byte].node; + } + /* ENOTREACH */ + return 0; +} + diff --git a/usr.sbin/nsd/radtree.h b/usr.sbin/nsd/radtree.h new file mode 100644 index 00000000000..6f54de01641 --- /dev/null +++ b/usr.sbin/nsd/radtree.h @@ -0,0 +1,244 @@ +/* + * radtree -- generic radix tree for binary strings. + * + * Copyright (c) 2010, NLnet Labs. See LICENSE for license. + */ +#ifndef RADTREE_H +#define RADTREE_H + +struct radnode; +struct region; + +/** length of the binary string */ +typedef uint16_t radstrlen_t; + +/** + * The radix tree + * + * The elements are stored based on binary strings(0-255) of a given length. + * They are sorted, a prefix is sorted before its suffixes. + * If you want to know the key string, you should store it yourself, the + * tree stores it in the parts necessary for lookup. + * For binary strings for domain names see the radname routines. + */ +struct radtree { + /** root node in tree */ + struct radnode* root; + /** count of number of elements */ + size_t count; + /** region for allocation */ + struct region* region; +}; + +/** + * A radix tree lookup node. + * The array is malloced separately from the radnode. + */ +struct radnode { + /** data element associated with the binary string up to this node */ + void* elem; + /** parent node (NULL for the root) */ + struct radnode* parent; + /** index in the parent lookup array */ + uint8_t pidx; + /** offset of the lookup array, add to [i] for lookups */ + uint8_t offset; + /** length of the lookup array */ + uint16_t len; + /** capacity of the lookup array (can be larger than length) */ + uint16_t capacity; + /** the lookup array by [byte-offset] */ + struct radsel* array; +}; + +/** + * radix select edge in array + */ +struct radsel { + /** additional string after the selection-byte for this edge. */ + uint8_t* str; + /** length of the additional string for this edge */ + radstrlen_t len; + /** node that deals with byte+str */ + struct radnode* node; +}; + +/** + * Create new radix tree + * @param region: where to allocate the tree. + * @return new tree or NULL on alloc failure. + */ +struct radtree* radix_tree_create(struct region* region); + +/** + * Init new radix tree. + * @param rt: radix tree to be initialized. + */ +void radix_tree_init(struct radtree* rt); + +/** + * Delete intermediate nodes from radix tree + * @param rt: radix tree to be initialized. + */ +void radix_tree_clear(struct radtree* rt); + +/** + * Delete radix tree. + * @param rt: radix tree to be deleted. + */ +void radix_tree_delete(struct radtree* rt); + + +/** + * Insert element into radix tree. + * @param rt: the radix tree. + * @param key: key string. + * @param len: length of key. + * @param elem: pointer to element data. + * @return NULL on failure - out of memory. + * NULL on failure - duplicate entry. + * On success the new radix node for this element. + */ +struct radnode* radix_insert(struct radtree* rt, uint8_t* k, radstrlen_t len, + void* elem); + +/** + * Delete element from radix tree. + * @param rt: the radix tree. + * @param n: radix node for that element. + * if NULL, nothing is deleted. + */ +void radix_delete(struct radtree* rt, struct radnode* n); + +/** + * Find radix element in tree. + * @param rt: the radix tree. + * @param key: key string. + * @param len: length of key. + * @return the radix node or NULL if not found. + */ +struct radnode* radix_search(struct radtree* rt, uint8_t* k, radstrlen_t len); + +/** + * Find radix element in tree, and if not found, find the closest smaller or + * equal element in the tree. + * @param rt: the radix tree. + * @param key: key string. + * @param len: length of key. + * @param result: returns the radix node or closest match (NULL if key is + * smaller than the smallest key in the tree). + * @return true if exact match, false if no match. + */ +int radix_find_less_equal(struct radtree* rt, uint8_t* k, radstrlen_t len, + struct radnode** result); + +/** + * Return the first (smallest) element in the tree. + * @param rt: the radix tree. + * @return: first node or NULL if none. + */ +struct radnode* radix_first(struct radtree* rt); + +/** + * Return the last (largest) element in the tree. + * @param rt: the radix tree. + * @return: last node or NULL if none. + */ +struct radnode* radix_last(struct radtree* rt); + +/** + * Return the next element. + * @param n: the element to go from. + * @return: next node or NULL if none. + */ +struct radnode* radix_next(struct radnode* n); + +/** + * Return the previous element. + * @param n: the element to go from. + * @return: prev node or NULL if none. + */ +struct radnode* radix_prev(struct radnode* n); + +/* + * Perform a walk through all elements of the tree. + * node: variable of type struct radnode*. + * tree: pointer to the tree. + * for(node=radix_first(tree); node; node=radix_next(node)) +*/ + +/** + * Create a binary string to represent a domain name + * @param k: string buffer to store into + * @param len: output length, initially, the max, output the result. + * @param dname: the domain name to convert, in wireformat. + * @param dlen: length of space for dname. + */ +void radname_d2r(uint8_t* k, radstrlen_t* len, const uint8_t* dname, + size_t dlen); + +/** + * Convert a binary string back to a domain name. + * @param k: the binary string. + * @param len: length of k. + * @param dname: buffer to store domain name into. + * @param dlen: length of dname (including root label). + */ +void radname_r2d(uint8_t* k, radstrlen_t len, uint8_t* dname, size_t* dlen); + +/** + * Search the radix tree using a domain name. + * The name is internally converted to a radname. + * @param rt: tree + * @param d: domain name, no compression pointers allowed. + * @param max: max length to go from d. + * @return NULL on parse error or if not found. + */ +struct radnode* radname_search(struct radtree* rt, const uint8_t* d, + size_t max); + +/** + * Find radix element in tree by domain name, and if not found, + * find the closest smaller or equal element in the tree. + * The name is internally converted to a radname (same sorting order). + * @param rt: the radix tree. + * @param d: domain name, no compression pointers allowed. + * @param max: max length to go from d. + * @param result: returns the radix node or closest match (NULL if key is + * smaller than the smallest key in the tree). + * could result in NULL on a parse error as well (with return false). + * @return true if exact match, false if no match. + */ +int radname_find_less_equal(struct radtree* rt, const uint8_t* d, size_t max, + struct radnode** result); + +/** + * Insert radix element by domain name. + * @param rt: the radix tree + * @param d: domain name, no compression pointers. + * @param max: max length from d. + * @param elem: the element pointer to insert. + * @return NULL on failure - out of memory. + * NULL on failure - duplicate entry. + * NULL on failure - parse error. + * On success the radix node for this element. + */ +struct radnode* radname_insert(struct radtree* rt, const uint8_t* d, + size_t max, void* elem); + +/** + * Delete element by domain name from radix tree. + * @param rt: the radix tree. + * @param d: the domain name. If it is not in the tree nothing happens. + * @param max: max length. + */ +void radname_delete(struct radtree* rt, const uint8_t* d, size_t max); + +/** number of bytes in common in strings */ +radstrlen_t bstr_common_ext(uint8_t* x, radstrlen_t xlen, uint8_t* y, + radstrlen_t ylen); +/** true if one is prefix of the other */ +int bstr_is_prefix_ext(uint8_t* p, radstrlen_t plen, uint8_t* x, + radstrlen_t xlen); + +#endif /* RADTREE_H */ diff --git a/usr.sbin/nsd/rbtree.c b/usr.sbin/nsd/rbtree.c index c7d384fe66d..80f7bbb2b6e 100644 --- a/usr.sbin/nsd/rbtree.c +++ b/usr.sbin/nsd/rbtree.c @@ -1,7 +1,7 @@ /* * rbtree.c -- generic red black tree * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -551,39 +551,3 @@ rbtree_previous(rbnode_t *node) } return node; } - - -/** - * Given an rbtree "root" node, find the first node under that tree in - * postorder. - */ -rbnode_t * -rbtree_postorder_first(rbnode_t *root) -{ - rbnode_t *node = root; - do { - while (node->left != RBTREE_NULL) { - node = node->left; - } - while ((node->left == RBTREE_NULL) && - (node->right != RBTREE_NULL)) { - node = node->right; - } - } while (node->left != node->right); - return node; -} - - -/** - * Given any node in an rbtree, find the next node in postorder. - */ -rbnode_t * -rbtree_postorder_next(rbnode_t *node) -{ - if ((node->parent->right == RBTREE_NULL) || - (node->parent->right == node)) - node = node->parent; - else - node = rbtree_postorder_first(node->parent->right); - return node; -} diff --git a/usr.sbin/nsd/rbtree.h b/usr.sbin/nsd/rbtree.h index 028d715397c..a381cf0788f 100644 --- a/usr.sbin/nsd/rbtree.h +++ b/usr.sbin/nsd/rbtree.h @@ -1,7 +1,7 @@ /* * rbtree.h -- generic red-black tree * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -60,8 +60,6 @@ rbnode_t *rbtree_first(rbtree_t *rbtree); rbnode_t *rbtree_last(rbtree_t *rbtree); rbnode_t *rbtree_next(rbnode_t *rbtree); rbnode_t *rbtree_previous(rbnode_t *rbtree); -rbnode_t *rbtree_postorder_first(rbnode_t *root); -rbnode_t *rbtree_postorder_next(rbnode_t *node); #define RBTREE_WALK(rbtree, k, d) \ for((rbtree)->_node = rbtree_first(rbtree);\ diff --git a/usr.sbin/nsd/rdata.h b/usr.sbin/nsd/rdata.h index 0cddb16e0f4..0da8eab6ec0 100644 --- a/usr.sbin/nsd/rdata.h +++ b/usr.sbin/nsd/rdata.h @@ -1,7 +1,7 @@ /* * rdata.h -- RDATA conversion functions. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * diff --git a/usr.sbin/nsd/region-allocator.h b/usr.sbin/nsd/region-allocator.h index a047a1dfc5a..7a7bfe96f2a 100644 --- a/usr.sbin/nsd/region-allocator.h +++ b/usr.sbin/nsd/region-allocator.h @@ -1,7 +1,7 @@ /* * region-allocator.h -- region based memory allocator. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -129,6 +129,10 @@ void region_dump_stats(region_type *region, FILE *out); /* get size of recyclebin */ size_t region_get_recycle_size(region_type* region); +/* get size of region memory in use */ +size_t region_get_mem(region_type* region); +/* get size of region memory unused */ +size_t region_get_mem_unused(region_type* region); /* Debug print REGION statistics to LOG. */ void region_log_stats(region_type *region); diff --git a/usr.sbin/nsd/remote.c b/usr.sbin/nsd/remote.c new file mode 100644 index 00000000000..d4858d2202a --- /dev/null +++ b/usr.sbin/nsd/remote.c @@ -0,0 +1,1943 @@ +/* + * remote.c - remote control for the NSD daemon. + * + * Copyright (c) 2008, NLnet Labs. All rights reserved. + * + * This software is open source. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of the NLNET LABS nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * \file + * + * This file contains the remote control functionality for the daemon. + * The remote control can be performed using either the commandline + * nsd-control tool, or a SSLv3/TLS capable web browser. + * The channel is secured using SSLv3 or TLSv1, and certificates. + * Both the server and the client(control tool) have their own keys. + */ +#include "config.h" +#ifdef HAVE_SSL + +#ifdef HAVE_OPENSSL_SSL_H +#include "openssl/ssl.h" +#endif +#ifdef HAVE_OPENSSL_ERR_H +#include <openssl/err.h> +#endif +#include <ctype.h> +#include <unistd.h> +#include <assert.h> +#include <fcntl.h> +#ifndef USE_MINI_EVENT +#include <event.h> +#else +#include "mini_event.h" +#endif +#include "remote.h" +#include "util.h" +#include "xfrd.h" +#include "xfrd-notify.h" +#include "xfrd-tcp.h" +#include "nsd.h" +#include "options.h" +#include "difffile.h" +#include "xfrd.h" +#include "ipc.h" + +#ifdef HAVE_SYS_TYPES_H +# include <sys/types.h> +#endif +#ifdef HAVE_NETDB_H +#include <netdb.h> +#endif + +/** number of seconds timeout on incoming remote control handshake */ +#define REMOTE_CONTROL_TCP_TIMEOUT 120 + +/** repattern to master or slave */ +#define REPAT_SLAVE 1 +#define REPAT_MASTER 2 + +/** if you want zero to be inhibited in stats output. + * it omits zeroes for types that have no acronym and unused-rcodes */ +const int inhibit_zero = 1; + +/** + * a busy control command connection, SSL state + * Defined here to keep the definition private, and keep SSL out of the .h + */ +struct rc_state { + /** the next item in list */ + struct rc_state* next, *prev; + /* if the event was added to the event_base */ + int event_added; + /** the commpoint */ + struct event c; + /** timeout for this state */ + struct timeval tval; + /** in the handshake part */ + enum { rc_none, rc_hs_read, rc_hs_write } shake_state; + /** the ssl state */ + SSL* ssl; + /** the rc this is part of */ + struct daemon_remote* rc; + /** stats list next item */ + struct rc_state* stats_next; + /** stats list indicator (0 is not part of stats list, 1 is stats, + * 2 is stats_noreset. */ + int in_stats_list; +}; + +/** + * list of events for accepting connections + */ +struct acceptlist { + struct acceptlist* next; + int event_added; + struct event c; +}; + +/** + * The remote control state. + */ +struct daemon_remote { + /** the master process for this remote control */ + struct xfrd_state* xfrd; + /** commpoints for accepting remote control connections */ + struct acceptlist* accept_list; + /** number of active commpoints that are handling remote control */ + int active; + /** max active commpoints */ + int max_active; + /** current commpoints busy; double linked, malloced */ + struct rc_state* busy_list; + /** commpoints waiting for stats to complete (also in busy_list) */ + struct rc_state* stats_list; + /** last time stats was reported */ + struct timeval stats_time, boot_time; + /** the SSL context for creating new SSL streams */ + SSL_CTX* ctx; +}; + +/** + * Print fixed line of text over ssl connection in blocking mode + * @param ssl: print to + * @param text: the text. + * @return false on connection failure. + */ +static int ssl_print_text(SSL* ssl, const char* text); + +/** + * printf style printing to the ssl connection + * @param ssl: the SSL connection to print to. Blocking. + * @param format: printf style format string. + * @return success or false on a network failure. + */ +static int ssl_printf(SSL* ssl, const char* format, ...) + ATTR_FORMAT(printf, 2, 3); + +/** + * Read until \n is encountered + * If SSL signals EOF, the string up to then is returned (without \n). + * @param ssl: the SSL connection to read from. blocking. + * @param buf: buffer to read to. + * @param max: size of buffer. + * @return false on connection failure. + */ +static int ssl_read_line(SSL* ssl, char* buf, size_t max); + +/** perform the accept of a new remote control connection */ +static void +remote_accept_callback(int fd, short event, void* arg); + +/** perform remote control */ +static void +remote_control_callback(int fd, short event, void* arg); + + +/** ---- end of private defines ---- **/ + + +/** log ssl crypto err */ +static void +log_crypto_err(const char* str) +{ + /* error:[error code]:[library name]:[function name]:[reason string] */ + char buf[128]; + unsigned long e; + ERR_error_string_n(ERR_get_error(), buf, sizeof(buf)); + log_msg(LOG_ERR, "%s crypto %s", str, buf); + while( (e=ERR_get_error()) ) { + ERR_error_string_n(e, buf, sizeof(buf)); + log_msg(LOG_ERR, "and additionally crypto %s", buf); + } +} + +#ifdef BIND8_STATS +/** subtract timers and the values do not overflow or become negative */ +static void +timeval_subtract(struct timeval* d, const struct timeval* end, + const struct timeval* start) +{ +#ifndef S_SPLINT_S + time_t end_usec = end->tv_usec; + d->tv_sec = end->tv_sec - start->tv_sec; + if(end_usec < start->tv_usec) { + end_usec += 1000000; + d->tv_sec--; + } + d->tv_usec = end_usec - start->tv_usec; +#endif +} +#endif /* BIND8_STATS */ + +struct daemon_remote* +daemon_remote_create(nsd_options_t* cfg) +{ + char* s_cert; + char* s_key; + struct daemon_remote* rc = (struct daemon_remote*)xalloc_zero( + sizeof(*rc)); + rc->max_active = 10; + assert(cfg->control_enable); + + /* init SSL library */ + ERR_load_crypto_strings(); + ERR_load_SSL_strings(); + OpenSSL_add_all_algorithms(); + (void)SSL_library_init(); + + rc->ctx = SSL_CTX_new(SSLv23_server_method()); + if(!rc->ctx) { + log_crypto_err("could not SSL_CTX_new"); + free(rc); + return NULL; + } + /* no SSLv2 because has defects */ + if(!(SSL_CTX_set_options(rc->ctx, SSL_OP_NO_SSLv2) & SSL_OP_NO_SSLv2)){ + log_crypto_err("could not set SSL_OP_NO_SSLv2"); + daemon_remote_delete(rc); + return NULL; + } + s_cert = cfg->server_cert_file; + s_key = cfg->server_key_file; + VERBOSITY(2, (LOG_INFO, "setup SSL certificates")); + if (!SSL_CTX_use_certificate_file(rc->ctx,s_cert,SSL_FILETYPE_PEM)) { + log_msg(LOG_ERR, "Error for server-cert-file: %s", s_cert); + log_crypto_err("Error in SSL_CTX use_certificate_file"); + goto setup_error; + } + if(!SSL_CTX_use_PrivateKey_file(rc->ctx,s_key,SSL_FILETYPE_PEM)) { + log_msg(LOG_ERR, "Error for server-key-file: %s", s_key); + log_crypto_err("Error in SSL_CTX use_PrivateKey_file"); + goto setup_error; + } + if(!SSL_CTX_check_private_key(rc->ctx)) { + log_msg(LOG_ERR, "Error for server-key-file: %s", s_key); + log_crypto_err("Error in SSL_CTX check_private_key"); + goto setup_error; + } + if(!SSL_CTX_load_verify_locations(rc->ctx, s_cert, NULL)) { + log_crypto_err("Error setting up SSL_CTX verify locations"); + setup_error: + daemon_remote_delete(rc); + return NULL; + } + SSL_CTX_set_client_CA_list(rc->ctx, SSL_load_client_CA_file(s_cert)); + SSL_CTX_set_verify(rc->ctx, SSL_VERIFY_PEER, NULL); + + /* and try to open the ports */ + if(!daemon_remote_open_ports(rc, cfg)) { + log_msg(LOG_ERR, "could not open remote control port"); + goto setup_error; + } + + if(gettimeofday(&rc->boot_time, NULL) == -1) + log_msg(LOG_ERR, "gettimeofday: %s", strerror(errno)); + rc->stats_time = rc->boot_time; + + return rc; +} + +void daemon_remote_close(struct daemon_remote* rc) +{ + struct rc_state* p, *np; + struct acceptlist* h, *nh; + if(!rc) return; + + /* close listen sockets */ + h = rc->accept_list; + while(h) { + nh = h->next; + if(h->event_added) + event_del(&h->c); + close(h->c.ev_fd); + free(h); + h = nh; + } + rc->accept_list = NULL; + + /* close busy connection sockets */ + p = rc->busy_list; + while(p) { + np = p->next; + if(p->event_added) + event_del(&p->c); + if(p->ssl) + SSL_free(p->ssl); + close(p->c.ev_fd); + free(p); + p = np; + } + rc->busy_list = NULL; + rc->active = 0; +} + +void daemon_remote_delete(struct daemon_remote* rc) +{ + if(!rc) return; + daemon_remote_close(rc); + if(rc->ctx) { + SSL_CTX_free(rc->ctx); + } + free(rc); +} + +static int +create_tcp_accept_sock(struct addrinfo* addr, int* noproto) +{ +#if defined(SO_REUSEADDR) || (defined(INET6) && (defined(IPV6_V6ONLY) || defined(IPV6_USE_MIN_MTU) || defined(IPV6_MTU))) + int on = 1; +#endif + int s; + *noproto = 0; + if ((s = socket(addr->ai_family, addr->ai_socktype, 0)) == -1) { +#if defined(INET6) + if (addr->ai_family == AF_INET6 && + errno == EAFNOSUPPORT) { + *noproto = 1; + log_msg(LOG_WARNING, "fallback to TCP4, no IPv6: not supported"); + return -1; + } +#endif /* INET6 */ + log_msg(LOG_ERR, "can't create a socket: %s", strerror(errno)); + return -1; + } +#ifdef SO_REUSEADDR + if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) { + log_msg(LOG_ERR, "setsockopt(..., SO_REUSEADDR, ...) failed: %s", strerror(errno)); + } +#endif /* SO_REUSEADDR */ +#if defined(INET6) && defined(IPV6_V6ONLY) + if (addr->ai_family == AF_INET6 && + setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on)) < 0) + { + log_msg(LOG_ERR, "setsockopt(..., IPV6_V6ONLY, ...) failed: %s", strerror(errno)); + return -1; + } +#endif + /* set it nonblocking */ + /* (StevensUNP p463), if tcp listening socket is blocking, then + it may block in accept, even if select() says readable. */ + if (fcntl(s, F_SETFL, O_NONBLOCK) == -1) { + log_msg(LOG_ERR, "cannot fcntl tcp: %s", strerror(errno)); + } + /* Bind it... */ + if (bind(s, (struct sockaddr *)addr->ai_addr, addr->ai_addrlen) != 0) { + log_msg(LOG_ERR, "can't bind tcp socket: %s", strerror(errno)); + return -1; + } + /* Listen to it... */ + if (listen(s, TCP_BACKLOG_REMOTE) == -1) { + log_msg(LOG_ERR, "can't listen: %s", strerror(errno)); + return -1; + } + return s; +} + +/** + * Add and open a new control port + * @param rc: rc with result list. + * @param ip: ip str + * @param nr: port nr + * @param noproto_is_err: if lack of protocol support is an error. + * @return false on failure. + */ +static int +add_open(struct daemon_remote* rc, const char* ip, int nr, int noproto_is_err) +{ + struct addrinfo hints; + struct addrinfo* res; + struct acceptlist* hl; + int noproto; + int fd, r; + char port[15]; + snprintf(port, sizeof(port), "%d", nr); + port[sizeof(port)-1]=0; + memset(&hints, 0, sizeof(hints)); + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST; + if((r = getaddrinfo(ip, port, &hints, &res)) != 0 || !res) { + log_msg(LOG_ERR, "control interface %s:%s getaddrinfo: %s %s", + ip?ip:"default", port, gai_strerror(r), +#ifdef EAI_SYSTEM + r==EAI_SYSTEM?(char*)strerror(errno):"" +#else + "" +#endif + ); + return 0; + } + + /* open fd */ + fd = create_tcp_accept_sock(res, &noproto); + freeaddrinfo(res); + if(fd == -1 && noproto) { + if(!noproto_is_err) + return 1; /* return success, but do nothing */ + log_msg(LOG_ERR, "cannot open control interface %s %d : " + "protocol not supported", ip, nr); + return 0; + } + if(fd == -1) { + log_msg(LOG_ERR, "cannot open control interface %s %d", ip, nr); + return 0; + } + + /* alloc */ + hl = (struct acceptlist*)xalloc_zero(sizeof(*hl)); + hl->next = rc->accept_list; + rc->accept_list = hl; + + hl->c.ev_fd = fd; + hl->event_added = 0; + return 1; +} + +int +daemon_remote_open_ports(struct daemon_remote* rc, nsd_options_t* cfg) +{ + assert(cfg->control_enable && cfg->control_port); + if(cfg->control_interface) { + ip_address_option_t* p; + for(p = cfg->control_interface; p; p = p->next) { + if(!add_open(rc, p->address, cfg->control_port, 1)) { + return 0; + } + } + } else { + /* defaults */ + if(cfg->do_ip6 && !add_open(rc, "::1", cfg->control_port, 0)) { + return 0; + } + if(cfg->do_ip4 && + !add_open(rc, "127.0.0.1", cfg->control_port, 1)) { + return 0; + } + } + return 1; +} + +void +daemon_remote_attach(struct daemon_remote* rc, struct xfrd_state* xfrd) +{ + int fd; + struct acceptlist* p; + if(!rc) return; + rc->xfrd = xfrd; + for(p = rc->accept_list; p; p = p->next) { + /* add event */ + fd = p->c.ev_fd; + event_set(&p->c, fd, EV_PERSIST|EV_READ, remote_accept_callback, + rc); + if(event_base_set(xfrd->event_base, &p->c) != 0) + log_msg(LOG_ERR, "remote: cannot set event_base"); + if(event_add(&p->c, NULL) != 0) + log_msg(LOG_ERR, "remote: cannot add event"); + p->event_added = 1; + } +} + +static void +remote_accept_callback(int fd, short event, void* arg) +{ + struct daemon_remote *rc = (struct daemon_remote*)arg; + struct sockaddr_storage addr; + socklen_t addrlen; + int newfd; + struct rc_state* n; + + if (!(event & EV_READ)) { + return; + } + + /* perform the accept */ + addrlen = sizeof(addr); + newfd = accept(fd, (struct sockaddr*)&addr, &addrlen); + if(newfd == -1) { + if ( errno != EINTR + && errno != EWOULDBLOCK +#ifdef ECONNABORTED + && errno != ECONNABORTED +#endif /* ECONNABORTED */ +#ifdef EPROTO + && errno != EPROTO +#endif /* EPROTO */ + ) { + log_msg(LOG_ERR, "accept failed: %s", strerror(errno)); + } + return; + } + + /* create new commpoint unless we are servicing already */ + if(rc->active >= rc->max_active) { + log_msg(LOG_WARNING, "drop incoming remote control: " + "too many connections"); + close_exit: + close(newfd); + return; + } + if (fcntl(newfd, F_SETFL, O_NONBLOCK) == -1) { + log_msg(LOG_ERR, "fcntl failed: %s", strerror(errno)); + goto close_exit; + } + + /* setup state to service the remote control command */ + n = (struct rc_state*)calloc(1, sizeof(*n)); + if(!n) { + log_msg(LOG_ERR, "out of memory"); + goto close_exit; + } + + n->tval.tv_sec = REMOTE_CONTROL_TCP_TIMEOUT; + n->tval.tv_usec = 0L; + + event_set(&n->c, newfd, EV_PERSIST|EV_TIMEOUT|EV_READ, + remote_control_callback, n); + if(event_base_set(xfrd->event_base, &n->c) != 0) + log_msg(LOG_ERR, "remote_accept: cannot set event_base"); + if(event_add(&n->c, &n->tval) != 0) + log_msg(LOG_ERR, "remote_accept: cannot add event"); + n->event_added = 1; + + if(2 <= verbosity) { + char s[128]; + addr2str(&addr, s, sizeof(s)); + VERBOSITY(2, (LOG_INFO, "new control connection from %s", s)); + } + + n->shake_state = rc_hs_read; + n->ssl = SSL_new(rc->ctx); + if(!n->ssl) { + log_crypto_err("could not SSL_new"); + event_del(&n->c); + free(n); + goto close_exit; + } + SSL_set_accept_state(n->ssl); + (void)SSL_set_mode(n->ssl, SSL_MODE_AUTO_RETRY); + if(!SSL_set_fd(n->ssl, newfd)) { + log_crypto_err("could not SSL_set_fd"); + event_del(&n->c); + SSL_free(n->ssl); + free(n); + goto close_exit; + } + + n->rc = rc; + n->stats_next = NULL; + n->in_stats_list = 0; + n->prev = NULL; + n->next = rc->busy_list; + if(n->next) n->next->prev = n; + rc->busy_list = n; + rc->active ++; + + /* perform the first nonblocking read already, for windows, + * so it can return wouldblock. could be faster too. */ + remote_control_callback(newfd, EV_READ, n); +} + +/** delete from list */ +static void +state_list_remove_elem(struct rc_state** list, struct rc_state* todel) +{ + if(todel->prev) todel->prev->next = todel->next; + else *list = todel->next; + if(todel->next) todel->next->prev = todel->prev; +} + +/** delete from stats list */ +static void +stats_list_remove_elem(struct rc_state** list, struct rc_state* todel) +{ + while(*list) { + if( (*list) == todel) { + *list = (*list)->stats_next; + return; + } + list = &(*list)->stats_next; + } +} + +/** decrease active count and remove commpoint from busy list */ +static void +clean_point(struct daemon_remote* rc, struct rc_state* s) +{ + if(s->in_stats_list) + stats_list_remove_elem(&rc->stats_list, s); + state_list_remove_elem(&rc->busy_list, s); + rc->active --; + if(s->event_added) + event_del(&s->c); + if(s->ssl) { + SSL_shutdown(s->ssl); + SSL_free(s->ssl); + } + close(s->c.ev_fd); + free(s); +} + +static int +ssl_print_text(SSL* ssl, const char* text) +{ + int r; + if(!ssl) + return 0; + ERR_clear_error(); + if((r=SSL_write(ssl, text, (int)strlen(text))) <= 0) { + if(SSL_get_error(ssl, r) == SSL_ERROR_ZERO_RETURN) { + VERBOSITY(2, (LOG_WARNING, "in SSL_write, peer " + "closed connection")); + return 0; + } + log_crypto_err("could not SSL_write"); + return 0; + } + return 1; +} + +/** print text over the ssl connection */ +static int +ssl_print_vmsg(SSL* ssl, const char* format, va_list args) +{ + char msg[1024]; + vsnprintf(msg, sizeof(msg), format, args); + return ssl_print_text(ssl, msg); +} + +/** printf style printing to the ssl connection */ +static int +ssl_printf(SSL* ssl, const char* format, ...) +{ + va_list args; + int ret; + va_start(args, format); + ret = ssl_print_vmsg(ssl, format, args); + va_end(args); + return ret; +} + +static int +ssl_read_line(SSL* ssl, char* buf, size_t max) +{ + int r; + size_t len = 0; + if(!ssl) + return 0; + while(len < max) { + ERR_clear_error(); + if((r=SSL_read(ssl, buf+len, 1)) <= 0) { + if(SSL_get_error(ssl, r) == SSL_ERROR_ZERO_RETURN) { + buf[len] = 0; + return 1; + } + log_crypto_err("could not SSL_read"); + return 0; + } + if(buf[len] == '\n') { + /* return string without \n */ + buf[len] = 0; + return 1; + } + len++; + } + buf[max-1] = 0; + log_msg(LOG_ERR, "control line too long (%d): %s", (int)max, buf); + return 0; +} + +/** skip whitespace, return new pointer into string */ +static char* +skipwhite(char* str) +{ + /* EOS \0 is not a space */ + while( isspace(*str) ) + str++; + return str; +} + +/** send the OK to the control client */ +static void +send_ok(SSL* ssl) +{ + (void)ssl_printf(ssl, "ok\n"); +} + +/** get zone argument (if any) or NULL, false on error */ +static int +get_zone_arg(SSL* ssl, xfrd_state_t* xfrd, char* arg, + zone_options_t** zo) +{ + const dname_type* dname; + if(!arg[0]) { + /* no argument present, return NULL */ + *zo = NULL; + return 1; + } + dname = dname_parse(xfrd->region, arg); + if(!dname) { + ssl_printf(ssl, "error cannot parse zone name '%s'\n", arg); + *zo = NULL; + return 0; + } + *zo = zone_options_find(xfrd->nsd->options, dname); + region_recycle(xfrd->region, (void*)dname, dname_total_size(dname)); + if(!*zo) { + ssl_printf(ssl, "error zone %s not configured\n", arg); + return 0; + } + return 1; +} + +/** do the stop command */ +static void +do_stop(SSL* ssl, xfrd_state_t* xfrd) +{ + xfrd->need_to_send_shutdown = 1; + + if(!(xfrd->ipc_handler_flags&EV_WRITE)) { + ipc_xfrd_set_listening(xfrd, EV_PERSIST|EV_READ|EV_WRITE); + } + + send_ok(ssl); +} + +/** do the log_reopen command, it only needs reload_now */ +static void +do_log_reopen(SSL* ssl, xfrd_state_t* xfrd) +{ + xfrd_set_reload_now(xfrd); + send_ok(ssl); +} + +/** do the reload command */ +static void +do_reload(SSL* ssl, xfrd_state_t* xfrd, char* arg) +{ + zone_options_t* zo; + if(!get_zone_arg(ssl, xfrd, arg, &zo)) + return; + task_new_check_zonefiles(xfrd->nsd->task[xfrd->nsd->mytask], + xfrd->last_task, zo?(const dname_type*)zo->node.key:NULL); + xfrd_set_reload_now(xfrd); + send_ok(ssl); +} + +/** do the write command */ +static void +do_write(SSL* ssl, xfrd_state_t* xfrd, char* arg) +{ + zone_options_t* zo; + if(!get_zone_arg(ssl, xfrd, arg, &zo)) + return; + task_new_write_zonefiles(xfrd->nsd->task[xfrd->nsd->mytask], + xfrd->last_task, zo?(const dname_type*)zo->node.key:NULL); + xfrd_set_reload_now(xfrd); + send_ok(ssl); +} + +/** do the notify command */ +static void +do_notify(SSL* ssl, xfrd_state_t* xfrd, char* arg) +{ + zone_options_t* zo; + if(!get_zone_arg(ssl, xfrd, arg, &zo)) + return; + if(zo) { + struct notify_zone_t* n = (struct notify_zone_t*)rbtree_search( + xfrd->notify_zones, (const dname_type*)zo->node.key); + if(n) { + xfrd_notify_start(n); + send_ok(ssl); + } else { + ssl_printf(ssl, "error zone does not have notify\n"); + } + } else { + struct notify_zone_t* n; + RBTREE_FOR(n, struct notify_zone_t*, xfrd->notify_zones) { + xfrd_notify_start(n); + } + send_ok(ssl); + } +} + +/** do the transfer command */ +static void +do_transfer(SSL* ssl, xfrd_state_t* xfrd, char* arg) +{ + zone_options_t* zo; + xfrd_zone_t* zone; + if(!get_zone_arg(ssl, xfrd, arg, &zo)) + return; + if(zo) { + zone = (xfrd_zone_t*)rbtree_search(xfrd->zones, (const + dname_type*)zo->node.key); + if(zone) { + xfrd_handle_notify_and_start_xfr(zone, NULL); + send_ok(ssl); + } else { + ssl_printf(ssl, "error zone not slave\n"); + } + } else { + RBTREE_FOR(zone, xfrd_zone_t*, xfrd->zones) { + xfrd_handle_notify_and_start_xfr(zone, NULL); + } + ssl_printf(ssl, "ok, %u zones\n", (unsigned)xfrd->zones->count); + } +} + +/** force transfer a zone */ +static void +force_transfer_zone(xfrd_zone_t* zone) +{ + /* if in TCP transaction, stop it immediately. */ + if(zone->tcp_conn != -1) + xfrd_tcp_release(xfrd->tcp_set, zone); + else if(zone->zone_handler.ev_fd != -1) + xfrd_udp_release(zone); + /* pretend we not longer have it and force any + * zone to be downloaded (even same serial, w AXFR) */ + zone->soa_disk_acquired = 0; + xfrd_handle_notify_and_start_xfr(zone, NULL); +} + +/** do the force transfer command */ +static void +do_force_transfer(SSL* ssl, xfrd_state_t* xfrd, char* arg) +{ + zone_options_t* zo; + xfrd_zone_t* zone; + if(!get_zone_arg(ssl, xfrd, arg, &zo)) + return; + if(zo) { + zone = (xfrd_zone_t*)rbtree_search(xfrd->zones, (const + dname_type*)zo->node.key); + if(zone) { + force_transfer_zone(zone); + send_ok(ssl); + } else { + ssl_printf(ssl, "error zone not slave\n"); + } + } else { + RBTREE_FOR(zone, xfrd_zone_t*, xfrd->zones) { + force_transfer_zone(zone); + } + ssl_printf(ssl, "ok, %u zones\n", (unsigned)xfrd->zones->count); + } +} + +static int +print_soa_status(SSL* ssl, const char* str, xfrd_soa_t* soa, time_t acq) +{ + if(acq) { + if(!ssl_printf(ssl, " %s: \"%u since %s\"\n", str, + (unsigned)ntohl(soa->serial), xfrd_pretty_time(acq))) + return 0; + } else { + if(!ssl_printf(ssl, " %s: none\n", str)) + return 0; + } + return 1; +} + +/** print zonestatus for one domain */ +static int +print_zonestatus(SSL* ssl, xfrd_state_t* xfrd, zone_options_t* zo) +{ + xfrd_zone_t* xz = (xfrd_zone_t*)rbtree_search(xfrd->zones, + (const dname_type*)zo->node.key); + struct notify_zone_t* nz = (struct notify_zone_t*)rbtree_search( + xfrd->notify_zones, (const dname_type*)zo->node.key); + if(!ssl_printf(ssl, "zone: %s\n", zo->name)) + return 0; + if(!zo->part_of_config) { + if(!ssl_printf(ssl, " pattern: %s\n", zo->pattern->pname)) + return 0; + } + if(nz) { + if(nz->is_waiting) { + if(!ssl_printf(ssl, " notify: \"waiting-for-fd\"\n")) + return 0; + } else if(nz->notify_send_enable) { + if(!ssl_printf(ssl, " notify: \"sent try %d " + "to %s with serial %u\"\n", nz->notify_retry, + nz->notify_current->ip_address_spec, + (unsigned)ntohl(nz->current_soa->serial))) + return 0; + } + } + if(!xz) { + if(!ssl_printf(ssl, " state: master\n")) + return 0; + return 1; + } + if(!ssl_printf(ssl, " state: %s\n", + (xz->state == xfrd_zone_ok)?"ok":( + (xz->state == xfrd_zone_expired)?"expired":"refreshing"))) + return 0; + if(!print_soa_status(ssl, "served-serial", &xz->soa_nsd, + xz->soa_nsd_acquired)) + return 0; + if(!print_soa_status(ssl, "commit-serial", &xz->soa_disk, + xz->soa_disk_acquired)) + return 0; + if(xz->round_num != -1) { + if(!print_soa_status(ssl, "notified-serial", &xz->soa_notified, + xz->soa_notified_acquired)) + return 0; + } + + /* UDP */ + if(xz->udp_waiting) { + if(!ssl_printf(ssl, " transfer: \"waiting-for-UDP-fd\"\n")) + return 0; + } else if(xz->zone_handler.ev_fd != -1 && xz->tcp_conn == -1) { + if(!ssl_printf(ssl, " transfer: \"sent UDP to %s\"\n", + xz->master->ip_address_spec)) + return 0; + } + + /* TCP */ + if(xz->tcp_waiting) { + if(!ssl_printf(ssl, " transfer: \"waiting-for-TCP-fd\"\n")) + return 0; + } else if(xz->tcp_conn != -1) { + if(!ssl_printf(ssl, " transfer: \"TCP connected to %s\"\n", + xz->master->ip_address_spec)) + return 0; + } + + return 1; +} + +/** do the zonestatus command */ +static void +do_zonestatus(SSL* ssl, xfrd_state_t* xfrd, char* arg) +{ + zone_options_t* zo; + if(!get_zone_arg(ssl, xfrd, arg, &zo)) + return; + if(zo) (void)print_zonestatus(ssl, xfrd, zo); + else { + RBTREE_FOR(zo, zone_options_t*, + xfrd->nsd->options->zone_options) { + if(!print_zonestatus(ssl, xfrd, zo)) + return; + } + } +} + +/** do the verbosity command */ +static void +do_verbosity(SSL* ssl, char* str) +{ + int val = atoi(str); + if(strcmp(str, "") == 0) { + ssl_printf(ssl, "verbosity %d\n", verbosity); + return; + } + if(val == 0 && strcmp(str, "0") != 0) { + ssl_printf(ssl, "error in verbosity number syntax: %s\n", str); + return; + } + verbosity = val; + task_new_set_verbosity(xfrd->nsd->task[xfrd->nsd->mytask], + xfrd->last_task, val); + xfrd_set_reload_now(xfrd); + send_ok(ssl); +} + +/** find second argument, modifies string */ +static int +find_arg2(SSL* ssl, char* arg, char** arg2) +{ + char* as = strrchr(arg, ' '); + if(as) { + as[0]=0; + *arg2 = as+1; + while(isspace(*as) && as > arg) + as--; + as[0]=0; + return 1; + } + ssl_printf(ssl, "error could not find next argument " + "after %s\n", arg); + return 0; +} + +/** do the status command */ +static void +do_status(SSL* ssl, xfrd_state_t* xfrd) +{ + if(!ssl_printf(ssl, "version: %s\n", PACKAGE_VERSION)) + return; + if(!ssl_printf(ssl, "verbosity: %d\n", verbosity)) + return; +#ifdef RATELIMIT + if(!ssl_printf(ssl, "ratelimit: %d\n", + (int)xfrd->nsd->options->rrl_ratelimit)) + return; +#else + (void)xfrd; +#endif +} + +/** do the stats command */ +static void +do_stats(struct daemon_remote* rc, int peek, struct rc_state* rs) +{ +#ifdef BIND8_STATS + /* queue up to get stats after a reload is done (to gather statistics + * from the servers) */ + assert(!rs->in_stats_list); + if(peek) rs->in_stats_list = 2; + else rs->in_stats_list = 1; + rs->stats_next = rc->stats_list; + rc->stats_list = rs; + /* block the tcp waiting for the reload */ + event_del(&rs->c); + rs->event_added = 0; + /* force a reload */ + xfrd_set_reload_now(xfrd); +#else + (void)rc; (void)peek; + (void)ssl_printf(rs->ssl, "error no stats enabled at compile time\n"); +#endif /* BIND8_STATS */ +} + +/** do the addzone command */ +static void +do_addzone(SSL* ssl, xfrd_state_t* xfrd, char* arg) +{ + zone_options_t* zopt; + char* arg2 = NULL; + if(!find_arg2(ssl, arg, &arg2)) + return; + + /* if we add it to the xfrd now, then xfrd could download AXFR and + * store it and the NSD-reload would see it in the difffile before + * it sees the add-config task. + */ + /* thus: AXFRs and IXFRs must store the pattern name in the + * difffile, so that it can be added when the AXFR or IXFR is seen. + */ + + /* check that the pattern exists */ + if(!rbtree_search(xfrd->nsd->options->patterns, arg2)) { + (void)ssl_printf(ssl, "error pattern does not exist\n"); + return; + } + + /* add to zonelist and adds to config in memory */ + zopt = zone_list_add(xfrd->nsd->options, arg, arg2); + if(!zopt) { + /* also dname parse error here */ + (void)ssl_printf(ssl, "error could not add zonelist entry\n"); + return; + } + /* make addzone task and schedule reload */ + task_new_add_zone(xfrd->nsd->task[xfrd->nsd->mytask], + xfrd->last_task, arg, arg2); + xfrd_set_reload_now(xfrd); + /* add to xfrd - notify (for master and slaves) */ + init_notify_send(xfrd->notify_zones, xfrd->region, zopt); + /* add to xfrd - slave */ + if(zone_is_slave(zopt)) { + xfrd_init_slave_zone(xfrd, zopt); + } + + send_ok(ssl); +} + +/** do the delzone command */ +static void +do_delzone(SSL* ssl, xfrd_state_t* xfrd, char* arg) +{ + const dname_type* dname; + zone_options_t* zopt; + + dname = dname_parse(xfrd->region, arg); + if(!dname) { + (void)ssl_printf(ssl, "error cannot parse zone name\n"); + return; + } + + /* see if we have the zone in question */ + zopt = zone_options_find(xfrd->nsd->options, dname); + if(!zopt) { + region_recycle(xfrd->region, (void*)dname, + dname_total_size(dname)); + /* nothing to do */ + if(!ssl_printf(ssl, "warning zone %s not present\n", arg)) + return; + send_ok(ssl); + return; + } + + /* see if it can be deleted */ + if(zopt->part_of_config) { + region_recycle(xfrd->region, (void*)dname, + dname_total_size(dname)); + (void)ssl_printf(ssl, "error zone defined in nsd.conf, " + "cannot delete it in this manner: remove it from " + "nsd.conf yourself and repattern\n"); + return; + } + + /* create deletion task */ + task_new_del_zone(xfrd->nsd->task[xfrd->nsd->mytask], + xfrd->last_task, dname); + xfrd_set_reload_now(xfrd); + /* delete it in xfrd */ + if(zone_is_slave(zopt)) { + xfrd_del_slave_zone(xfrd, dname); + } + xfrd_del_notify(xfrd, dname); + /* delete from config */ + zone_list_del(xfrd->nsd->options, zopt); + + region_recycle(xfrd->region, (void*)dname, dname_total_size(dname)); + send_ok(ssl); +} + +/** remove TSIG key from config and add task so that reload does too */ +static void remove_key(xfrd_state_t* xfrd, const char* kname) +{ + /* add task before deletion because the name string could be deleted */ + task_new_del_key(xfrd->nsd->task[xfrd->nsd->mytask], xfrd->last_task, + kname); + key_options_remove(xfrd->nsd->options, kname); + xfrd_set_reload_now(xfrd); /* this is executed when the current control + command ends, thus the entire config changes are bunched up */ +} + +/** add TSIG key to config and add task so that reload does too */ +static void add_key(xfrd_state_t* xfrd, key_options_t* k) +{ + key_options_add_modify(xfrd->nsd->options, k); + task_new_add_key(xfrd->nsd->task[xfrd->nsd->mytask], xfrd->last_task, + k); + xfrd_set_reload_now(xfrd); +} + +/** check if keys have changed */ +static void repat_keys(xfrd_state_t* xfrd, nsd_options_t* newopt) +{ + nsd_options_t* oldopt = xfrd->nsd->options; + key_options_t* k; + /* find deleted keys */ + k = (key_options_t*)rbtree_first(oldopt->keys); + while((rbnode_t*)k != RBTREE_NULL) { + key_options_t* next = (key_options_t*)rbtree_next( + (rbnode_t*)k); + if(!key_options_find(newopt, k->name)) + remove_key(xfrd, k->name); + k = next; + } + /* find added or changed keys */ + RBTREE_FOR(k, key_options_t*, newopt->keys) { + key_options_t* origk = key_options_find(oldopt, k->name); + if(!origk) + add_key(xfrd, k); + else if(!key_options_equal(k, origk)) + add_key(xfrd, k); + } +} + +/** find zone given the implicit pattern */ +static const dname_type* +parse_implicit_name(xfrd_state_t* xfrd,const char* pname) +{ + if(strncmp(pname, PATTERN_IMPLICIT_MARKER, + strlen(PATTERN_IMPLICIT_MARKER)) != 0) + return NULL; + return dname_parse(xfrd->region, pname + + strlen(PATTERN_IMPLICIT_MARKER)); +} + +/** remove cfgzone and add task so that reload does too */ +static void +remove_cfgzone(xfrd_state_t* xfrd, const char* pname) +{ + /* dname and find the zone for the implicit pattern */ + zone_options_t* zopt = NULL; + const dname_type* dname = parse_implicit_name(xfrd, pname); + if(!dname) { + /* should have a parseable name, but it did not */ + return; + } + + /* find the zone entry for the implicit pattern */ + zopt = zone_options_find(xfrd->nsd->options, dname); + if(!zopt) { + /* this should not happen; implicit pattern has zone entry */ + region_recycle(xfrd->region, (void*)dname, + dname_total_size(dname)); + return; + } + + /* create deletion task */ + task_new_del_zone(xfrd->nsd->task[xfrd->nsd->mytask], + xfrd->last_task, dname); + xfrd_set_reload_now(xfrd); + /* delete it in xfrd */ + if(zone_is_slave(zopt)) { + xfrd_del_slave_zone(xfrd, dname); + } + xfrd_del_notify(xfrd, dname); + + /* delete from zoneoptions */ + zone_options_delete(xfrd->nsd->options, zopt); + + /* recycle parsed dname */ + region_recycle(xfrd->region, (void*)dname, dname_total_size(dname)); +} + +/** add cfgzone and add task so that reload does too */ +static void +add_cfgzone(xfrd_state_t* xfrd, const char* pname) +{ + /* add to our zonelist */ + zone_options_t* zopt = zone_options_create(xfrd->nsd->options->region); + if(!zopt) + return; + zopt->part_of_config = 1; + zopt->name = region_strdup(xfrd->nsd->options->region, + pname + strlen(PATTERN_IMPLICIT_MARKER)); + zopt->pattern = pattern_options_find(xfrd->nsd->options, pname); + if(!zopt->name || !zopt->pattern) + return; + if(!nsd_options_insert_zone(xfrd->nsd->options, zopt)) { + log_msg(LOG_ERR, "bad domain name or duplicate zone '%s' " + "pattern %s", zopt->name, pname); + } + + /* make addzone task and schedule reload */ + task_new_add_zone(xfrd->nsd->task[xfrd->nsd->mytask], + xfrd->last_task, zopt->name, pname); + xfrd_set_reload_now(xfrd); + /* add to xfrd - notify (for master and slaves) */ + init_notify_send(xfrd->notify_zones, xfrd->region, zopt); + /* add to xfrd - slave */ + if(zone_is_slave(zopt)) { + xfrd_init_slave_zone(xfrd, zopt); + } +} + +/** remove pattern and add task so that reload does too */ +static void +remove_pat(xfrd_state_t* xfrd, const char* name) +{ + /* add task before deletion, because name-string could be deleted */ + task_new_del_pattern(xfrd->nsd->task[xfrd->nsd->mytask], + xfrd->last_task, name); + pattern_options_remove(xfrd->nsd->options, name); + xfrd_set_reload_now(xfrd); +} + +/** add pattern and add task so that reload does too */ +static void +add_pat(xfrd_state_t* xfrd, pattern_options_t* p) +{ + pattern_options_add_modify(xfrd->nsd->options, p); + task_new_add_pattern(xfrd->nsd->task[xfrd->nsd->mytask], + xfrd->last_task, p); + xfrd_set_reload_now(xfrd); +} + +/** interrupt zones that are using changed or removed patterns */ +static void +repat_interrupt_zones(xfrd_state_t* xfrd, nsd_options_t* newopt) +{ + /* if masterlist changed: + * interrupt slave zone (UDP or TCP) transfers. + * slave zones reset master to start of list. + */ + xfrd_zone_t* xz; + struct notify_zone_t* nz; + RBTREE_FOR(xz, xfrd_zone_t*, xfrd->zones) { + pattern_options_t* oldp = xz->zone_options->pattern; + pattern_options_t* newp = pattern_options_find(newopt, + oldp->pname); + if(!newp || !acl_list_equal(oldp->request_xfr, + newp->request_xfr)) { + /* interrupt transfer */ + if(xz->tcp_conn != -1) { + xfrd_tcp_release(xfrd->tcp_set, xz); + xfrd_set_refresh_now(xz); + } else if(xz->zone_handler.ev_fd != -1) { + xfrd_udp_release(xz); + xfrd_set_refresh_now(xz); + } + xz->master = 0; + xz->master_num = 0; + xz->next_master = -1; + xz->round_num = 0; /* fresh set of retries */ + } + } + /* if notify list changed: + * interrupt notify that is busy. + * reset notify to start of list. (clear all other reset_notify) + */ + RBTREE_FOR(nz, struct notify_zone_t*, xfrd->notify_zones) { + pattern_options_t* oldp = nz->options->pattern; + pattern_options_t* newp = pattern_options_find(newopt, + oldp->pname); + if(!newp || !acl_list_equal(oldp->notify, newp->notify)) { + /* interrupt notify */ + if(nz->notify_send_enable) { + notify_disable(nz); + /* set to restart the notify after the + * pattern has been changed. */ + nz->notify_restart = 2; + } else { + nz->notify_restart = 1; + } + } else { + nz->notify_restart = 0; + } + } +} + +/** for notify, after the pattern changes, restart the affected notifies */ +static void +repat_interrupt_notify_start(xfrd_state_t* xfrd) +{ + struct notify_zone_t* nz; + RBTREE_FOR(nz, struct notify_zone_t*, xfrd->notify_zones) { + if(nz->notify_restart) { + if(nz->notify_current) + nz->notify_current = nz->options->pattern->notify; + if(nz->notify_restart == 2) { + if(nz->notify_restart) + xfrd_notify_start(nz); + } + } + } +} + +/** check if patterns have changed */ +static void +repat_patterns(xfrd_state_t* xfrd, nsd_options_t* newopt) +{ + /* zones that use changed patterns must have: + * - their AXFR/IXFR interrupted: try again, acl may have changed. + * if the old master/key still exists, OK, fix master-numptrs and + * keep going. Otherwise, stop xfer and reset TSIG. + * - send NOTIFY reset to start of NOTIFY list (and TSIG reset). + */ + nsd_options_t* oldopt = xfrd->nsd->options; + pattern_options_t* p; + int search_zones = 0; + + repat_interrupt_zones(xfrd, newopt); + /* find deleted patterns */ + p = (pattern_options_t*)rbtree_first(oldopt->patterns); + while((rbnode_t*)p != RBTREE_NULL) { + pattern_options_t* next = (pattern_options_t*)rbtree_next( + (rbnode_t*)p); + if(!pattern_options_find(newopt, p->pname)) { + if(p->implicit) { + /* first remove its zone */ + VERBOSITY(1, (LOG_INFO, "zone removed from config: %s", p->pname + strlen(PATTERN_IMPLICIT_MARKER))); + remove_cfgzone(xfrd, p->pname); + } + remove_pat(xfrd, p->pname); + } + p = next; + } + /* find added or changed patterns */ + RBTREE_FOR(p, pattern_options_t*, newopt->patterns) { + pattern_options_t* origp = pattern_options_find(oldopt, + p->pname); + if(!origp) { + /* no zones can use it, no zone_interrupt needed */ + add_pat(xfrd, p); + if(p->implicit) { + VERBOSITY(1, (LOG_INFO, "zone added to config: %s", p->pname + strlen(PATTERN_IMPLICIT_MARKER))); + add_cfgzone(xfrd, p->pname); + } + } else if(!pattern_options_equal(p, origp)) { + uint8_t newstate = 0; + if (p->request_xfr && !origp->request_xfr) { + newstate = REPAT_SLAVE; + } else if (!p->request_xfr && origp->request_xfr) { + newstate = REPAT_MASTER; + } + add_pat(xfrd, p); + if (p->implicit && newstate) { + const dname_type* dname = + parse_implicit_name(xfrd, p->pname); + if (dname) { + if (newstate == REPAT_SLAVE) { + zone_options_t* zopt = + zone_options_find( + oldopt, dname); + if (zopt) { + xfrd_init_slave_zone( + xfrd, zopt); + } + } else if (newstate == REPAT_MASTER) { + xfrd_del_slave_zone(xfrd, + dname); + } + region_recycle(xfrd->region, + (void*)dname, + dname_total_size(dname)); + } + } else if(!p->implicit && newstate) { + /* search all zones with this pattern */ + search_zones = 1; + origp->xfrd_flags = newstate; + } + } + } + if (search_zones) { + zone_options_t* zone_opt; + /* search in oldopt because 1) it contains zonelist zones, + * and 2) you need oldopt(existing) to call xfrd_init */ + RBTREE_FOR(zone_opt, zone_options_t*, oldopt->zone_options) { + pattern_options_t* oldp = zone_opt->pattern; + if (!oldp->implicit) { + if (oldp->xfrd_flags == REPAT_SLAVE) { + /* xfrd needs stable reference so get + * it from the oldopt(modified) tree */ + xfrd_init_slave_zone(xfrd, zone_opt); + } else if (oldp->xfrd_flags == REPAT_MASTER) { + xfrd_del_slave_zone(xfrd, + (const dname_type*) + zone_opt->node.key); + } + oldp->xfrd_flags = 0; + } + } + } + repat_interrupt_notify_start(xfrd); +} + +/** true if options are different that can be set via repat. */ +static int +repat_options_changed(xfrd_state_t* xfrd, nsd_options_t* newopt) +{ +#ifdef RATELIMIT + if(xfrd->nsd->options->rrl_ratelimit != newopt->rrl_ratelimit) + return 1; + if(xfrd->nsd->options->rrl_whitelist_ratelimit != newopt->rrl_whitelist_ratelimit) + return 1; + if(xfrd->nsd->options->rrl_slip != newopt->rrl_slip) + return 1; +#else + (void)xfrd; (void)newopt; +#endif + return 0; +} + +/** check if global options have changed */ +static void +repat_options(xfrd_state_t* xfrd, nsd_options_t* newopt) +{ + if(repat_options_changed(xfrd, newopt)) { + /* update our options */ +#ifdef RATELIMIT + xfrd->nsd->options->rrl_ratelimit = newopt->rrl_ratelimit; + xfrd->nsd->options->rrl_whitelist_ratelimit = newopt->rrl_whitelist_ratelimit; + xfrd->nsd->options->rrl_slip = newopt->rrl_slip; +#endif + task_new_opt_change(xfrd->nsd->task[xfrd->nsd->mytask], + xfrd->last_task, newopt); + xfrd_set_reload_now(xfrd); + } +} + +/** print errors over ssl, gets pointer-to-pointer to ssl, so it can set + * the pointer to NULL on failure and stop printing */ +static void +print_ssl_cfg_err(void* arg, const char* str) +{ + SSL** ssl = (SSL**)arg; + if(!*ssl) return; + if(!ssl_printf(*ssl, "%s", str)) + *ssl = NULL; /* failed, stop printing */ +} + +/** do the repattern command: reread config file and apply keys, patterns */ +static void +do_repattern(SSL* ssl, xfrd_state_t* xfrd) +{ + region_type* region = region_create(xalloc, free); + nsd_options_t* opt; + const char* cfgfile = xfrd->nsd->options->configfile; + + /* check chroot and configfile, if possible to reread */ + if(xfrd->nsd->chrootdir) { + size_t l = strlen(xfrd->nsd->chrootdir); + while(l>0 && xfrd->nsd->chrootdir[l-1] == '/') + --l; + if(strncmp(xfrd->nsd->chrootdir, cfgfile, l) != 0) { + ssl_printf(ssl, "error %s is not relative to %s: " + "chroot prevents reread of config\n", + cfgfile, xfrd->nsd->chrootdir); + region_destroy(region); + return; + } + cfgfile += l; + } + + ssl_printf(ssl, "reconfig start, read %s\n", cfgfile); + opt = nsd_options_create(region); + if(!parse_options_file(opt, cfgfile, &print_ssl_cfg_err, &ssl)) { + /* error already printed */ + region_destroy(region); + return; + } + /* check for differences in TSIG keys and patterns, and apply, + * first the keys, so that pattern->keyptr can be set right. */ + repat_keys(xfrd, opt); + repat_patterns(xfrd, opt); + repat_options(xfrd, opt); + send_ok(ssl); + region_destroy(region); +} + +/** do the serverpid command: printout pid of server process */ +static void +do_serverpid(SSL* ssl, xfrd_state_t* xfrd) +{ + (void)ssl_printf(ssl, "%u\n", (unsigned)xfrd->reload_pid); +} + +/** check for name with end-of-string, space or tab after it */ +static int +cmdcmp(char* p, const char* cmd, size_t len) +{ + return strncmp(p,cmd,len)==0 && (p[len]==0||p[len]==' '||p[len]=='\t'); +} + +/** execute a remote control command */ +static void +execute_cmd(struct daemon_remote* rc, SSL* ssl, char* cmd, struct rc_state* rs) +{ + char* p = skipwhite(cmd); + /* compare command */ + if(cmdcmp(p, "stop", 4)) { + do_stop(ssl, rc->xfrd); + } else if(cmdcmp(p, "reload", 6)) { + do_reload(ssl, rc->xfrd, skipwhite(p+6)); + } else if(cmdcmp(p, "write", 5)) { + do_write(ssl, rc->xfrd, skipwhite(p+5)); + } else if(cmdcmp(p, "status", 6)) { + do_status(ssl, rc->xfrd); + } else if(cmdcmp(p, "stats_noreset", 13)) { + do_stats(rc, 1, rs); + } else if(cmdcmp(p, "stats", 5)) { + do_stats(rc, 0, rs); + } else if(cmdcmp(p, "log_reopen", 10)) { + do_log_reopen(ssl, rc->xfrd); + } else if(cmdcmp(p, "addzone", 7)) { + do_addzone(ssl, rc->xfrd, skipwhite(p+7)); + } else if(cmdcmp(p, "delzone", 7)) { + do_delzone(ssl, rc->xfrd, skipwhite(p+7)); + } else if(cmdcmp(p, "notify", 6)) { + do_notify(ssl, rc->xfrd, skipwhite(p+6)); + } else if(cmdcmp(p, "transfer", 8)) { + do_transfer(ssl, rc->xfrd, skipwhite(p+8)); + } else if(cmdcmp(p, "force_transfer", 14)) { + do_force_transfer(ssl, rc->xfrd, skipwhite(p+14)); + } else if(cmdcmp(p, "zonestatus", 10)) { + do_zonestatus(ssl, rc->xfrd, skipwhite(p+10)); + } else if(cmdcmp(p, "verbosity", 9)) { + do_verbosity(ssl, skipwhite(p+9)); + } else if(cmdcmp(p, "repattern", 9)) { + do_repattern(ssl, rc->xfrd); + } else if(cmdcmp(p, "reconfig", 8)) { + do_repattern(ssl, rc->xfrd); + } else if(cmdcmp(p, "serverpid", 9)) { + do_serverpid(ssl, rc->xfrd); + } else { + (void)ssl_printf(ssl, "error unknown command '%s'\n", p); + } +} + +/** handle remote control request */ +static void +handle_req(struct daemon_remote* rc, struct rc_state* s, SSL* ssl) +{ + int r; + char pre[10]; + char magic[8]; + char buf[1024]; + if (fcntl(s->c.ev_fd, F_SETFL, 0) == -1) { /* set blocking */ + log_msg(LOG_ERR, "cannot fcntl rc: %s", strerror(errno)); + } + + /* try to read magic UBCT[version]_space_ string */ + ERR_clear_error(); + if((r=SSL_read(ssl, magic, (int)sizeof(magic)-1)) <= 0) { + if(SSL_get_error(ssl, r) == SSL_ERROR_ZERO_RETURN) + return; + log_crypto_err("could not SSL_read"); + return; + } + magic[7] = 0; + if( r != 7 || strncmp(magic, "NSDCT", 5) != 0) { + VERBOSITY(2, (LOG_INFO, "control connection has bad header")); + /* probably wrong tool connected, ignore it completely */ + return; + } + + /* read the command line */ + if(!ssl_read_line(ssl, buf, sizeof(buf))) { + return; + } + snprintf(pre, sizeof(pre), "NSDCT%d ", NSD_CONTROL_VERSION); + if(strcmp(magic, pre) != 0) { + VERBOSITY(2, (LOG_INFO, "control connection had bad " + "version %s, cmd: %s", magic, buf)); + ssl_printf(ssl, "error version mismatch\n"); + return; + } + VERBOSITY(2, (LOG_INFO, "control cmd: %s", buf)); + + /* figure out what to do */ + execute_cmd(rc, ssl, buf, s); +} + +static void +remote_control_callback(int fd, short event, void* arg) +{ + struct rc_state* s = (struct rc_state*)arg; + struct daemon_remote* rc = s->rc; + int r; + if( (event&EV_TIMEOUT) ) { + log_msg(LOG_ERR, "remote control timed out"); + clean_point(rc, s); + return; + } + /* (continue to) setup the SSL connection */ + ERR_clear_error(); + r = SSL_do_handshake(s->ssl); + if(r != 1) { + int r2 = SSL_get_error(s->ssl, r); + if(r2 == SSL_ERROR_WANT_READ) { + if(s->shake_state == rc_hs_read) { + /* try again later */ + return; + } + s->shake_state = rc_hs_read; + event_del(&s->c); + event_set(&s->c, fd, EV_PERSIST|EV_TIMEOUT|EV_READ, + remote_control_callback, s); + if(event_base_set(xfrd->event_base, &s->c) != 0) + log_msg(LOG_ERR, "remote_accept: cannot set event_base"); + if(event_add(&s->c, &s->tval) != 0) + log_msg(LOG_ERR, "remote_accept: cannot add event"); + return; + } else if(r2 == SSL_ERROR_WANT_WRITE) { + if(s->shake_state == rc_hs_write) { + /* try again later */ + return; + } + s->shake_state = rc_hs_write; + event_del(&s->c); + event_set(&s->c, fd, EV_PERSIST|EV_TIMEOUT|EV_WRITE, + remote_control_callback, s); + if(event_base_set(xfrd->event_base, &s->c) != 0) + log_msg(LOG_ERR, "remote_accept: cannot set event_base"); + if(event_add(&s->c, &s->tval) != 0) + log_msg(LOG_ERR, "remote_accept: cannot add event"); + return; + } else { + if(r == 0) + log_msg(LOG_ERR, "remote control connection closed prematurely"); + log_crypto_err("remote control failed ssl"); + clean_point(rc, s); + return; + } + } + s->shake_state = rc_none; + + /* once handshake has completed, check authentication */ + if(SSL_get_verify_result(s->ssl) == X509_V_OK) { + X509* x = SSL_get_peer_certificate(s->ssl); + if(!x) { + VERBOSITY(2, (LOG_INFO, "remote control connection " + "provided no client certificate")); + clean_point(rc, s); + return; + } + VERBOSITY(3, (LOG_INFO, "remote control connection authenticated")); + X509_free(x); + } else { + VERBOSITY(2, (LOG_INFO, "remote control connection failed to " + "authenticate with client certificate")); + clean_point(rc, s); + return; + } + + /* if OK start to actually handle the request */ + handle_req(rc, s, s->ssl); + + if(!s->in_stats_list) { + VERBOSITY(3, (LOG_INFO, "remote control operation completed")); + clean_point(rc, s); + } +} + +#ifdef BIND8_STATS +static const char* +opcode2str(int o) +{ + switch(o) { + case OPCODE_QUERY: return "QUERY"; + case OPCODE_IQUERY: return "IQUERY"; + case OPCODE_STATUS: return "STATUS"; + case OPCODE_NOTIFY: return "NOTIFY"; + case OPCODE_UPDATE: return "UPDATE"; + default: return "OTHER"; + } +} + +/** print long number */ +static int +print_longnum(SSL* ssl, char* desc, uint64_t x) +{ + if(x > (uint64_t)1024*1024*1024) { + /* more than a Gb */ + size_t front = (size_t)(x / (uint64_t)1000000); + size_t back = (size_t)(x % (uint64_t)1000000); + return ssl_printf(ssl, "%s%u%6.6u\n", desc, + (unsigned)front, (unsigned)back); + } else { + return ssl_printf(ssl, "%s%u\n", desc, (unsigned)x); + } +} + +static void +print_stats(SSL* ssl, xfrd_state_t* xfrd, struct timeval* now) +{ + const char* rcstr[] = {"NOERROR", "FORMERR", "SERVFAIL", "NXDOMAIN", + "NOTIMP", "REFUSED", "YXDOMAIN", "YXRRSET", "NXRRSET", "NOTAUTH", + "NOTZONE", "RCODE11", "RCODE12", "RCODE13", "RCODE14", "RCODE15", + "BADVERS" + }; + size_t i; + stc_t total = 0; + struct timeval elapsed, uptime; + + /* per CPU and total */ + for(i=0; i<xfrd->nsd->child_count; i++) { + if(!ssl_printf(ssl, "server%d.queries=%u\n", (int)i, + (unsigned)xfrd->nsd->children[i].query_count)) + return; + total += xfrd->nsd->children[i].query_count; + } + if(!ssl_printf(ssl, "num.queries=%u\n", (unsigned)total)) + return; + + /* time elapsed and uptime (in seconds) */ + timeval_subtract(&uptime, now, &xfrd->nsd->rc->boot_time); + timeval_subtract(&elapsed, now, &xfrd->nsd->rc->stats_time); + if(!ssl_printf(ssl, "time.boot=%u.%6.6u\n", + (unsigned)uptime.tv_sec, (unsigned)uptime.tv_usec)) + return; + if(!ssl_printf(ssl, "time.elapsed=%u.%6.6u\n", + (unsigned)elapsed.tv_sec, (unsigned)elapsed.tv_usec)) + return; + + /* mem info, database on disksize */ + if(!print_longnum(ssl, "size.db.disk=", xfrd->nsd->st.db_disk)) + return; + if(!print_longnum(ssl, "size.db.mem=", xfrd->nsd->st.db_mem)) + return; + if(!print_longnum(ssl, "size.xfrd.mem=", region_get_mem(xfrd->region))) + return; + if(!print_longnum(ssl, "size.config.disk=", + xfrd->nsd->options->zonelist_off)) + return; + if(!print_longnum(ssl, "size.config.mem=", region_get_mem( + xfrd->nsd->options->region))) + return; + + for(i=0; i<= 255; i++) { + if(inhibit_zero && xfrd->nsd->st.qtype[i] == 0 && + strncmp(rrtype_to_string(i), "TYPE", 4) == 0) + continue; + if(!ssl_printf(ssl, "num.type.%s=%u\n", + rrtype_to_string(i), (unsigned)xfrd->nsd->st.qtype[i])) + return; + } + + /* opcode */ + for(i=0; i<6; i++) { + if(inhibit_zero && xfrd->nsd->st.opcode[i] == 0 && + i != OPCODE_QUERY) + continue; + if(!ssl_printf(ssl, "num.opcode.%s=%u\n", opcode2str(i), + (unsigned)xfrd->nsd->st.opcode[i])) + return; + } + + /* qclass */ + for(i=0; i<4; i++) { + if(inhibit_zero && xfrd->nsd->st.qclass[i] == 0 && + i != CLASS_IN) + continue; + if(!ssl_printf(ssl, "num.class.%s=%u\n", rrclass_to_string(i), + (unsigned)xfrd->nsd->st.qclass[i])) + return; + } + + /* rcode */ + for(i=0; i<17; i++) { + if(inhibit_zero && xfrd->nsd->st.rcode[i] == 0 && + i > RCODE_YXDOMAIN) /* NSD does not use larger */ + continue; + if(!ssl_printf(ssl, "num.rcode.%s=%u\n", rcstr[i], + (unsigned)xfrd->nsd->st.rcode[i])) + return; + } + + /* edns */ + if(!ssl_printf(ssl, "num.edns=%u\n", (unsigned)xfrd->nsd->st.edns)) + return; + + /* ednserr */ + if(!ssl_printf(ssl, "num.ednserr=%u\n", + (unsigned)xfrd->nsd->st.ednserr)) + return; + + /* qudp */ + if(!ssl_printf(ssl, "num.udp=%u\n", (unsigned)xfrd->nsd->st.qudp)) + return; + /* qudp6 */ + if(!ssl_printf(ssl, "num.udp6=%u\n", (unsigned)xfrd->nsd->st.qudp6)) + return; + /* ctcp */ + if(!ssl_printf(ssl, "num.tcp=%u\n", (unsigned)xfrd->nsd->st.ctcp)) + return; + /* ctcp6 */ + if(!ssl_printf(ssl, "num.tcp6=%u\n", (unsigned)xfrd->nsd->st.ctcp6)) + return; + + /* nona */ + if(!ssl_printf(ssl, "num.answer_wo_aa=%u\n", + (unsigned)xfrd->nsd->st.nona)) + return; + + /* rxerr */ + if(!ssl_printf(ssl, "num.rxerr=%u\n", (unsigned)xfrd->nsd->st.rxerr)) + return; + + /* txerr */ + if(!ssl_printf(ssl, "num.txerr=%u\n", (unsigned)xfrd->nsd->st.txerr)) + return; + + /* number of requested-axfr, number of times axfr served to clients */ + if(!ssl_printf(ssl, "num.raxfr=%u\n", (unsigned)xfrd->nsd->st.raxfr)) + return; + + /* truncated */ + if(!ssl_printf(ssl, "num.truncated=%u\n", + (unsigned)xfrd->nsd->st.truncated)) + return; + + /* dropped */ + if(!ssl_printf(ssl, "num.dropped=%u\n", + (unsigned)xfrd->nsd->st.dropped)) + return; + + /* zone statistics */ + if(!ssl_printf(ssl, "zone.master=%u\n", + (unsigned)(xfrd->notify_zones->count - xfrd->zones->count))) + return; + if(!ssl_printf(ssl, "zone.slave=%u\n", (unsigned)xfrd->zones->count)) + return; +} + +static void +clear_stats(xfrd_state_t* xfrd) +{ + size_t i; + uint64_t dbd = xfrd->nsd->st.db_disk; + uint64_t dbm = xfrd->nsd->st.db_mem; + for(i=0; i<xfrd->nsd->child_count; i++) { + xfrd->nsd->children[i].query_count = 0; + } + memset(&xfrd->nsd->st, 0, sizeof(struct nsdst)); + xfrd->nsd->st.db_disk = dbd; + xfrd->nsd->st.db_mem = dbm; +} + +void +daemon_remote_process_stats(struct daemon_remote* rc) +{ + struct rc_state* s; + struct timeval now; + if(!rc) return; + if(gettimeofday(&now, NULL) == -1) + log_msg(LOG_ERR, "gettimeofday: %s", strerror(errno)); + /* pop one and give it stats */ + while((s = rc->stats_list)) { + assert(s->in_stats_list); + print_stats(s->ssl, rc->xfrd, &now); + if(s->in_stats_list == 1) { + clear_stats(rc->xfrd); + rc->stats_time = now; + } + VERBOSITY(3, (LOG_INFO, "remote control stats printed")); + rc->stats_list = s->next; + s->in_stats_list = 0; + clean_point(rc, s); + } +} +#endif /* BIND8_STATS */ + +#endif /* HAVE_SSL */ diff --git a/usr.sbin/nsd/remote.h b/usr.sbin/nsd/remote.h new file mode 100644 index 00000000000..4317e1fec65 --- /dev/null +++ b/usr.sbin/nsd/remote.h @@ -0,0 +1,102 @@ +/* + * remote.h - remote control for the NSD daemon. + * + * Copyright (c) 2008, NLnet Labs. All rights reserved. + * + * This software is open source. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * Neither the name of the NLNET LABS nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/** + * \file + * + * This file contains the remote control functionality for the daemon. + * The remote control can be performed using either the commandline + * nsd-control tool, or a SSLv3/TLS capable web browser. + * The channel is secured using SSLv3 or TLSv1, and certificates. + * Both the server and the client(control tool) have their own keys. + */ + +#ifndef DAEMON_REMOTE_H +#define DAEMON_REMOTE_H +struct xfrd_state; +struct nsd_options; + +/* private, defined in remote.c to keep ssl.h out of this header */ +struct daemon_remote; +struct rc_state; + +/* the remote control needs less backlog than the tcp53 service */ +#define TCP_BACKLOG_REMOTE 16 /* listen() tcp backlog */ + +/** + * Create new remote control state for the daemon. + * Also setups the control port. + * @param cfg: config file with key file settings. + * @return new state, or NULL on failure. + */ +struct daemon_remote* daemon_remote_create(struct nsd_options* cfg); + +/** + * remote control state to delete. + * @param rc: state to delete. + */ +void daemon_remote_delete(struct daemon_remote* rc); + +/** + * Close remote control ports. Clears up busy connections. + * Does not delete the rc itself, or the ssl context (with its keys). + * @param rc: state to close. + */ +void daemon_remote_close(struct daemon_remote* rc); + +/** + * Open and create listening ports for remote control. + * @param rc: rc state that contains list of accept port sockets. + * @param cfg: config options. + * @return false on failure. + */ +int daemon_remote_open_ports(struct daemon_remote* rc, + struct nsd_options* cfg); + +/** + * Setup comm points for accepting remote control connections. + * @param rc: state + * @param xfrd: the process that hosts the control connection. + * The rc is attached to its event base. + */ +void daemon_remote_attach(struct daemon_remote* rc, struct xfrd_state* xfrd); + +/** + * Process statistic results and send them + * @param rc: state. + */ +void daemon_remote_process_stats(struct daemon_remote* rc); + +#endif /* DAEMON_REMOTE_H */ diff --git a/usr.sbin/nsd/rrl.h b/usr.sbin/nsd/rrl.h index 48dbb53b8cb..1ffd841664b 100644 --- a/usr.sbin/nsd/rrl.h +++ b/usr.sbin/nsd/rrl.h @@ -72,5 +72,7 @@ enum rrl_type rrlstr2type(const char* s); /** for unit test, update rrl bucket; return rate */ uint32_t rrl_update(query_type* query, uint32_t hash, uint64_t source, uint16_t flags, int32_t now, uint32_t lm); +/** set the rate limit counters, pass variables in qps */ +void rrl_set_limit(size_t lm, size_t wlm, size_t sm); #endif /* RRL_H */ diff --git a/usr.sbin/nsd/tsig-openssl.c b/usr.sbin/nsd/tsig-openssl.c index 797f7fbf2ab..6795e750f1f 100644 --- a/usr.sbin/nsd/tsig-openssl.c +++ b/usr.sbin/nsd/tsig-openssl.c @@ -1,7 +1,7 @@ /* * tsig-openssl.h -- Interface to OpenSSL for TSIG support. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * diff --git a/usr.sbin/nsd/tsig-openssl.h b/usr.sbin/nsd/tsig-openssl.h index 263c715b113..859c280c4c0 100644 --- a/usr.sbin/nsd/tsig-openssl.h +++ b/usr.sbin/nsd/tsig-openssl.h @@ -1,7 +1,7 @@ /* * tsig-openssl.h -- Interface to OpenSSL for TSIG support. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * diff --git a/usr.sbin/nsd/tsig.c b/usr.sbin/nsd/tsig.c index cf2872b563e..1844e98d9e1 100644 --- a/usr.sbin/nsd/tsig.c +++ b/usr.sbin/nsd/tsig.c @@ -1,7 +1,7 @@ /* - * tsig.h -- TSIG definitions (RFC 2845). + * tsig.c -- TSIG implementation (RFC 2845). * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -16,16 +16,18 @@ #include "tsig-openssl.h" #include "dns.h" #include "packet.h" +#include "query.h" +#include "rbtree.h" static region_type *tsig_region; struct tsig_key_table { - struct tsig_key_table *next; + rbnode_t node; /* by dname */ tsig_key_type *key; }; typedef struct tsig_key_table tsig_key_table_type; -static tsig_key_table_type *tsig_key_table; +static rbtree_t *tsig_key_table; struct tsig_algorithm_table { @@ -83,11 +85,17 @@ tsig_digest_variables(tsig_record_type *tsig, int tsig_timers_only) } } +static int +tree_dname_compare(const void* a, const void* b) +{ + return dname_compare((const dname_type*)a, (const dname_type*)b); +} + int tsig_init(region_type *region) { tsig_region = region; - tsig_key_table = NULL; + tsig_key_table = rbtree_create(region, &tree_dname_compare); tsig_algorithm_table = NULL; #if defined(HAVE_SSL) @@ -99,11 +107,31 @@ tsig_init(region_type *region) void tsig_add_key(tsig_key_type *key) { - tsig_key_table_type *entry = (tsig_key_table_type *) region_alloc( + tsig_key_table_type *entry = (tsig_key_table_type *) region_alloc_zero( tsig_region, sizeof(tsig_key_table_type)); entry->key = key; - entry->next = tsig_key_table; - tsig_key_table = entry; + entry->node.key = entry->key->name; + (void)rbtree_insert(tsig_key_table, &entry->node); +} + +void +tsig_del_key(tsig_key_type *key) +{ + tsig_key_table_type *entry; + if(!key) return; + entry = (tsig_key_table_type*)rbtree_delete(tsig_key_table, key->name); + if(!entry) return; + region_recycle(tsig_region, entry, sizeof(tsig_key_table_type)); +} + +tsig_key_type* +tsig_find_key(const dname_type* name) +{ + tsig_key_table_type* entry; + entry = (tsig_key_table_type*)rbtree_search(tsig_key_table, name); + if(entry) + return entry->key; + return NULL; } void @@ -222,11 +250,21 @@ tsig_create_record_custom(tsig_record_type *tsig, region_type *region, large_object_size, initial_cleanup_size, 0); tsig->context_region = region_create_custom(xalloc, free, chunk_size, large_object_size, initial_cleanup_size, 0); - region_add_cleanup(region, tsig_cleanup, tsig); + if(region) + region_add_cleanup(region, tsig_cleanup, tsig); tsig_init_record(tsig, NULL, NULL); } void +tsig_delete_record(tsig_record_type* tsig, region_type* region) +{ + if(region) + region_remove_cleanup(region, tsig_cleanup, tsig); + region_destroy(tsig->rr_region); + region_destroy(tsig->context_region); +} + +void tsig_init_record(tsig_record_type *tsig, tsig_algorithm_type *algorithm, tsig_key_type *key) @@ -246,7 +284,6 @@ tsig_init_record(tsig_record_type *tsig, int tsig_from_query(tsig_record_type *tsig) { - tsig_key_table_type *key_entry; tsig_key_type *key = NULL; tsig_algorithm_table_type *algorithm_entry; tsig_algorithm_type *algorithm = NULL; @@ -257,16 +294,7 @@ tsig_from_query(tsig_record_type *tsig) assert(!tsig->algorithm); assert(!tsig->key); - /* XXX: TODO: slow linear check for keyname */ - for (key_entry = tsig_key_table; - key_entry; - key_entry = key_entry->next) - { - if (dname_compare(tsig->key_name, key_entry->key->name) == 0) { - key = key_entry->key; - break; - } - } + key = (tsig_key_type*)tsig_find_key(tsig->key_name); for (algorithm_entry = tsig_algorithm_table; algorithm_entry; diff --git a/usr.sbin/nsd/tsig.h b/usr.sbin/nsd/tsig.h index f09a07e5aba..71cad7740c7 100644 --- a/usr.sbin/nsd/tsig.h +++ b/usr.sbin/nsd/tsig.h @@ -1,7 +1,7 @@ /* * tsig.h -- TSIG definitions (RFC 2845). * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -103,7 +103,7 @@ struct tsig_key { const dname_type *name; size_t size; - const uint8_t *data; + uint8_t *data; }; struct tsig_record @@ -144,6 +144,7 @@ int tsig_init(region_type *region); * Add the specified key to the TSIG key table. */ void tsig_add_key(tsig_key_type *key); +void tsig_del_key(tsig_key_type *key); /* * Add the specified algorithm to the TSIG algorithm table. @@ -172,6 +173,7 @@ void tsig_create_record(tsig_record_type* tsig, /* * Like tsig_create_record, with custom region settings. * The size params are used to customise the rr_region and context_region. + * If region is NULL, no cleanup is attached to it. */ void tsig_create_record_custom(tsig_record_type* tsig, region_type* region, @@ -180,6 +182,12 @@ void tsig_create_record_custom(tsig_record_type* tsig, size_t initial_cleanup_size); /* + * Destroy tsig record internals (the main ptr is user alloced). + * if region is nonNULL, removes cleanup. + */ +void tsig_delete_record(tsig_record_type* tsig, region_type* region); + +/* * Call this before starting to analyze or signing a sequence of * packets. * diff --git a/usr.sbin/nsd/udb.c b/usr.sbin/nsd/udb.c new file mode 100644 index 00000000000..6c0ffe7d0c0 --- /dev/null +++ b/usr.sbin/nsd/udb.c @@ -0,0 +1,2018 @@ +/* udb.c - u(micro) data base. + * By W.C.A. Wijngaards + * Copyright 2010, NLnet Labs. + * BSD, see LICENSE. + */ +#include "config.h" +#include "udb.h" +#include <string.h> +#include <errno.h> +#include <stdio.h> +#include <unistd.h> +#include <assert.h> +#include "lookup3.h" +#include "util.h" + +/* mmap and friends */ +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <sys/mman.h> + +/* for systems without, portable definition, failed-1 and async is a flag */ +#ifndef MAP_FAILED +#define MAP_FAILED ((void*)-1) +#endif +#ifndef MS_SYNC +#define MS_SYNC 0 +#endif + +/** move and fixup xl segment */ +static void move_xl_segment(void* base, udb_base* udb, udb_void xl, + udb_void n, uint64_t sz, uint64_t startseg); +/** attempt to compact the data and move free space to the end */ +static int udb_alloc_compact(void* base, udb_alloc* alloc); + +/** convert pointer to the data part to a pointer to the base of the chunk */ +static udb_void +chunk_from_dataptr(udb_void data) +{ + /* we use that sizeof(udb_chunk_d) != sizeof(udb_xl_chunk_d) and + * that xl_chunk_d is aligned on x**1024 boundaries. */ + udb_void xl = data - sizeof(udb_xl_chunk_d); + if( (xl & (UDB_ALLOC_CHUNK_SIZE-1)) == 0) + return xl; + return data - sizeof(udb_chunk_d); +} + +udb_void chunk_from_dataptr_ext(udb_void data) { + return chunk_from_dataptr(data); +} + +#ifndef NDEBUG +/** read last octet from a chunk */ +static uint8_t +chunk_get_last(void* base, udb_void chunk, int exp) +{ + return *((uint8_t*)UDB_REL(base, chunk+(1<<exp)-1)); +} +#endif + +/** write last octet of a chunk */ +static void +chunk_set_last(void* base, udb_void chunk, int exp, uint8_t value) +{ + *((uint8_t*)UDB_REL(base, chunk+(1<<exp)-1)) = value; +} + +/** create udb_base from a file descriptor (must be at start of file) */ +udb_base* +udb_base_create_fd(const char* fname, int fd, udb_walk_relptr_func walkfunc, + void* arg) +{ + uint64_t m; + udb_glob_d g; + ssize_t r; + udb_base* udb = (udb_base*)xalloc_zero(sizeof(*udb)); + if(!udb) { + log_msg(LOG_ERR, "out of memory"); + close(fd); + return NULL; + } + udb->fname = strdup(fname); + if(!udb->fname) { + log_msg(LOG_ERR, "out of memory"); + free(udb); + close(fd); + return NULL; + } + udb->walkfunc = walkfunc; + udb->walkarg = arg; + udb->fd = fd; + udb->ram_size = 1024; + udb->ram_mask = (int)udb->ram_size - 1; + udb->ram_hash = (udb_ptr**)xalloc_zero(sizeof(udb_ptr*)*udb->ram_size); + if(!udb->ram_hash) { + free(udb->fname); + free(udb); + log_msg(LOG_ERR, "out of memory"); + close(fd); + return NULL; + } + + /* read magic */ + if((r=read(fd, &m, sizeof(m))) == -1) { + log_msg(LOG_ERR, "%s: %s", fname, strerror(errno)); + goto fail; + } else if(r != (ssize_t)sizeof(m)) { + log_msg(LOG_ERR, "%s: file too short", fname); + goto fail; + } + /* TODO : what if bigendian and littleendian file, see magic */ + if(m != UDB_MAGIC) { + log_msg(LOG_ERR, "%s: wrong type of file", fname); + goto fail; + } + /* read header */ + if((r=read(fd, &g, sizeof(g))) == -1) { + log_msg(LOG_ERR, "%s: %s\n", fname, strerror(errno)); + goto fail; + } else if(r != (ssize_t)sizeof(g)) { + log_msg(LOG_ERR, "%s: file too short", fname); + goto fail; + } + if(g.version != 0) { + log_msg(LOG_ERR, "%s: unknown file version %d", fname, + (int)g.version); + goto fail; + } + if(g.hsize < UDB_HEADER_SIZE) { + log_msg(LOG_ERR, "%s: header size too small %d", fname, + (int)g.hsize); + goto fail; + } + if(g.hsize > UDB_HEADER_SIZE) { + log_msg(LOG_WARNING, "%s: header size too large %d", fname, + (int)g.hsize); + log_msg(LOG_WARNING, "attempting to continue..."); + } + if(g.clean_close != 0) { + log_msg(LOG_WARNING, "%s: not cleanly closed %d", fname, + (int)g.clean_close); + log_msg(LOG_WARNING, "attempting to continue..."); + } + /* TODO check if too large (>4g on 32bit); mmap-usage would fail */ + + /* mmap it */ + if(g.fsize < UDB_HEADER_SIZE || g.fsize < g.hsize) { + log_msg(LOG_ERR, "%s: file too short", fname); + goto fail; + } + udb->base_size = (size_t)g.fsize; + /* note the size_t casts must be there for portability, on some + * systems the layout of memory is otherwise broken. */ + udb->base = mmap(NULL, (size_t)udb->base_size, + (int)PROT_READ|PROT_WRITE, (int)MAP_SHARED, + (int)udb->fd, (off_t)0); + if(udb->base == MAP_FAILED) { + udb->base = NULL; + log_msg(LOG_ERR, "mmap(size %u) error: %s", + (unsigned)udb->base_size, strerror(errno)); + fail: + close(fd); + free(udb->fname); + free(udb->ram_hash); + free(udb); + return NULL; + } + + /* init completion */ + udb->glob_data = (udb_glob_d*)(udb->base+sizeof(uint64_t)); + r = 0; + if(udb->glob_data->dirty_alloc != udb_dirty_clean) + r = 1; + udb->alloc = udb_alloc_create(udb, (udb_alloc_d*)( + (void*)udb->glob_data+sizeof(*udb->glob_data))); + if(!udb->alloc) { + log_msg(LOG_ERR, "out of memory"); + udb_base_free(udb); + return NULL; + } + if(r) { + /* and compact now, or resume compacting */ + udb_alloc_compact(udb, udb->alloc); + udb_base_sync(udb, 1); + } + + return udb; +} + +udb_base* udb_base_create_read(const char* fname, udb_walk_relptr_func walkfunc, + void* arg) +{ + int fd = open(fname, O_RDWR); + if(fd == -1) { + log_msg(LOG_ERR, "%s: %s", fname, strerror(errno)); + return NULL; + } + return udb_base_create_fd(fname, fd, walkfunc, arg); +} + +/** init new udb_global structure */ +static void udb_glob_init_new(udb_glob_d* g) +{ + memset(g, 0, sizeof(*g)); + g->hsize = UDB_HEADER_SIZE; + g->fsize = UDB_HEADER_SIZE; +} + +/** write data to file and check result */ +static int +write_fdata(const char* fname, int fd, void* data, size_t len) +{ + ssize_t w; + if((w=write(fd, data, len)) == -1) { + log_msg(LOG_ERR, "%s: %s", fname, strerror(errno)); + close(fd); + return 0; + } else if(w != (ssize_t)len) { + log_msg(LOG_ERR, "%s: short write (disk full?)", fname); + close(fd); + return 0; + } + return 1; +} + +udb_base* udb_base_create_new(const char* fname, udb_walk_relptr_func walkfunc, + void* arg) +{ + uint64_t m; + udb_glob_d g; + udb_alloc_d a; + uint64_t endsize = UDB_HEADER_SIZE; + uint64_t endexp = 0; + int fd = open(fname, O_CREAT|O_RDWR, 0600); + if(fd == -1) { + log_msg(LOG_ERR, "%s: %s", fname, strerror(errno)); + return NULL; + } + m = UDB_MAGIC; + udb_glob_init_new(&g); + udb_alloc_init_new(&a); + + /* write new data to file (closes fd on error) */ + if(!write_fdata(fname, fd, &m, sizeof(m))) + return NULL; + if(!write_fdata(fname, fd, &g, sizeof(g))) + return NULL; + if(!write_fdata(fname, fd, &a, sizeof(a))) + return NULL; + if(!write_fdata(fname, fd, &endsize, sizeof(endsize))) + return NULL; + if(!write_fdata(fname, fd, &endexp, sizeof(endexp))) + return NULL; + /* rewind to start */ + if(lseek(fd, (off_t)0, SEEK_SET) == (off_t)-1) { + log_msg(LOG_ERR, "%s: lseek %s", fname, strerror(errno)); + close(fd); + return NULL; + } + return udb_base_create_fd(fname, fd, walkfunc, arg); +} + +/** shrink the udb base if it has unused space at the end */ +static void +udb_base_shrink(udb_base* udb, uint64_t nsize) +{ + udb->glob_data->dirty_alloc = udb_dirty_fsize; + udb->glob_data->fsize = nsize; + /* sync, does not *seem* to be required on Linux, but it is + certainly required on OpenBSD. Otherwise changed data is lost. */ + msync(udb->base, udb->base_size, MS_ASYNC); + if(ftruncate(udb->fd, (off_t)nsize) != 0) { + log_msg(LOG_ERR, "%s: ftruncate(%u) %s", udb->fname, + (unsigned)nsize, strerror(errno)); + } + udb->glob_data->dirty_alloc = udb_dirty_clean; +} + +void udb_base_close(udb_base* udb) +{ + if(!udb) + return; + if(udb->fd != -1 && udb->base && udb->alloc) { + uint64_t nsize = udb->alloc->disk->nextgrow; + if(nsize < udb->base_size) + udb_base_shrink(udb, nsize); + } + if(udb->fd != -1) { + close(udb->fd); + udb->fd = -1; + } + if(udb->base) { + if(munmap(udb->base, udb->base_size) == -1) { + log_msg(LOG_ERR, "munmap: %s", strerror(errno)); + } + udb->base = NULL; + } +} + +void udb_base_free(udb_base* udb) +{ + if(!udb) + return; + udb_base_close(udb); + udb_alloc_delete(udb->alloc); + free(udb->ram_hash); + free(udb->fname); + free(udb); +} + +void udb_base_free_keep_mmap(udb_base* udb) +{ + if(!udb) return; + if(udb->fd != -1) { + close(udb->fd); + udb->fd = -1; + } + udb->base = NULL; + udb_alloc_delete(udb->alloc); + free(udb->ram_hash); + free(udb->fname); + free(udb); +} + +void udb_base_sync(udb_base* udb, int wait) +{ + if(msync(udb->base, udb->base_size, wait?MS_SYNC:MS_ASYNC) != 0) { + log_msg(LOG_ERR, "msync(%s) error %s", + udb->fname, strerror(errno)); + } +} + +/** hash a chunk pointer */ +static uint32_t +chunk_hash_ptr(udb_void p) +{ + /* put p into an array of uint32 */ + uint32_t h[sizeof(p)/sizeof(uint32_t)]; + memcpy(&h, &p, sizeof(h)); + return hashword(h, sizeof(p)/sizeof(uint32_t), 0x8763); +} + +/** check that the given pointer is on the bucket for the given offset */ +int udb_ptr_is_on_bucket(udb_base* udb, udb_ptr* ptr, udb_void to) +{ + uint32_t i = chunk_hash_ptr(to) & udb->ram_mask; + udb_ptr* p; + assert((size_t)i < udb->ram_size); + for(p = udb->ram_hash[i]; p; p=p->next) { + if(p == ptr) + return 1; + } + return 0; +} + +/** grow the ram array */ +static void +grow_ram_hash(udb_base* udb, udb_ptr** newhash) +{ + size_t i; + size_t osize= udb->ram_size; + udb_ptr* p, *np; + udb_ptr** oldhash = udb->ram_hash; + udb->ram_size *= 2; + udb->ram_mask <<= 1; + udb->ram_mask |= 1; + udb->ram_hash = newhash; + /* have to link in every element in the old list into the new list*/ + for(i=0; i<osize; i++) { + p = oldhash[i]; + while(p) { + np = p->next; + /* link into newhash */ + p->prev=NULL; + p->next=newhash[chunk_hash_ptr(p->data)&udb->ram_mask]; + if(p->next) p->next->prev = p; + /* go to next element of oldhash */ + p = np; + } + } + free(oldhash); +} + +void udb_base_link_ptr(udb_base* udb, udb_ptr* ptr) +{ + uint32_t i = chunk_hash_ptr(ptr->data) & udb->ram_mask; + assert((size_t)i < udb->ram_size); +#ifdef UDB_CHECK + assert(udb_valid_dataptr(udb, ptr->data)); /* must be to whole chunk*/ +#endif + udb->ram_num++; + if(udb->ram_num == udb->ram_size && udb->ram_size<(size_t)0xefffffff) { + /* grow the array, if allocation succeeds */ + udb_ptr** newram = (udb_ptr**)xalloc_zero(sizeof(udb_ptr*)* + udb->ram_size*2); + if(newram) { + grow_ram_hash(udb, newram); + } + } + ptr->prev = NULL; + ptr->next = udb->ram_hash[i]; + udb->ram_hash[i] = ptr; + if(ptr->next) + ptr->next->prev = ptr; +} + +void udb_base_unlink_ptr(udb_base* udb, udb_ptr* ptr) +{ + assert(ptr->data); +#ifdef UDB_CHECK + assert(udb_valid_dataptr(udb, ptr->data)); /* ptr must be inited */ + assert(udb_ptr_is_on_bucket(udb, ptr, ptr->data)); +#endif + udb->ram_num--; + if(ptr->next) + ptr->next->prev = ptr->prev; + if(ptr->prev) + ptr->prev->next = ptr->next; + else { + uint32_t i = chunk_hash_ptr(ptr->data) & udb->ram_mask; + assert((size_t)i < udb->ram_size); + udb->ram_hash[i] = ptr->next; + } +} + +/** change a set of ram ptrs to a new value */ +static void +udb_base_ram_ptr_edit(udb_base* udb, udb_void old, udb_void newd) +{ + uint32_t io = chunk_hash_ptr(old) & udb->ram_mask; + udb_ptr* p, *np; + /* edit them and move them into the new position */ + p = udb->ram_hash[io]; + while(p) { + np = p->next; + if(p->data == old) { + udb_base_unlink_ptr(udb, p); + p->data = newd; + udb_base_link_ptr(udb, p); + } + p = np; + } +} + +udb_rel_ptr* udb_base_get_userdata(udb_base* udb) +{ + return &udb->glob_data->user_global; +} + +void udb_base_set_userdata(udb_base* udb, udb_void user) +{ +#ifdef UDB_CHECK + if(user) { assert(udb_valid_dataptr(udb, user)); } +#endif + udb_rel_ptr_set(udb->base, &udb->glob_data->user_global, user); +} + +void udb_base_set_userflags(udb_base* udb, uint8_t v) +{ + udb->glob_data->userflags = v; +} + +uint8_t udb_base_get_userflags(udb_base* udb) +{ + return udb->glob_data->userflags; +} + +/** re-mmap the udb to specified size */ +static void* +udb_base_remap(udb_base* udb, udb_alloc* alloc, uint64_t nsize) +{ + void* nb; + /* for use with valgrind, do not use mremap, but the other version */ +#ifdef MREMAP_MAYMOVE + nb = mremap(udb->base, udb->base_size, nsize, MREMAP_MAYMOVE); + if(nb == MAP_FAILED) { + log_msg(LOG_ERR, "mremap(%s, size %u) error %s", + udb->fname, (unsigned)nsize, strerror(errno)); + return 0; + } +#else /* !HAVE MREMAP */ + /* use munmap-mmap to simulate mremap */ + if(munmap(udb->base, udb->base_size) != 0) { + log_msg(LOG_ERR, "munmap(%s) error %s", + udb->fname, strerror(errno)); + } + /* provide hint for new location */ + /* note the size_t casts must be there for portability, on some + * systems the layout of memory is otherwise broken. */ + nb = mmap(udb->base, (size_t)nsize, (int)PROT_READ|PROT_WRITE, + (int)MAP_SHARED, (int)udb->fd, (off_t)0); + /* retry the mmap without basept in case of ENOMEM (FreeBSD8), + * the kernel can then try to mmap it at a different location + * where more memory is available */ + if(nb == MAP_FAILED && errno == ENOMEM) { + nb = mmap(NULL, (size_t)nsize, (int)PROT_READ|PROT_WRITE, + (int)MAP_SHARED, (int)udb->fd, (off_t)0); + } + if(nb == MAP_FAILED) { + log_msg(LOG_ERR, "mmap(%s, size %u) error %s", + udb->fname, (unsigned)nsize, strerror(errno)); + udb->base = NULL; + return 0; + } +#endif /* HAVE MREMAP */ + if(nb != udb->base) { + /* fix up realpointers in udb and alloc */ + /* but mremap may have been nice and not move the base */ + udb->base = nb; + udb->glob_data = (udb_glob_d*)(nb+sizeof(uint64_t)); + /* use passed alloc pointer because the udb->alloc may not + * be initialized yet */ + alloc->disk = (udb_alloc_d*)((void*)udb->glob_data + +sizeof(*udb->glob_data)); + } + udb->base_size = nsize; + return nb; +} + +void +udb_base_remap_process(udb_base* udb) +{ + /* assume that fsize is still accessible */ + udb_base_remap(udb, udb->alloc, udb->glob_data->fsize); +} + +/** grow file to specified size and re-mmap, return new base */ +static void* +udb_base_grow_and_remap(udb_base* udb, uint64_t nsize) +{ + /* grow file by writing a single zero at that spot, the + * rest is filled in with zeroes. */ + uint8_t z = 0; + ssize_t w; + + assert(nsize > 0); + udb->glob_data->dirty_alloc = udb_dirty_fsize; +#ifdef HAVE_PWRITE + if((w=pwrite(udb->fd, &z, sizeof(z), (off_t)(nsize-1))) == -1) { +#else + if(lseek(udb->fd, (off_t)(nsize-1), SEEK_SET) == -1) { + log_msg(LOG_ERR, "fseek %s: %s", udb->fname, strerror(errno)); + return 0; + } + if((w=write(udb->fd, &z, sizeof(z))) == -1) { +#endif + log_msg(LOG_ERR, "grow(%s, size %u) error %s", + udb->fname, (unsigned)nsize, strerror(errno)); + return 0; + } else if(w != (ssize_t)sizeof(z)) { + log_msg(LOG_ERR, "grow(%s, size %u) failed (disk full?)", + udb->fname, (unsigned)nsize); + return 0; + } + udb->glob_data->fsize = nsize; + udb->glob_data->dirty_alloc = udb_dirty_clean; + return udb_base_remap(udb, udb->alloc, nsize); +} + +int udb_exp_size(uint64_t a) +{ + /* find enclosing value such that 2**x >= a */ + int x = 0; + uint64_t i = a; + assert(a != 0); + + i --; + /* could optimise this with uint8* access, depends on endianness */ + /* first whole bytes */ + while( (i&(~(uint64_t)0xff)) ) { + i >>= 8; + x += 8; + } + /* now details */ + while(i) { + i >>= 1; + x ++; + } + assert( ((uint64_t)1<<x) >= a); + assert( x==0 || ((uint64_t)1<<(x-1)) < a); + return x; +} + +int udb_exp_offset(uint64_t o) +{ + /* this means measuring the number of 0 bits on the right */ + /* so, if exp zero bits then (o&(2**x-1))==0 */ + int x = 0; + uint64_t i = o; + assert(o != 0); + /* first whole bytes */ + while( (i&(uint64_t)0xff) == 0) { + i >>= 8; + x += 8; + } + /* now details */ + while( (i&(uint64_t)0x1) == 0) { + i >>= 1; + x ++; + } + assert( o % ((uint64_t)1<<x) == 0); + assert( o % ((uint64_t)1<<(x+1)) != 0); + return x; +} + +void udb_alloc_init_new(udb_alloc_d* a) +{ + assert(UDB_HEADER_SIZE % UDB_ALLOC_CHUNK_MINSIZE == 0); + memset(a, 0, sizeof(*a)); + /* set new allocations after header, as if allocated in a sequence + * of minsize allocations */ + a->nextgrow = UDB_HEADER_SIZE; +} + +/** fsck the file size, false if failed and file is useless */ +static int +fsck_fsize(udb_base* udb, udb_alloc* alloc) +{ + off_t realsize; + log_msg(LOG_WARNING, "udb-fsck %s: file size wrong", udb->fname); + realsize = lseek(udb->fd, (off_t)0, SEEK_END); + if(realsize == (off_t)-1) { + log_msg(LOG_ERR, "lseek(%s): %s", udb->fname, strerror(errno)); + return 0; + } + udb->glob_data->fsize = (uint64_t)realsize; + if(!udb_base_remap(udb, alloc, (uint64_t)realsize)) + return 0; + udb->glob_data->dirty_alloc = udb_dirty_clean; + log_msg(LOG_WARNING, "udb-fsck %s: file size fixed (sync)", udb->fname); + udb_base_sync(udb, 1); + return 1; +} + +/** regenerate freelist add a new free chunk, return next todo */ +static udb_void +regen_free(void* base, udb_void c, int exp, udb_alloc_d* regen) +{ + udb_free_chunk_d* cp = UDB_FREE_CHUNK(c); + uint64_t esz = (uint64_t)1<<exp; + if(exp < UDB_ALLOC_CHUNK_MINEXP || exp > UDB_ALLOC_CHUNKS_MAX) { + return 0; + } + cp->type = udb_chunk_type_free; + cp->flags = 0; + chunk_set_last(base, c, exp, (uint8_t)exp); + cp->prev = 0; + cp->next = regen->free[exp-UDB_ALLOC_CHUNK_MINEXP]; + if(cp->next) + UDB_FREE_CHUNK(cp->next)->prev = c; + regen->stat_free += esz; + return c + esz; +} + +/** regenerate xl chunk, return next todo */ +static udb_void +regen_xl(void* base, udb_void c, udb_alloc_d* regen) +{ + udb_xl_chunk_d* cp = UDB_XL_CHUNK(c); + uint64_t xlsz = cp->size; + if( (xlsz&(UDB_ALLOC_CHUNK_SIZE-1)) != 0) { + return 0; + } + if( (c&(UDB_ALLOC_CHUNK_SIZE-1)) != 0) { + return 0; + } + /* fixup end-size and end-expmarker */ + regen->stat_alloc += xlsz; + return c + xlsz; +} + +/** regenerate data chunk, return next todo */ +static udb_void +regen_data(void* base, udb_void c, int exp, udb_alloc_d* regen) +{ + uint64_t esz = (uint64_t)1<<exp; + if(exp < UDB_ALLOC_CHUNK_MINEXP || exp > UDB_ALLOC_CHUNKS_MAX) { + return 0; + } + chunk_set_last(base, c, exp, (uint8_t)exp); + regen->stat_alloc += esz; + return c + esz; +} + +/** regenerate a relptr structure inside a data segment */ +static void +regen_relptr_func(void* base, udb_rel_ptr* rp, void* arg) +{ + udb_void* a = (udb_void*)arg; + /* ignore 0 pointers */ + if(!rp->data) + return; + + /* edit relptrs that point to oldmoved to point to newmoved. */ + if(rp->data == a[0]) + rp->data = a[1]; + + /* regenerate relptr lists, add this item to the relptr list for + * the data that it points to */ + udb_rel_ptr_link(base, rp, rp->data); +} + +/** regenerate the relptrs store in this data segment */ +static void +regen_its_ptrs(void* base, udb_base* udb, udb_chunk_d* atp, + void* data, uint64_t dsz, udb_void rb_old, udb_void rb_new) +{ + udb_void arg[2]; + arg[0] = rb_old; arg[1] = rb_new; + /* walk through the structs here and put them on their respective + * relptr lists */ + (*udb->walkfunc)(base, udb->walkarg, atp->type, data, dsz, + ®en_relptr_func, arg); + +} + +/** regenerate relptrlists in the file */ +static void +regen_ptrlist(void* base, udb_base* udb, udb_alloc* alloc, + udb_void rb_old, udb_void rb_new) +{ + udb_void at = alloc->udb->glob_data->hsize; + /* clear all ptrlist start pointers in the file. */ + while(at < alloc->disk->nextgrow) { + int exp = (int)UDB_CHUNK(at)->exp; + udb_chunk_type tp = (udb_chunk_type)UDB_CHUNK(at)->type; + if(exp == UDB_EXP_XL) { + UDB_XL_CHUNK(at)->ptrlist = 0; + at += UDB_XL_CHUNK(at)->size; + } else if(tp == udb_chunk_type_free) { + at += (uint64_t)1<<exp; + } else { /* data chunk */ + UDB_CHUNK(at)->ptrlist = 0; + at += (uint64_t)1<<exp; + } + } + /* walk through all relptr structs and put on the right list. */ + at = alloc->udb->glob_data->hsize; + while(at < alloc->disk->nextgrow) { + udb_chunk_d* atp = UDB_CHUNK(at); + int exp = (int)atp->exp; + udb_chunk_type tp = (udb_chunk_type)atp->type; + uint64_t sz = ((exp == UDB_EXP_XL)?UDB_XL_CHUNK(at)->size: + (uint64_t)1<<exp); + if(exp == UDB_EXP_XL) { + assert(at != rb_old); /* should have been freed */ + regen_its_ptrs(base, udb, atp, + ((void*)atp)+sizeof(udb_xl_chunk_d), + sz-sizeof(udb_xl_chunk_d) - sizeof(uint64_t)*2, + rb_old, rb_new); + at += sz; + } else if(tp == udb_chunk_type_free) { + at += sz; + } else { /* data chunk */ + assert(at != rb_old); /* should have been freed */ + regen_its_ptrs(base, udb, atp, + ((void*)atp)+sizeof(udb_chunk_d), + sz-sizeof(udb_chunk_d)-1, rb_old, rb_new); + at += sz; + } + } +} + + +/** mark free elements from ex XL chunk space and later fixups pick that up */ +static void +rb_mark_free_segs(void* base, udb_void s, uint64_t m) +{ + udb_void q = s + m - UDB_ALLOC_CHUNK_SIZE; + /* because of header and alignment we know s >= UDB_ALLOC_CHUNK_SIZE*/ + assert(s >= UDB_ALLOC_CHUNK_SIZE); + while(q >= s) { + UDB_CHUNK(q)->exp = UDB_ALLOC_CHUNKS_MAX; + UDB_CHUNK(q)->type = udb_chunk_type_free; + q -= UDB_ALLOC_CHUNK_SIZE; + } +} + + +/** fsck rollback or rollforward XL move results */ +static int +fsck_rb_xl(void* base, udb_base* udb, udb_void rb_old, udb_void rb_new, + uint64_t rb_size, uint64_t rb_seg) +{ + + if(rb_old <= rb_new) + return 0; /* XL move one way */ + if( (rb_size&(UDB_ALLOC_CHUNK_SIZE-1)) != 0) + return 0; /* not aligned */ + if( (rb_old&(UDB_ALLOC_CHUNK_SIZE-1)) != 0) + return 0; /* not aligned */ + if( (rb_new&(UDB_ALLOC_CHUNK_SIZE-1)) != 0) + return 0; /* not aligned */ + if(rb_new + rb_size <= rb_old) { + /* not overlapping: resume copy */ + memcpy(UDB_CHUNK(rb_new), UDB_CHUNK(rb_old), rb_size); + /* and free up old piece(s) */ + rb_mark_free_segs(base, rb_old, rb_size); + } else { + /* overlapping, see what segment we stopped at + * and continue there. */ + move_xl_segment(base, udb, rb_old, rb_new, rb_size, rb_seg); + /* free up old piece(s); from the end of the moved segment, + * until the end of the old segment */ + rb_mark_free_segs(base, rb_new+rb_size, (rb_old+rb_size)- + (rb_new+rb_size)); + } + /* do not call fix_ptrs, regenptrs does the job */ + return 1; +} + +/** fsck rollback or rollforward move results */ +static int +fsck_rb(void* base, udb_void rb_old, udb_void rb_new, uint64_t rb_size, + udb_void* make_free) +{ + if( (rb_size&(rb_size-1)) != 0) + return 0; /* not powerof2 */ + if( (rb_old&(rb_size-1)) != 0) + return 0; /* not aligned */ + if( (rb_new&(rb_size-1)) != 0) + return 0; /* not aligned */ + /* resume copy */ + memcpy(UDB_CHUNK(rb_new), UDB_CHUNK(rb_old), rb_size); + /* do not call fix_ptrs, regenptrs does the job */ + /* make sure udb_old is freed */ + *make_free = rb_old; + return 1; +} + +/** fsck the file and salvage, false if failed and file is useless */ +static int +fsck_file(udb_base* udb, udb_alloc* alloc, int moved) +{ + void* base = udb->base; + udb_alloc_d regen; + udb_void at = udb->glob_data->hsize; + udb_void rb_old = udb->glob_data->rb_old; + udb_void rb_new = udb->glob_data->rb_new; + udb_void rb_seg = udb->glob_data->rb_seg; + udb_void make_free = 0; + uint64_t rb_size = udb->glob_data->rb_size; + log_msg(LOG_WARNING, "udb-fsck %s: salvaging", udb->fname); + /* walk through the file, use the exp values to see what can be + * salvaged */ + if(moved && rb_old && rb_new && rb_size) { + if(rb_old+rb_size <= alloc->disk->nextgrow + && rb_new+rb_size <= alloc->disk->nextgrow) { + /* we can use the move information to fix up the + * duplicate element (or partially moved element) */ + if(rb_size > 1024*1024) { + /* XL chunk */ + if(!fsck_rb_xl(base, udb, rb_old, rb_new, + rb_size, rb_seg)) + return 0; + } else { + if(!fsck_rb(base, rb_old, rb_new, rb_size, + &make_free)) + return 0; + } + } + } + + /* rebuild freelists */ + /* recalculate stats in alloc (except 'stat_data') */ + /* possibly new end 'nextgrow' value */ + memset(®en, 0, sizeof(regen)); + regen.nextgrow = alloc->disk->nextgrow; + while(at < regen.nextgrow) { + /* figure out this chunk */ + int exp = (int)UDB_CHUNK(at)->exp; + udb_chunk_type tp = (udb_chunk_type)UDB_CHUNK(at)->type; + /* consistency check possible here with end-exp */ + if(tp == udb_chunk_type_free || at == make_free) { + at = regen_free(base, at, exp, ®en); + if(!at) return 0; + } else if(exp == UDB_EXP_XL) { + /* allocated data of XL size */ + at = regen_xl(base, at, ®en); + if(!at) return 0; + } else if(exp >= UDB_ALLOC_CHUNK_MINEXP + && exp <= UDB_ALLOC_CHUNKS_MAX) { + /* allocated data */ + at = regen_data(base, at, exp, ®en); + if(!at) return 0; + } else { + /* garbage; this must be EOF then */ + regen.nextgrow = at; + break; + } + } + *alloc->disk = regen; + + /* rebuild relptr lists */ + regen_ptrlist(base, udb, alloc, rb_old, rb_new); + + log_msg(LOG_WARNING, "udb-fsck %s: salvaged successfully (sync)", + udb->fname); + udb->glob_data->rb_old = 0; + udb->glob_data->rb_new = 0; + udb->glob_data->rb_size = 0; + udb->glob_data->dirty_alloc = udb_dirty_clean; + udb_base_sync(udb, 1); + return 1; +} + + +udb_alloc* udb_alloc_create(udb_base* udb, udb_alloc_d* disk) +{ + udb_alloc* alloc = (udb_alloc*)xalloc_zero(sizeof(*alloc)); + if(!alloc) + return NULL; + alloc->udb = udb; + alloc->disk = disk; + /* see if committed but uncompleted actions need to be done */ + /* preserves the alloc state */ + if(udb->glob_data->dirty_alloc != udb_dirty_clean) { + if(udb->glob_data->dirty_alloc == udb_dirty_fsize) { + if(fsck_fsize(udb, alloc)) + return alloc; + } else if(udb->glob_data->dirty_alloc == udb_dirty_fl) { + if(fsck_file(udb, alloc, 0)) + return alloc; + } else if(udb->glob_data->dirty_alloc == udb_dirty_compact) { + if(fsck_file(udb, alloc, 1)) + return alloc; + } + log_msg(LOG_ERR, "error: file allocation dirty (%d)", + (int)udb->glob_data->dirty_alloc); + free(alloc); + return NULL; + } + return alloc; +} + +void udb_alloc_delete(udb_alloc* alloc) +{ + if(!alloc) return; + free(alloc); +} + +/** unlink this element from its freelist */ +static void +udb_alloc_unlink_fl(void* base, udb_alloc* alloc, udb_void chunk, int exp) +{ + udb_free_chunk_d* fp = UDB_FREE_CHUNK(chunk); + assert(chunk); + /* chunk is a free chunk */ + assert(fp->exp == (uint8_t)exp); + assert(fp->type == udb_chunk_type_free); + assert(chunk_get_last(base, chunk, exp) == (uint8_t)exp); + /* and thus freelist not empty */ + assert(alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP]); + /* unlink */ + if(fp->prev) + UDB_FREE_CHUNK(fp->prev)->next = fp->next; + else alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP] = fp->next; + if(fp->next) + UDB_FREE_CHUNK(fp->next)->prev = fp->prev; +} + +/** pop first element off freelist, list may not be empty */ +static udb_void +udb_alloc_pop_fl(void* base, udb_alloc* alloc, int exp) +{ + udb_void f = alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP]; + udb_free_chunk_d* fp = UDB_FREE_CHUNK(f); + assert(f); + assert(fp->exp == (uint8_t)exp); + assert(fp->type == udb_chunk_type_free); + assert(chunk_get_last(base, f, exp) == (uint8_t)exp); + alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP] = fp->next; + if(fp->next) { + UDB_FREE_CHUNK(fp->next)->prev = 0; + } + return f; +} + +/** push new element onto freelist */ +static void +udb_alloc_push_fl(void* base, udb_alloc* alloc, udb_void f, int exp) +{ + udb_free_chunk_d* fp = UDB_FREE_CHUNK(f); + assert(f); + fp->exp = (uint8_t)exp; + fp->type = udb_chunk_type_free; + fp->flags = 0; + fp->prev = 0; + fp->next = alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP]; + if(fp->next) + UDB_FREE_CHUNK(fp->next)->prev = f; + chunk_set_last(base, f, exp, (uint8_t)exp); + alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP] = f; +} + +/** push new element onto freelist - do not initialize the elt */ +static void +udb_alloc_push_fl_noinit(void* base, udb_alloc* alloc, udb_void f, int exp) +{ + udb_free_chunk_d* fp = UDB_FREE_CHUNK(f); + assert(f); + assert(fp->exp == (uint8_t)exp); + assert(fp->type == udb_chunk_type_free); + assert(chunk_get_last(base, f, exp) == (uint8_t)exp); + fp->prev = 0; + fp->next = alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP]; + if(fp->next) + UDB_FREE_CHUNK(fp->next)->prev = f; + alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP] = f; +} + +/** add free chunks at end until specified alignment occurs */ +static void +grow_align(void* base, udb_alloc* alloc, uint64_t esz) +{ + while( (alloc->disk->nextgrow & (esz-1)) != 0) { + /* the nextgrow is not a whole multiple of esz. */ + /* grow a free chunk of max allowed size */ + int fexp = udb_exp_offset(alloc->disk->nextgrow); + uint64_t fsz = (uint64_t)1<<fexp; + udb_void f = alloc->disk->nextgrow; + udb_void fn = alloc->disk->nextgrow+fsz; + assert(fn <= alloc->udb->base_size); + alloc->disk->stat_free += fsz; + udb_alloc_push_fl(base, alloc, f, fexp); + /* now increase nextgrow to commit that free chunk */ + alloc->disk->nextgrow = fn; + } +} + +/** append chunks at end of memory space to get size exp, return dataptr */ +static udb_void +grow_chunks(void* base, udb_alloc* alloc, size_t sz, int exp) +{ + uint64_t esz = (uint64_t)1<<exp; + udb_void ret; + alloc->udb->glob_data->dirty_alloc = udb_dirty_fl; + grow_align(base, alloc, esz); + /* free chunks are grown, grow the one we want to use */ + ret = alloc->disk->nextgrow; + /* take a new alloced chunk into use */ + UDB_CHUNK(ret)->exp = (uint8_t)exp; + UDB_CHUNK(ret)->flags = 0; + UDB_CHUNK(ret)->ptrlist = 0; + UDB_CHUNK(ret)->type = udb_chunk_type_data; + /* store last octet */ + chunk_set_last(base, ret, exp, (uint8_t)exp); + /* update stats */ + alloc->disk->stat_alloc += esz; + alloc->disk->stat_data += sz; + /* now increase nextgrow to commit this newly allocated chunk */ + alloc->disk->nextgrow += esz; + assert(alloc->disk->nextgrow <= alloc->udb->base_size); + alloc->udb->glob_data->dirty_alloc = udb_dirty_clean; + return ret + sizeof(udb_chunk_d); /* ptr to data */ +} + +/** calculate how much space is necessary to grow for this exp */ +static uint64_t +grow_end_calc(udb_alloc* alloc, int exp) +{ + uint64_t sz = (uint64_t)1<<exp; + uint64_t ng = alloc->disk->nextgrow; + uint64_t res; + /* if nextgrow is 2**expness, no extra growth needed, only size */ + if( (ng & (sz-1)) == 0) { + /* sz-1 is like 0xfff, and checks if ng is whole 2**exp */ + return ng+sz; /* must grow exactly 2**exp */ + } + /* grow until 2**expness and then we need 2**exp as well */ + /* so, round ng down to whole sz (basically ng-ng%sz, or ng/sz*sz) + * and then add the sz twice (go up to whole sz, and to allocate) */ + res = (ng & ~(sz-1)) + 2*sz; + return res; +} + +/** see if we need to grow more than specified to enable sustained growth */ +static uint64_t +grow_extra_check(udb_alloc* alloc, uint64_t ge) +{ + const uint64_t mb = 1024*1024; + uint64_t bsz = alloc->udb->base_size; + if(bsz <= mb) { + /* below 1 Mb, double sizes for exponential growth */ + /* takes about 15 times to grow to 1Mb */ + if(ge < bsz*2) + return bsz*2; + } else { + uint64_t gnow = ge - bsz; + /* above 1Mb, grow at least 1 Mb, or 12.5% of current size, + * in whole megabytes rounded up. */ + uint64_t want = ((bsz / 8) & ~(mb-1)) + mb; + if(gnow < want) + return bsz + want; + } + return ge; +} + +/** see if free space is enogh to warrant shrink (while file is open) */ +static int +enough_free(udb_alloc* alloc) +{ + if(alloc->udb->base_size <= 2*1024*1024) { + /* below 1 Mb, grown by double size, (so up to 2 mb), + * do not shrink unless we can 1/3 in size */ + if(((size_t)alloc->disk->nextgrow)*3 <= alloc->udb->base_size) + return 1; + } else { + /* grown 12.5%, shrink 25% if possible, at least one mb */ + /* between 1mb and 4mb size, it shrinks by 1mb if possible */ + uint64_t space = alloc->udb->base_size - alloc->disk->nextgrow; + if(space >= 1024*1024 && (space*4 >= alloc->udb->base_size + || alloc->udb->base_size < 4*1024*1024)) + return 1; + } + return 0; +} + +/** grow space for a chunk of 2**exp and return dataptr */ +static udb_void +udb_alloc_grow_space(void* base, udb_alloc* alloc, size_t sz, int exp) +{ + /* commit the grow action + * - the file grow only changes filesize, but not the nextgrow. + * - taking space after nextgrow into use (as free space), + * is like free-ing a chunk (one at a time). + * - and the last chunk taken into use is like alloc. + */ + /* predict how much free space is needed for this */ + uint64_t grow_end = grow_end_calc(alloc, exp); + assert(alloc->udb->base_size >= alloc->disk->nextgrow); + if(grow_end <= alloc->udb->base_size) { + /* we can do this with the available space */ + return grow_chunks(base, alloc, sz, exp); + } + /* we have to grow the file, re-mmap */ + /* see if we need to grow a little more, to avoid endless grow + * efforts on adding data */ + grow_end = grow_extra_check(alloc, grow_end); + if(!(base=udb_base_grow_and_remap(alloc->udb, grow_end))) { + return 0; /* mmap or write failed (disk or mem full) */ + } + /* we have enough space now */ + assert(grow_end <= alloc->udb->base_size); + assert(alloc->udb->glob_data->fsize == alloc->udb->base_size); + return grow_chunks(base, alloc, sz, exp); +} + +/** take XL allocation into use at end of file, return dataptr */ +static udb_void +grow_xl(void* base, udb_alloc* alloc, uint64_t xlsz, uint64_t sz) +{ + udb_void ret; + udb_xl_chunk_d* p; + alloc->udb->glob_data->dirty_alloc = udb_dirty_fl; + + /* align growth to whole mbs */ + grow_align(base, alloc, UDB_ALLOC_CHUNK_SIZE); + + /* grow XL segment */ + ret = alloc->disk->nextgrow; + p = UDB_XL_CHUNK(ret); + p->exp = UDB_EXP_XL; + p->size = xlsz; + p->flags = 0; + p->ptrlist = 0; + p->type = udb_chunk_type_data; + + /* also put size and marker at end for compaction */ + *((uint64_t*)(UDB_REL(base, ret+xlsz-sizeof(uint64_t)*2))) = xlsz; + *((uint8_t*)(UDB_REL(base, ret+xlsz-1))) = UDB_EXP_XL; + + /* stats */ + alloc->disk->stat_data += sz; + alloc->disk->stat_alloc += xlsz; + /* now increase the nextgrow to commit this xl chunk */ + alloc->disk->nextgrow += xlsz; + alloc->udb->glob_data->dirty_alloc = udb_dirty_clean; + return ret + sizeof(udb_xl_chunk_d); /* data ptr */ +} + +/** make space for XL allocation */ +static udb_void +udb_alloc_xl_space(void* base, udb_alloc* alloc, size_t sz) +{ + /* allocate whole mbs of space, at end of space */ + uint64_t asz = sz + sizeof(udb_xl_chunk_d) + sizeof(uint64_t)*2; + uint64_t need=(asz+UDB_ALLOC_CHUNK_SIZE-1)&(~(UDB_ALLOC_CHUNK_SIZE-1)); + uint64_t grow_end = grow_end_calc(alloc, UDB_ALLOC_CHUNKS_MAX) + need; + assert(need >= asz); + if(grow_end <= alloc->udb->base_size) { + /* can do this in available space */ + return grow_xl(base, alloc, need, sz); + } + /* have to grow file and re-mmap */ + grow_end = grow_extra_check(alloc, grow_end); + if(!(base=udb_base_grow_and_remap(alloc->udb, grow_end))) { + return 0; /* mmap or write failed (disk or mem full) */ + } + /* we have enough space now */ + assert(grow_end <= alloc->udb->base_size); + assert(alloc->udb->glob_data->fsize == alloc->udb->base_size); + return grow_xl(base, alloc, need, sz); +} + +/** divide big(2**e2) into pieces so 2**exp fits */ +static udb_void +udb_alloc_subdivide(void* base, udb_alloc* alloc, udb_void big, int e2, + int exp) +{ + int e = e2; + uint64_t sz = (uint64_t)1<<e2; + assert(big && e2 > exp); + /* so the returned piece to use is the first piece, + * offload the later half until it fits */ + do { + sz >>= 1; /* divide size of big by two */ + e--; /* that means its exp is one smaller */ + udb_alloc_push_fl(base, alloc, big+sz, e); + } while(e != exp); + /* exit loop when last pushed is same size as what we want */ + return big; +} + +/** returns the exponent size of the chunk needed for data sz */ +static int +udb_alloc_exp_needed(size_t sz) +{ + uint64_t asz = sz + sizeof(udb_chunk_d) + 1; + if(asz > UDB_ALLOC_CHUNK_SIZE) { + return UDB_EXP_XL; + } else if(asz <= UDB_ALLOC_CHUNK_MINSIZE) { + return UDB_ALLOC_CHUNK_MINEXP; + } + return udb_exp_size(asz); +} + +udb_void udb_alloc_space(udb_alloc* alloc, size_t sz) +{ + void* base = alloc->udb->base; + /* calculate actual allocation size */ + int e2, exp = udb_alloc_exp_needed(sz); + if(exp == UDB_EXP_XL) + return udb_alloc_xl_space(base, alloc, sz); + /* see if there is a free chunk of that size exactly */ + if(alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP]) { + /* snip from freelist, udb_chunk_d */ + udb_void ret; + alloc->udb->glob_data->dirty_alloc = udb_dirty_fl; + ret = udb_alloc_pop_fl(base, alloc, exp); + /* use it - size octets already OK */ + UDB_CHUNK(ret)->flags = 0; + UDB_CHUNK(ret)->ptrlist = 0; + UDB_CHUNK(ret)->type = udb_chunk_type_data; + /* update stats */ + alloc->disk->stat_data += sz; + alloc->disk->stat_alloc += (1<<exp); + assert(alloc->disk->stat_free >= (1u<<exp)); + alloc->disk->stat_free -= (1<<exp); + alloc->udb->glob_data->dirty_alloc = udb_dirty_clean; + return ret + sizeof(udb_chunk_d); /* ptr to data */ + } + /* see if we can subdivide a larger chunk */ + for(e2 = exp+1; e2 < UDB_ALLOC_CHUNKS_MAX; e2++) + if(alloc->disk->free[e2-UDB_ALLOC_CHUNK_MINEXP]) { + udb_void big, ret; /* udb_chunk_d */ + alloc->udb->glob_data->dirty_alloc = udb_dirty_fl; + big = udb_alloc_pop_fl(base, alloc, e2); + /* push other parts onto freelists (needs inited) */ + ret = udb_alloc_subdivide(base, alloc, big, e2, exp); + /* use final part (needs inited) */ + UDB_CHUNK(ret)->exp = (uint8_t)exp; + /* if stop here; the new exp makes smaller free chunk*/ + UDB_CHUNK(ret)->flags = 0; + UDB_CHUNK(ret)->ptrlist = 0; + /* set type to commit data chunk */ + UDB_CHUNK(ret)->type = udb_chunk_type_data; + /* store last octet */ + chunk_set_last(base, ret, exp, (uint8_t)exp); + /* update stats */ + alloc->disk->stat_data += sz; + alloc->disk->stat_alloc += (1<<exp); + assert(alloc->disk->stat_free >= (1u<<exp)); + alloc->disk->stat_free -= (1<<exp); + alloc->udb->glob_data->dirty_alloc = udb_dirty_clean; + return ret + sizeof(udb_chunk_d); /* ptr to data */ + } + /* we need to grow an extra chunk */ + return udb_alloc_grow_space(base, alloc, sz, exp); +} + +/** see if there is free space to allocate a chunk into */ +static int +have_free_for(udb_alloc* alloc, int exp) +{ + int e2; + if(alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP]) + return exp; + for(e2 = exp+1; e2 < UDB_ALLOC_CHUNKS_MAX; e2++) + if(alloc->disk->free[e2-UDB_ALLOC_CHUNK_MINEXP]) { + return e2; + } + return 0; +} + +/** fix relptr prev and next for moved relptr structures */ +static void +chunk_fix_ptr_each(void* base, udb_rel_ptr* rp, void* arg) +{ + udb_void* data = (udb_void*)arg; + udb_void r; + if(!rp->data) + return; + r = UDB_SYSTOREL(base, rp); + if(rp->next) + UDB_REL_PTR(rp->next)->prev = r; + if(rp->prev) + UDB_REL_PTR(rp->prev)->next = r; + else { + /* if this is a pointer to its own chunk, fix it up; + * the data ptr gets set by relptr_edit later. */ + if(rp->data == data[0]) + UDB_CHUNK(data[1])->ptrlist = r; + else UDB_CHUNK(chunk_from_dataptr(rp->data))->ptrlist = r; + } +} + +/** fix pointers from and to a moved chunk */ +static void +chunk_fix_ptrs(void* base, udb_base* udb, udb_chunk_d* cp, udb_void data, + uint64_t dsz, udb_void olddata) +{ + udb_void d[2]; + d[0] = olddata; + d[1] = data; + (*udb->walkfunc)(base, udb->walkarg, cp->type, UDB_REL(base, data), + dsz, &chunk_fix_ptr_each, d); + udb_rel_ptr_edit(base, cp->ptrlist, data); + udb_base_ram_ptr_edit(udb, olddata, data); +} + +/** move an allocated chunk to use a free chunk */ +static void +move_chunk(void* base, udb_alloc* alloc, udb_void f, int exp, uint64_t esz, + int e2) +{ + udb_void res = udb_alloc_pop_fl(base, alloc, e2); + udb_chunk_d* rp; + udb_chunk_d* fp; + if(exp != e2) { + /* it is bigger, subdivide it */ + res = udb_alloc_subdivide(base, alloc, res, e2, exp); + } + assert(res != f); + /* setup rollback information */ + alloc->udb->glob_data->rb_old = f; + alloc->udb->glob_data->rb_new = res; + alloc->udb->glob_data->rb_size = esz; + /* take the res, exp into use */ + rp = UDB_CHUNK(res); + fp = UDB_CHUNK(f); + /* copy over the data */ + memcpy(rp, fp, esz); + /* adjust rel ptrs */ + chunk_fix_ptrs(base, alloc->udb, rp, res+sizeof(udb_chunk_d), + esz-sizeof(udb_chunk_d)-1, f+sizeof(udb_chunk_d)); + + /* do not freeup the fp; caller does that */ +} + +/** unlink several free elements to overwrite with xl chunk */ +static void +free_xl_space(void* base, udb_alloc* alloc, udb_void s, uint64_t m) +{ + udb_void q = s + m - UDB_ALLOC_CHUNK_SIZE; + /* because of header and alignment we know s >= UDB_ALLOC_CHUNK_SIZE*/ + assert(s >= UDB_ALLOC_CHUNK_SIZE); + while(q >= s) { + assert(UDB_CHUNK(q)->exp == UDB_ALLOC_CHUNKS_MAX); + assert(UDB_CHUNK(q)->type == udb_chunk_type_free); + udb_alloc_unlink_fl(base, alloc, q, UDB_ALLOC_CHUNKS_MAX); + q -= UDB_ALLOC_CHUNK_SIZE; + } +} + +/** move an XL chunk, and keep track of segments for rollback */ +static void +move_xl_segment(void* base, udb_base* udb, udb_void xl, udb_void n, + uint64_t sz, uint64_t startseg) +{ + udb_xl_chunk_d* xlp = UDB_XL_CHUNK(xl); + udb_xl_chunk_d* np = UDB_XL_CHUNK(n); + uint64_t amount = xl - n; + assert(n < xl); /* move to compact */ + + /* setup move rollback */ + udb->glob_data->rb_old = xl; + udb->glob_data->rb_new = n; + udb->glob_data->rb_size = sz; + + /* is it overlapping? */ + if(sz <= amount) { + memcpy(np, xlp, sz); + } else { + /* move and commit per 1M segment to avoid data loss */ + uint64_t seg, maxseg = amount/UDB_ALLOC_CHUNK_SIZE; + for(seg = startseg; seg<maxseg; seg++) { + udb->glob_data->rb_seg = seg; + memcpy(np+seg*UDB_ALLOC_CHUNK_SIZE, + xlp+seg*UDB_ALLOC_CHUNK_SIZE, + UDB_ALLOC_CHUNK_SIZE); + } + + } +} + +/** move list of XL chunks to the front by the shift amount */ +static void +move_xl_list(void* base, udb_alloc* alloc, udb_void xl_start, uint64_t xl_sz, + uint64_t amount) +{ + udb_void xl = xl_start; + assert( (xl_start&(UDB_ALLOC_CHUNK_SIZE-1)) == 0 ); /* aligned */ + assert( (amount&(UDB_ALLOC_CHUNK_SIZE-1)) == 0 ); /* multiples */ + assert( (xl_sz&(UDB_ALLOC_CHUNK_SIZE-1)) == 0 ); /* multiples */ + while(xl < xl_start+xl_sz) { + udb_xl_chunk_d* xlp = UDB_XL_CHUNK(xl); + udb_void n = xl-amount; + uint64_t sz = xlp->size; + assert(xlp->exp == UDB_EXP_XL); + move_xl_segment(base, alloc->udb, xl, n, sz, 0); + chunk_fix_ptrs(base, alloc->udb, UDB_CHUNK(n), + n+sizeof(udb_xl_chunk_d), + sz-sizeof(udb_xl_chunk_d)-sizeof(uint64_t)*2, + xl+sizeof(udb_xl_chunk_d)); + } + alloc->disk->stat_free -= amount; + alloc->disk->nextgrow -= amount; + alloc->udb->glob_data->rb_old = 0; + alloc->udb->glob_data->rb_new = 0; + alloc->udb->glob_data->rb_size = 0; +} + +/** see if free chunk can coagulate with another chunk, return other chunk */ +static udb_void +coagulate_possible(void* base, udb_alloc* alloc, udb_void f, int exp, + uint64_t esz) +{ + udb_void other = f^esz; + if(exp == UDB_ALLOC_CHUNKS_MAX) + return 0; /* no further merges */ + if(other >= alloc->udb->base_size) + return 0; /* not allocated */ + if(other >= alloc->disk->nextgrow) + return 0; /* not in use */ + if(other < alloc->udb->glob_data->hsize) + return 0; /* cannot merge with header */ + /* the header is also protected by the special exp marker */ + /* see if the other chunk is a free chunk */ + + /* check closest marker to avoid large memory churn */ + /* and also it makes XL allocations and header special markers work */ + if(f > other) { + assert(f > 1); /* this is certain because of header */ + if(*((uint8_t*)UDB_REL(base, f-1)) == (uint8_t)exp) { + /* can do it if the other part is a free chunk */ + assert(UDB_FREE_CHUNK(other)->exp == (uint8_t)exp); + if(UDB_CHUNK(other)->type == udb_chunk_type_free) + return other; + } + } else { + if(UDB_CHUNK(other)->exp == (uint8_t)exp) { + /* can do it if the other part is a free chunk */ + assert(chunk_get_last(base, other, exp)==(uint8_t)exp); + if(UDB_CHUNK(other)->type == udb_chunk_type_free) + return other; + } + } + return 0; +} + +/** coagulate and then add new free segment, return final free segment */ +static udb_void +coagulate_and_push(void* base, udb_alloc* alloc, udb_void last, int exp, + uint64_t esz) +{ + /* new free chunk here, attempt coagulate */ + udb_void other; + while( (other=coagulate_possible(base, alloc, last, exp, esz)) ) { + /* unlink that other chunk */ + udb_alloc_unlink_fl(base, alloc, other, exp); + /* merge up */ + if(other < last) + last = other; + exp++; + esz <<= 1; + } + /* free the final segment */ + udb_alloc_push_fl(base, alloc, last, exp); + return last; +} + +/** attempt to compact the data and move free space to the end */ +static int +udb_alloc_compact(void* base, udb_alloc* alloc) +{ + udb_void last; + int exp, e2; + uint64_t esz; + uint64_t at = alloc->disk->nextgrow; + udb_void xl_start = 0; + uint64_t xl_sz = 0; + while(at > alloc->udb->glob_data->hsize) { + /* grab last entry */ + exp = (int)*((uint8_t*)UDB_REL(base, at-1)); + if(exp == UDB_EXP_XL) { + /* for XL chunks: + * - inspect the size of the XLchunklist at end + * - attempt to compact in front of of XLchunklist + */ + uint64_t xlsz = *((uint64_t*)UDB_REL(base, + at-sizeof(uint64_t)*2)); + udb_void xl = at-xlsz; +#ifndef NDEBUG + udb_xl_chunk_d* xlp = UDB_XL_CHUNK(xl); + assert(xlp->exp == UDB_EXP_XL); + assert(xlp->type != udb_chunk_type_free); +#endif + /* got thesegment add to the xl chunk list */ + if(xl_start != 0 && xl+xlsz != xl_start) { + /* nonadjoining XL part, but they are aligned, + * so the space in between is whole Mbs, + * shift the later part(s) and continue */ + uint64_t m = xl_start - (xl+xlsz); + assert(xl_start > xl+xlsz); + alloc->udb->glob_data->dirty_alloc = udb_dirty_compact; + free_xl_space(base, alloc, xl+xlsz, m); + move_xl_list(base, alloc, xl_start, xl_sz, m); + alloc->udb->glob_data->dirty_alloc = udb_dirty_clean; + } + xl_start = xl; + xl_sz += xlsz; + at = xl; + continue; + /* end of XL if */ + } else if(exp < UDB_ALLOC_CHUNK_MINEXP + || exp > UDB_ALLOC_CHUNKS_MAX) + break; /* special chunk or garbage */ + esz = (uint64_t)1<<exp; + last = at - esz; + assert(UDB_CHUNK(last)->exp == (uint8_t)exp); + if(UDB_CHUNK(last)->type == udb_chunk_type_free) { + /* if xlstart continue looking to move stuff, but do + * not unlink this free segment */ + if(!xl_start) { + /* it is a free chunk, remove it */ + alloc->udb->glob_data->dirty_alloc = udb_dirty_fl; + udb_alloc_unlink_fl(base, alloc, last, exp); + alloc->disk->stat_free -= esz; + alloc->disk->nextgrow = last; + alloc->udb->glob_data->dirty_alloc = udb_dirty_clean; + /* and continue at this point */ + } + at = last; + } else if( (e2=have_free_for(alloc, exp)) ) { + /* last entry can be allocated in free chunks + * move it to its new position, adjust rel_ptrs */ + alloc->udb->glob_data->dirty_alloc = udb_dirty_compact; + move_chunk(base, alloc, last, exp, esz, e2); + if(xl_start) { + last = coagulate_and_push(base, alloc, + last, exp, esz); + } else { + /* shorten usage */ + alloc->disk->stat_free -= esz; + alloc->disk->nextgrow = last; + } + alloc->udb->glob_data->rb_old = 0; + alloc->udb->glob_data->rb_new = 0; + alloc->udb->glob_data->rb_size = 0; + alloc->udb->glob_data->dirty_alloc = udb_dirty_clean; + /* and continue in front of it */ + at = last; + } else { + /* cannot compact this block, stop compacting */ + break; + } + /* if that worked, repeat it */ + } + /* if we passed xl chunks, see if XL-chunklist can move */ + if(xl_start) { + /* calculate free space in front of the XLchunklist. */ + /* has to be whole mbs of free space */ + /* if so, we can move the XL chunks. Move them all back + * by the new free space. */ + /* this compacts very well, but the XL chunks can be moved + * multiple times; worst case for every mb freed a huge sized + * xlchunklist gets moved. */ + /* free space must be, since aligned and coagulated, in + * chunks of a whole MB */ + udb_void at = xl_start; + uint64_t m = 0; + while(*((uint8_t*)UDB_REL(base, at-1))==UDB_ALLOC_CHUNKS_MAX){ + udb_void chunk = at - UDB_ALLOC_CHUNK_SIZE; + if(UDB_CHUNK(chunk)->type != udb_chunk_type_free) + break; + assert(UDB_CHUNK(chunk)->exp==UDB_ALLOC_CHUNKS_MAX); + m += UDB_ALLOC_CHUNK_SIZE; + at = chunk; + } + if(m != 0) { + assert(at+m == xl_start); + alloc->udb->glob_data->dirty_alloc = udb_dirty_compact; + free_xl_space(base, alloc, at, m); + move_xl_list(base, alloc, xl_start, xl_sz, m); + alloc->udb->glob_data->dirty_alloc = udb_dirty_clean; + } + } + + /* if enough free, shrink the file; re-mmap */ + if(enough_free(alloc)) { + uint64_t nsize = alloc->disk->nextgrow; + udb_base_shrink(alloc->udb, nsize); + if(!udb_base_remap(alloc->udb, alloc, nsize)) + return 0; + } + return 1; +} + +#ifdef UDB_CHECK +/** check that rptrs are really zero before free */ +void udb_check_rptr_zero(void* base, udb_rel_ptr* p, void* arg) +{ + (void)base; + (void)arg; + assert(p->data == 0); +} +#endif /* UDB_CHECK */ + +/** free XL chunk as multiples of CHUNK_SIZE free segments */ +static void +udb_free_xl(void* base, udb_alloc* alloc, udb_void f, udb_xl_chunk_d* fp, + size_t sz) +{ + uint64_t xlsz = fp->size; + uint64_t c; + /* lightweight check for buffer overflow in xl data */ + assert(*((uint64_t*)(UDB_REL(base, f+xlsz-sizeof(uint64_t)*2)))==xlsz); + assert(*((uint8_t*)(UDB_REL(base, f+xlsz-1))) == UDB_EXP_XL); + assert( (xlsz & (UDB_ALLOC_CHUNK_SIZE-1)) == 0 ); /* whole mbs */ + assert( (f & (UDB_ALLOC_CHUNK_SIZE-1)) == 0 ); /* aligned */ +#ifdef UDB_CHECK + /* check that relptrs in this chunk have been zeroed */ + (*alloc->udb->walkfunc)(base, alloc->udb->walkarg, fp->type, + UDB_REL(base, f+sizeof(udb_xl_chunk_d)), xlsz, + &udb_check_rptr_zero, NULL); +#endif + alloc->udb->glob_data->dirty_alloc = udb_dirty_fl; + /* update stats */ + alloc->disk->stat_data -= sz; + alloc->disk->stat_alloc -= xlsz; + alloc->disk->stat_free += xlsz; + /* walk in reverse, so the front blocks go first on the list */ + c = f + xlsz - UDB_ALLOC_CHUNK_SIZE; + /* because of header and alignment we know f >= UDB_ALLOC_CHUNK_SIZE*/ + assert(f >= UDB_ALLOC_CHUNK_SIZE); + while(c >= f) { + /* free a block of CHUNK_SIZE (1 Mb) */ + udb_alloc_push_fl(base, alloc, c, UDB_ALLOC_CHUNKS_MAX); + c -= UDB_ALLOC_CHUNK_SIZE; + } + alloc->udb->glob_data->dirty_alloc = udb_dirty_clean; +} + +int udb_alloc_free(udb_alloc* alloc, udb_void r, size_t sz) +{ + void* base; + /* lookup chunk ptr */ + udb_void f; + udb_chunk_d* fp; + uint64_t esz; + int exp; + udb_void other; + int coagulated = 0; + if(!r) + return 1; /* free(NULL) does nothing */ + + /* lookup size of chunk */ + base = alloc->udb->base; + /* fails for XL blocks */ + f = chunk_from_dataptr(r); + fp = UDB_CHUNK(f); + assert(fp->type != udb_chunk_type_free); + + /* see if it has a ptrlist, if so: trouble, the list is not properly + * cleaned up. (although you can imagine a wholesale delete where + * it does not matter) */ + assert(fp->ptrlist == 0); + + /* set ptrlist to 0 to stop relptr from using it, robustness. */ + fp->ptrlist = 0; + + if(fp->exp == UDB_EXP_XL) { + udb_free_xl(base, alloc, f, (udb_xl_chunk_d*)fp, sz); + /* compact */ + return udb_alloc_compact(base, alloc); + } + /* it is a regular chunk of 2**exp size */ + exp = (int)fp->exp; + esz = (uint64_t)1<<exp; + /* light check for e.g. buffer overflow of the data */ + assert(sz < esz); + assert(chunk_get_last(base, f, exp) == (uint8_t)exp); +#ifdef UDB_CHECK + /* check that relptrs in this chunk have been zeroed */ + (*alloc->udb->walkfunc)(base, alloc->udb->walkarg, fp->type, + UDB_REL(base, r), esz, &udb_check_rptr_zero, NULL); +#endif + + /* update the stats */ + alloc->udb->glob_data->dirty_alloc = udb_dirty_fl; + alloc->disk->stat_data -= sz; + alloc->disk->stat_free += esz; + alloc->disk->stat_alloc -= esz; + + /* if it can be merged with other free chunks, do so */ + while( (other=coagulate_possible(base, alloc, f, exp, esz)) ) { + coagulated = 1; + /* unlink that other chunk and expand it (it has same size) */ + udb_alloc_unlink_fl(base, alloc, other, exp); + /* merge up */ + if(other < f) + f = other; + exp++; + esz <<= 1; + } + if(coagulated) { + /* put big free chunk into freelist, and init it */ + udb_alloc_push_fl(base, alloc, f, exp); + } else { + /* we do not need to touch the last-exp-byte, which may save + * a reference to that page of memory */ + fp->type = udb_chunk_type_free; + fp->flags = 0; + udb_alloc_push_fl_noinit(base, alloc, f, exp); + } + alloc->udb->glob_data->dirty_alloc = udb_dirty_clean; + /* compact */ + return udb_alloc_compact(base, alloc); +} + +udb_void udb_alloc_init(udb_alloc* alloc, void* d, size_t sz) +{ + /* could be faster maybe, if grown? */ + udb_void r = udb_alloc_space(alloc, sz); + if(!r) return r; + memcpy(UDB_REL(alloc->udb->base, r), d, sz); + return r; +} + +udb_void udb_alloc_realloc(udb_alloc* alloc, udb_void r, size_t osz, size_t sz) +{ + void* base = alloc->udb->base; + udb_void c, n, newd; + udb_chunk_d* cp, *np; + uint64_t avail; + uint8_t cp_type; + /* emulate some posix realloc stuff */ + if(r == 0) + return udb_alloc_space(alloc, sz); + if(sz == 0) { + if(!udb_alloc_free(alloc, r, osz)) + log_msg(LOG_ERR, "udb_alloc_realloc: free failed"); + return 0; + } + c = chunk_from_dataptr(r); + cp = UDB_CHUNK(c); + cp_type = cp->type; + if(cp->exp == UDB_EXP_XL) { + avail = UDB_XL_CHUNK(c)->size - sizeof(udb_xl_chunk_d) + - sizeof(uint64_t)*2; + } else { + avail = ((uint64_t)1<<cp->exp) - sizeof(udb_chunk_d) - 1; + } + if(sz <= avail) + return r; + /* reallocate it, and copy */ + newd = udb_alloc_space(alloc, sz); + if(!newd) return 0; + /* re-base after alloc, since re-mmap may have happened */ + base = alloc->udb->base; + cp = NULL; /* may be invalid now, robustness */ + n = chunk_from_dataptr(newd); + np = UDB_CHUNK(n); + np->type = cp_type; + memcpy(UDB_REL(base, newd), UDB_REL(base, r), osz); + /* fixup ptrs */ + chunk_fix_ptrs(base, alloc->udb, np, newd, osz, r); + + if(!udb_alloc_free(alloc, r, osz)) + log_msg(LOG_ERR, "udb_alloc_realloc: free failed"); + return newd; +} + +int udb_alloc_grow(udb_alloc* alloc, size_t sz, size_t num) +{ + const uint64_t mb = 1024*1024; + int exp = udb_alloc_exp_needed(sz); + uint64_t esz; + uint64_t want; + if(exp == UDB_EXP_XL) + esz = (sz&(mb-1))+mb; + else esz = (uint64_t)1<<exp; + /* we need grow_end_calc to take into account alignment */ + want = grow_end_calc(alloc, exp) + esz*(num-1); + assert(want >= alloc->udb->base_size); + if(!udb_base_grow_and_remap(alloc->udb, want)) { + log_msg(LOG_ERR, "failed to grow the specified amount"); + return 0; + } + return 1; +} + +void udb_alloc_set_type(udb_alloc* alloc, udb_void r, udb_chunk_type tp) +{ + void* base = alloc->udb->base; + udb_void f = chunk_from_dataptr(r); + udb_chunk_d* fp = UDB_CHUNK(f); + /* not the 'free' type, that must be set by allocation routines */ + assert(fp->type != udb_chunk_type_free); + assert(tp != udb_chunk_type_free); + fp->type = tp; +} + +int udb_valid_offset(udb_base* udb, udb_void to, size_t destsize) +{ + /* pointers are not valid before the header-size or after the + * used-region of the mmap */ + return ( (to+destsize) <= udb->base_size && + to >= (udb->glob_data->hsize-2*sizeof(udb_rel_ptr)) && + (to+destsize) <= udb->alloc->disk->nextgrow); +} + +int udb_valid_dataptr(udb_base* udb, udb_void to) +{ + void* base = udb->base; + udb_void ch; + int exp; + uint64_t esz; + /* our data chunks are aligned and at least 8 bytes */ + if(!udb_valid_offset(udb, to, sizeof(uint64_t))) + return 0; + /* get the chunk pointer */ + ch = chunk_from_dataptr(to); + if(!udb_valid_offset(udb, ch, sizeof(udb_chunk_d))) + return 0; + /* check its size */ + exp = UDB_CHUNK(ch)->exp; + if(exp == UDB_EXP_XL) { + /* check XL chunk */ + uint64_t xlsz; + if(!udb_valid_offset(udb, ch, sizeof(udb_xl_chunk_d))) + return 0; + xlsz = UDB_XL_CHUNK(ch)->size; + if(!udb_valid_offset(udb, ch+xlsz-1, 1)) + return 0; + if(*((uint8_t*)UDB_REL(base, ch+xlsz-1)) != UDB_EXP_XL) + return 0; + if(*((uint64_t*)UDB_REL(base, ch+xlsz-sizeof(uint64_t)*2)) + != xlsz) + return 0; + return 1; + } + /* check if regular chunk has matching end byte */ + if(exp < UDB_ALLOC_CHUNK_MINEXP || exp > UDB_ALLOC_CHUNKS_MAX) + return 0; /* cannot be a valid chunk */ + esz = 1<<exp; + if(!udb_valid_offset(udb, ch+esz-1, 1)) + return 0; + if(*((uint8_t*)UDB_REL(base, ch+esz-1)) != exp) + return 0; + return 1; +} + +int udb_valid_rptr(udb_base* udb, udb_void rptr, udb_void to) +{ + void* base = udb->base; + udb_void p; + if(!udb_valid_offset(udb, rptr, sizeof(udb_rel_ptr))) + return 0; + if(!udb_valid_dataptr(udb, to)) + return 0; + p = UDB_CHUNK(chunk_from_dataptr(to))->ptrlist; + while(p) { + if(!udb_valid_offset(udb, p, sizeof(udb_rel_ptr))) + return 0; + if(p == rptr) + return 1; + p = UDB_REL_PTR(p)->next; + } + return 0; +} + +void udb_rel_ptr_init(udb_rel_ptr* ptr) +{ + memset(ptr, 0, sizeof(*ptr)); +} + +void udb_rel_ptr_unlink(void* base, udb_rel_ptr* ptr) +{ + if(!ptr->data) + return; + if(ptr->prev) { + UDB_REL_PTR(ptr->prev)->next = ptr->next; + } else { + UDB_CHUNK(chunk_from_dataptr(ptr->data))->ptrlist = ptr->next; + } + if(ptr->next) { + UDB_REL_PTR(ptr->next)->prev = ptr->prev; + } +} + +void udb_rel_ptr_link(void* base, udb_rel_ptr* ptr, udb_void to) +{ + udb_chunk_d* chunk = UDB_CHUNK(chunk_from_dataptr(to)); + ptr->prev = 0; + ptr->next = chunk->ptrlist; + if(ptr->next) + UDB_REL_PTR(ptr->next)->prev = UDB_SYSTOREL(base, ptr); + chunk->ptrlist = UDB_SYSTOREL(base, ptr); + ptr->data = to; +} + +void udb_rel_ptr_set(void* base, udb_rel_ptr* ptr, udb_void to) +{ + assert(to == 0 || to > 64); + udb_rel_ptr_unlink(base, ptr); + if(to) + udb_rel_ptr_link(base, ptr, to); + else ptr->data = to; +} + +void udb_rel_ptr_edit(void* base, udb_void list, udb_void to) +{ + udb_void p = list; + while(p) { + UDB_REL_PTR(p)->data = to; + p = UDB_REL_PTR(p)->next; + } +} + +#ifdef UDB_CHECK +/** check that all pointers are validly chained */ +static void +udb_check_ptrs_valid(udb_base* udb) +{ + size_t i; + udb_ptr* p, *prev; + for(i=0; i<udb->ram_size; i++) { + prev = NULL; + for(p=udb->ram_hash[i]; p; p=p->next) { + assert(p->prev == prev); + assert((size_t)(chunk_hash_ptr(p->data)&udb->ram_mask) + == i); + assert(p->base == &udb->base); + prev = p; + } + } +} +#endif /* UDB_CHECK */ + +void udb_ptr_init(udb_ptr* ptr, udb_base* udb) +{ +#ifdef UDB_CHECK + udb_check_ptrs_valid(udb); /* previous ptrs have been unlinked */ +#endif + memset(ptr, 0, sizeof(*ptr)); + ptr->base = &udb->base; +} + +void udb_ptr_set(udb_ptr* ptr, udb_base* udb, udb_void newval) +{ + assert(newval == 0 || newval > 64); + if(ptr->data) + udb_base_unlink_ptr(udb, ptr); + ptr->data = newval; + if(newval) + udb_base_link_ptr(udb, ptr); +} + +int udb_ptr_alloc_space(udb_ptr* ptr, udb_base* udb, udb_chunk_type type, + size_t sz) +{ + udb_void r; + r = udb_alloc_space(udb->alloc, sz); + if(!r) return 0; + udb_alloc_set_type(udb->alloc, r, type); + udb_ptr_init(ptr, udb); + udb_ptr_set(ptr, udb, r); + return 1; +} + +void udb_ptr_free_space(udb_ptr* ptr, udb_base* udb, size_t sz) +{ + if(ptr->data) { + udb_void d = ptr->data; + udb_ptr_set(ptr, udb, 0); + udb_alloc_free(udb->alloc, d, sz); + } +} + +udb_chunk_type udb_ptr_get_type(udb_ptr* ptr) +{ + udb_void f; + if(!ptr || ptr->data == 0) return udb_chunk_type_internal; /* something bad*/ + f = chunk_from_dataptr(ptr->data); + return ((udb_chunk_d*)UDB_REL(*ptr->base, f))->type; +} diff --git a/usr.sbin/nsd/udb.h b/usr.sbin/nsd/udb.h new file mode 100644 index 00000000000..de7985275c2 --- /dev/null +++ b/usr.sbin/nsd/udb.h @@ -0,0 +1,784 @@ +/* udb.h - u(micro) data base, stores data and index information in mmap file. + * By W.C.A. Wijngaards + * Copyright 2010, NLnet Labs. + * BSD, see LICENSE. + */ +#ifndef UDB_H +#define UDB_H +#include <assert.h> + +/** + * The micro data base UDB. + * + * File data.udb is mmapped and used to lookup and edit. + * it contains a header with space-allocation-info, and a reference to the + * base information, an object that is the entry point for the file. + * Then it contains a lot of data and index objects. + * + * The space allocator is 'buddy system', 1megareas, larger get own area. + * So worst case is 2xdata filesize (+header). Growth semi-linear. + * Chunks have size and type (for recovery). Call to reserve space. + * Call to 'realloc-in-place', if space permits. + * + * Usually you want a record-type and its indexes (sorted) to be stored in + * the file. This is a table (named by string). The record is opaque + * data. + * + * To be able to use pointers in the mmapped file, there is conversion of + * relative-pointers(to file base) to system-pointers. + * + * If an item is moved its internal pointers need to be recalculated. + * Thus a recordtype (that has internal pointers) must provide a routine. + * Structures that are 'on-disk', are denoted with _d. Except rel_ptr which + * is also on-disk. + * + * About 64-bit trouble. The pointer-size which which the application is + * compiled determines the file layout, because this makes it perform well + * in a mmap. It could in theory be converted if you really wanted to. + * Nonpointer data is best stored as a fixed bitsize (uint8, 16, 32, 64). + */ +typedef struct udb_base udb_base; +typedef struct udb_alloc udb_alloc; + +/** perform extra checks (when --enable-checking is used) */ +#ifndef NDEBUG +#define UDB_CHECK 1 +#endif + +/** pointers are stored like this */ +typedef uint64_t udb_void; + +/** convert relptr to usable pointer */ +#define UDB_REL(base, relptr) ((base) + (relptr)) +/** from system pointer to relative pointer */ +#define UDB_SYSTOREL(base, ptr) ((udb_void)((void*)(ptr) - (base))) + +/** MAX 2**x exponent of alloced chunks, for 1Mbytes. The smallest + * chunk is 16bytes (8preamble+8data), so 0-3 is unused. */ +#define UDB_ALLOC_CHUNKS_MAX 20 +/** size of areas that are subdivided */ +#define UDB_ALLOC_CHUNK_SIZE ((uint64_t)1<<UDB_ALLOC_CHUNKS_MAX) +/** the minimum alloc in exp, 2**x. 32bytes because of chunk_free_d size (8aligned) */ +#define UDB_ALLOC_CHUNK_MINEXP 5 +/** size of minimum alloc */ +#define UDB_ALLOC_CHUNK_MINSIZE ((uint64_t)1<<UDB_ALLOC_CHUNK_MINEXP) +/** exp size used to mark the header (cannot be reallocated) */ +#define UDB_EXP_HEADER 0 +/** exp size used to mark XL(extralarge) allocations (in whole mbs) */ +#define UDB_EXP_XL 1 + +typedef struct udb_ptr udb_ptr; +/** + * This structure is there for when you want to have a pointer into + * the mmap-ed file. It is kept track of. Set it to NULL to unlink it. + * For pointers to the mmap-ed file from within the mmap-ed file, use the + * rel_pre construct below. + */ +struct udb_ptr { + /** the data segment it points to (relative file offset) */ + uint64_t data; + /** pointer to the base pointer (for convenience) */ + void** base; + /** prev in udb_ptr list for this data segment */ + udb_ptr* prev; + /** next in udb_ptr list for this data segment */ + udb_ptr* next; +}; + +typedef struct udb_rel_ptr udb_rel_ptr; +/** + * A relative pointer that keeps track of the list of pointers, + * so that it can be reallocated. + */ +struct udb_rel_ptr { + /** the relative pointer to the data itself (subtract chunk_d size + * to get the chunk_d type, this is for usage speed in dereferencing + * to the userdata). */ + udb_void data; + /** udb_rel_ptr* prev in relptr list */ + udb_void prev; + /** udb_rel_ptr* next in relptr list */ + udb_void next; +}; + +/** + * This is the routine that is called for every relptr + * @param base: the baseptr for REL. + * @param p: the relptr, a real pointer to it. + * @param arg: user argument. + */ +typedef void udb_walk_relptr_cb(void*, udb_rel_ptr*, void*); + +/** + * This routine calls the callback for every relptr in a datablock + * params in order: + * base: the baseptr for REL macro. + * warg: the walkfunc user argument. + * t: the type of the chunk. + * d: pointer to the data part of the chunk (real pointer). + * s: max size of the data part. + * cb: the callback to call for every element. + * arg: user argument to pass to the callback. + */ +typedef void udb_walk_relptr_func(void*, void*, uint8_t, void*, uint64_t, + udb_walk_relptr_cb*, void*); + +/** What sort of salvage should be performed by alloc */ +enum udb_dirty_alloc { + udb_dirty_clean = 0, /* all clean */ + udb_dirty_fl, /* allocs, freelists are messed up */ + udb_dirty_fsize, /* file size and fsize are messed up */ + udb_dirty_compact /* allocs, freelists and relptrs are messed up */ +}; + +typedef struct udb_glob_d udb_glob_d; +/** + * The UDB global data for a file. This structure is mmapped. + * Make sure it has no structure-padding problems. + */ +struct udb_glob_d { + /** size of header in the file (offset to the first alloced chunk) */ + uint64_t hsize; + /** version number of this file */ + uint8_t version; + /** was the file not cleanly closed, 0 is ok */ + uint8_t clean_close; + /** an allocation operation was in progress, file needs to be salvaged + * type enum udb_dirty_alloc */ + uint8_t dirty_alloc; + /** user flags */ + uint8_t userflags; + /** padding to 8-bytes alignment */ + uint8_t pad1[4]; + /** size to mmap */ + uint64_t fsize; + /** chunk move rollback info: oldchunk (0 is nothing). + * volatile because these values prevent dataloss, they need to be + * written immediately. */ + volatile udb_void rb_old; + /** chunk move rollback info: newchunk (0 is nothing) */ + volatile udb_void rb_new; + /** size of move rollback chunks */ + volatile uint64_t rb_size; + /** segment of move rollback, for an XL chunk that overlaps. */ + volatile uint64_t rb_seg; + /** linked list for content-listing, 0 if empty */ + udb_rel_ptr content_list; + /** user global data pointer */ + udb_rel_ptr user_global; +}; + +/** + * The UDB database file. Contains all the data + */ +struct udb_base { + /** name of the file, alloced */ + char* fname; + + /** mmap base pointer (or NULL) */ + void* base; + /** size of mmap */ + size_t base_size; + /** fd of mmap (if -1, closed). */ + int fd; + + /** space allocator that is used for this base */ + udb_alloc* alloc; + /** real pointer to the global data in the file */ + udb_glob_d* glob_data; + + /** store all linked udb_ptrs in this table, by hash(offset). + * then a linked list of ptrs (all that match the hash). + * this avoids buckets, and thus memory allocation. */ + udb_ptr** ram_hash; + /** size of the current udb_ptr hashtable array */ + size_t ram_size; + /** mask for the curren udb_ptr hashtable lookups */ + int ram_mask; + /** number of ptrs in ram, used to decide when to grow */ + size_t ram_num; + /** for relocation, this walks through all relptrs in chunk */ + udb_walk_relptr_func* walkfunc; + /** user data for walkfunc */ + void* walkarg; +}; + +typedef enum udb_chunk_type udb_chunk_type; +/** chunk type enum, setting these types help recovery and debug */ +enum udb_chunk_type { + udb_chunk_type_free = 0, + udb_chunk_type_data, /* alloced data */ + udb_chunk_type_index, + udb_chunk_type_radtree, + udb_chunk_type_radnode, + udb_chunk_type_radarray, + udb_chunk_type_zone, + udb_chunk_type_domain, + udb_chunk_type_rrset, + udb_chunk_type_rr, + udb_chunk_type_task, + udb_chunk_type_internal +}; + +typedef struct udb_chunk_d udb_chunk_d; +/** + * UDB chunk info (prepended for every allocated chunk). + * The chunks are in doublelinkedlists per size. + * At the end of the chunk another exp uint8 is stored (to walk backwards). + * 17 bytes overhead, datasize for 32byte chunk is 15. + */ +struct udb_chunk_d { + /** the size of this chunk (i.e. 2**x) */ + uint8_t exp; + /** type for this chunk (enum chunktype; free, data or index) */ + uint8_t type; + /** flags for this chunk */ + uint8_t flags; + /** padding onto 8-alignment */ + uint8_t pad[5]; + /** udb_rel_ptr* first in list of rel-ptrs that point back here + * In the free chunk this is the previous pointer. */ + udb_void ptrlist; + /* user data space starts here, 64-bit aligned */ + uint8_t data[0]; + /* last octet: exp of chunk */ +}; + +typedef struct udb_free_chunk_d udb_free_chunk_d; +/** + * A free chunk. Same start as the udb_chunk_d. minsize is 32 bytes. + */ +struct udb_free_chunk_d { + /** the size of this chunk (i.e. 2**x) */ + uint8_t exp; + /** type for this chunk (enum chunktype; free, data or index) */ + uint8_t type; + /** flags for this chunk */ + uint8_t flags; + /** padding onto 8-alignment */ + uint8_t pad[5]; + /** udb_chunk_d* prev of free list for this size */ + udb_void prev; + /** udb_chunk_d* next of free list for this size */ + udb_void next; + /* empty stuff */ + /* last octet: exp of chunk */ +}; + +typedef struct udb_xl_chunk_d udb_xl_chunk_d; +/** + * an Extra Large (XL) chunk. Same start as the udb_chunk_d. Allocated in whole + * MAX_CHUNK_SIZE parts, whole megabytes. overhead is 5x8=40 bytes. + */ +struct udb_xl_chunk_d { + /** the size of this chunk (i.e. 2**x): special XL value */ + uint8_t exp; + /** type for this chunk (enum chunktype; free, data or index) */ + uint8_t type; + /** flags for this chunk */ + uint8_t flags; + /** padding onto 8-alignment */ + uint8_t pad[5]; + /** udb_rel_ptr* first in list of rel-ptrs that point back here + * In the free chunk this is the previous pointer. */ + udb_void ptrlist; + /** size of this chunk in bytes */ + uint64_t size; + /** data of the XL chunk */ + uint8_t data[0]; + /* uint64_t endsize: before last octet the size again. */ + /* uint8_t pad[7]: padding to make last octet last. */ + /* last octet: exp of chunk: special XL value */ +}; + +typedef struct udb_alloc_d udb_alloc_d; +/** + * UDB alloc info on disk. + */ +struct udb_alloc_d { + /** stats: number of data bytes allocated, sum of sizes passed to alloc */ + uint64_t stat_data; + /** stats: number of bytes in free chunks, sum of their 2**x size */ + uint64_t stat_free; + /** stats: number of bytes in alloced chunks, sum of their 2**x size */ + uint64_t stat_alloc; + /** offset to create next chunk at. can be before file-end, or be + * fsize, volatile because it is used as a 'commit', and thus we want + * this to be written to memory (and thus disk) immediately. */ + volatile uint64_t nextgrow; + /** fixed size array the points to the 2**x size chunks in the file, + * This is the start of the doublelinked list, ptr to udb_free_chunk_d. + * array starts at UDB_ALLOC_CHUNK_MINEXP entry as [0]. */ + udb_void free[UDB_ALLOC_CHUNKS_MAX-UDB_ALLOC_CHUNK_MINEXP+1]; +}; + +/** + * The UDB space allocator. Assigns space in the file. + */ +struct udb_alloc { + /** the base this is part of */ + udb_base* udb; + /** real pointer to space allocation info on disk; fixedsize struct */ + udb_alloc_d* disk; +}; + +/** + * file header length, the file start with + * 64bit: magic number to identify file (and prevent stupid mistakes) + * globdata: global data. Fixed size segment. (starts with size uint64) + * allocdata: alloc global data. Fixed size segment. + * size and 0 byte: end marker for reverse search. + */ +#define UDB_HEADER_SIZE (sizeof(uint64_t)+sizeof(udb_glob_d)+ \ + sizeof(udb_alloc_d)+sizeof(uint64_t)*2) +/** magic string that starts an UDB file, uint64_t, note first byte=0, to mark + * header start as a chunk. */ +#define UDB_MAGIC (((uint64_t)'u'<<48)|((uint64_t)'d'<<40)|((uint64_t)'b' \ + <<32)|((uint64_t)'v'<<24)|((uint64_t)'0'<<16)|((uint64_t)'a'<<8)) + +/* UDB BASE */ +/** + * Create udb base structure and attempt to read the file. + * @param fname: file name. + * @param walkfunc: function to walk through relptrs in chunk. + * @param arg: user argument to pass to walkfunc + * @return base structure or NULL on failure. + */ +udb_base* udb_base_create_read(const char* fname, udb_walk_relptr_func walkfunc, + void* arg); + +/** + * Create udb base structure and create a new file. + * @param fname: file name. + * @param walkfunc: function to walk through relptrs in chunk. + * @param arg: user argument to pass to walkfunc + * @return base structure or NULL on failure. + */ +udb_base* udb_base_create_new(const char* fname, udb_walk_relptr_func walkfunc, + void* arg); + +/** + * Create udb from (O_RDWR) fd. + * @param fname: file name. + * @param fd: file descriptor. + * @param walkfunc: function to walk through relptrs in chunk. + * @param arg: user argument to pass to walkfunc + * @return base structure or NULL on failure. + */ +udb_base* udb_base_create_fd(const char* fname, int fd, + udb_walk_relptr_func walkfunc, void* arg); + +/** + * Properly close the UDB base file. Separate from delete so the + * most important bits (write to disk, sockets) can be done first. + * @param udb: the udb. + */ +void udb_base_close(udb_base* udb); + +/** + * Free the data structure (and close if not already) the udb. + * @param udb: the udb. + */ +void udb_base_free(udb_base* udb); + +/** + * Free the udb, but keep mmap mapped for others. + * @param udb: the udb. + */ +void udb_base_free_keep_mmap(udb_base* udb); + +/** + * Sync the mmap. + * @param udb: the udb. + * @param wait: if true, the call blocks until synced. + */ +void udb_base_sync(udb_base* udb, int wait); + +/** + * The mmap size is updated to reflect changes by another process. + * @param udb: the udb. + */ +void udb_base_remap_process(udb_base* udb); + +/** + * get the user data (relative) pointer. + * @param udb: the udb. + * @return the userdata relative pointer, 0 means nothing. + */ +udb_rel_ptr* udb_base_get_userdata(udb_base* udb); + +/** + * Set the user data (relative) pointer. + * @param udb: the udb. + * @param user: user data. offset-pointer (or 0). + */ +void udb_base_set_userdata(udb_base* udb, udb_void user); + +/** + * Set the user flags (to any value, uint8). + * @param udb: the udb. + * @param v: new value. + */ +void udb_base_set_userflags(udb_base* udb, uint8_t v); + +/** + * Get the user flags. + * @param udb: the udb. + * @param v: new value. + */ +uint8_t udb_base_get_userflags(udb_base* udb); + +/** + * Not for users of udb_base, but for udb_ptr. + * Link in a new ptr that references a data segment. + * @param udb: the udb. + * @param ptr: to link in. + */ +void udb_base_link_ptr(udb_base* udb, udb_ptr* ptr); + +/** + * Not for users of udb_base, but for udb_ptr. + * Unlink a ptr that references a data segment. + * @param udb: the udb. + * @param ptr: to unlink. + */ +void udb_base_unlink_ptr(udb_base* udb, udb_ptr* ptr); + +/* UDB ALLOC */ +/** + * Utility for alloc, find 2**x size that is bigger than the given size. + * Does not work for amount==0. + * @param amount: amount of memory. + * @return x; the exponent where 2**x >= amount. + */ +int udb_exp_size(uint64_t amount); + +/** + * Utility for alloc, what is the size that the current offset supports + * as a maximum 2**x chunk. + * Does not work for offset = 0 (result is infinite). + * @param offset: the offset into the memory region. + * @return maximum exponent where 2**x is fits the offset, thus + * offset % (2**x) == 0 and x cannot be larger. + */ +int udb_exp_offset(uint64_t offset); + +/** + * Convert pointer to the data part to a pointer to the base of the chunk. + * @param data: data part. + * @return pointer to the base of the chunk. + */ +udb_void chunk_from_dataptr_ext(udb_void data); + +/** + * Create empty UDB allocate structure to write to disk to initialize file. + * @param a: allocation structure to initialize. system pointer. + */ +void udb_alloc_init_new(udb_alloc_d* a); + +/** + * Create new udb allocator, with specific data on disk + * @param udb: the udb. + * @param disk: disk data. + * @return udb allocator or NULL on (malloc) failure. + */ +udb_alloc* udb_alloc_create(udb_base* udb, udb_alloc_d* disk); + +/** + * Free the udb allocator from memory. + * @param alloc: the udb space allocator. + */ +void udb_alloc_delete(udb_alloc* alloc); + +/** + * Allocate space on the disk. + * This may involve closing and reopening the mmap. + * @param alloc: the udb space allocator. + * @param sz: size you want to use. + * @return relative pointer (or 0 on alloc failure). + */ +udb_void udb_alloc_space(udb_alloc* alloc, size_t sz); + +/** + * Allocate space on disk, give already the data you want there. + * This may involve closing and reopening the mmap. + * @param alloc: the udb space allocator. + * @param d: data you want there (system pointer). + * @param sz: size you want to use. + * @return relative pointer (or 0 on alloc failure). + */ +udb_void udb_alloc_init(udb_alloc* alloc, void* d, size_t sz); + +/** + * free allocated space. It may shrink the file. + * This may involve closing and reopening the mmap. + * @param alloc: the udb space allocator. + * @param r: relative pointer to data you want to free. + * @param sz: the size of the data you stop using. + * @return false if the free failed, it failed the close and mmap. + */ +int udb_alloc_free(udb_alloc* alloc, udb_void r, size_t sz); + +/** + * realloc an existing allocated space. It may grow the file. + * This may involve closing and reopening the mmap. + * It could also use the existing space where it is now. + * @param alloc: the udb space allocator. + * @param r: relative pointer to data you want to realloc. + * if 0 then this is alloc_space(), and osz is ignored. + * @param osz: the old size of the data. + * @param sz: the size of the data you want to get. + * if this is 0 then a free() is done, but please do it directly, + * as you then get a returnvalue (file errors). + * @return relative pointer (0 on alloc failure, same if not moved). + */ +udb_void udb_alloc_realloc(udb_alloc* alloc, udb_void r, size_t osz, + size_t sz); + +/** + * Prepare for a lot of new entries. Grow space for that. + * This can involve closing and reopening the mmap. + * This space (if large) is going to be released on next free() or close(). + * @param alloc: the udb space allocator. + * @param sz: size of the entries. + * @param num: number of entries. + * @return false on failure to grow or re-mmap. + */ +int udb_alloc_grow(udb_alloc* alloc, size_t sz, size_t num); + +/** + * Set the alloc type for a newly alloced piece of data + * @param alloc: the udb space allocator. + * @param r: relativeptr to the data. + * @param tp: the type of that block. + */ +void udb_alloc_set_type(udb_alloc* alloc, udb_void r, udb_chunk_type tp); + +/** + * See if a pointer could be valid (it points within valid space), + * for the given type side. For debug checks. + * @param udb: the udb + * @param to: the ptr (offset). + * @param destsize: the size_of of the destination of the pointer. + * @return true if it points to a valid region. + */ +int udb_valid_offset(udb_base* udb, udb_void to, size_t destsize); + +/** + * See if a pointer is valid (it points to a chunk). For debug checks. + * @param udb: the udb. + * @param to: the ptr (offset). + * @return true if it points to the start of a chunks data region. + */ +int udb_valid_dataptr(udb_base* udb, udb_void to); + +/** + * See if a pointer is on the relptrlist for dataptr. For debug checks. + * @param udb: the udb. + * @param rptr: the rel_ptr (offset). + * @param to: dataptr of the chunk on which ptrlist the rptr is searched. + * @return true if rptr is valid and on the ptrlist. + */ +int udb_valid_rptr(udb_base* udb, udb_void rptr, udb_void to); + +/*** UDB_REL_PTR ***/ +/** + * Init a new UDB rel ptr at NULL. + * @param ptr: sysptr, becomes inited. + */ +void udb_rel_ptr_init(udb_rel_ptr* ptr); + +/** + * Unlink a UDB rel ptr. + * @param base: the udb base + * @param ptr: sysptr, unlinked + */ +void udb_rel_ptr_unlink(void* base, udb_rel_ptr* ptr); + +/** + * Link a UDB rel ptr to a new chunk + * @param base: the udb base + * @param ptr: sysptr, linked to new value. + * @param to: the data to point to (relative ptr). + */ +void udb_rel_ptr_link(void* base, udb_rel_ptr* ptr, udb_void to); + +/** + * Change rel ptr to a new value (point to another record) + * @param base: the udb base + * @param ptr: sysptr, points to new value. + * @param to: the data to point to (relative ptr). + */ +void udb_rel_ptr_set(void* base, udb_rel_ptr* ptr, udb_void to); + +/** + * A chunk has moved and now edit all the relptrs in list to fix them up + * @param base: the udb base + * @param list: start of the ptr list + * @param to: where the chunk has moved to relptr to its userdata. + */ +void udb_rel_ptr_edit(void* base, udb_void list, udb_void to); + +/** + * Get system pointer. Assumes there is a variable named 'base' + * that points to the udb base. + * @param ptr: the relative pointer (a sysptr to it). + * @return void* to the data. + */ +#define UDB_SYSPTR(ptr) UDB_REL(base, (ptr)->data) + +/** get sys ptr for char* string */ +#define UDB_CHAR(ptr) ((char*)UDB_REL(base, ptr)) +/** get sys ptr for udb_rel_ptr */ +#define UDB_REL_PTR(ptr) ((udb_rel_ptr*)UDB_REL(base, ptr)) +/** get sys ptr for udb_glob_d */ +#define UDB_GLOB(ptr) ((udb_glob_d*)UDB_REL(base, ptr)) +/** get sys ptr for udb_chunk_d */ +#define UDB_CHUNK(ptr) ((udb_chunk_d*)UDB_REL(base, ptr)) +/** get sys ptr for udb_free_chunk_d */ +#define UDB_FREE_CHUNK(ptr) ((udb_free_chunk_d*)UDB_REL(base, ptr)) +/** get sys ptr for udb_xl_chunk_d */ +#define UDB_XL_CHUNK(ptr) ((udb_xl_chunk_d*)UDB_REL(base, ptr)) + +/* udb_ptr */ +/** + * Initialize an udb ptr. Set to NULL. (and thus not linked can be deleted). + * You MUST set it to 0 before you stop using the ptr. + * @param ptr: the ptr to initialise (caller has allocated it). + * @param udb: the udb base to link it to. + */ +void udb_ptr_init(udb_ptr* ptr, udb_base* udb); + +/** + * Set udp ptr to a new value. If set to NULL you can delete it. + * @param ptr: the ptr. + * @param udb: the udb base to link up with that data segment's administration. + * @param newval: new value to point to (udb_void relative file offset to data). + */ +void udb_ptr_set(udb_ptr* ptr, udb_base* udb, udb_void newval); + +/** dereference udb_ptr */ +#define UDB_PTR(ptr) (UDB_REL(*((ptr)->base), (ptr)->data)) + +/** + * Ease of use udb ptr, allocate space and return ptr to it + * You MUST udb_ptr_set it to 0 before you stop using the ptr. + * @param base: udb base to use. + * @param ptr: ptr is overwritten, can be uninitialised. + * @param type: type of the allocation. + * You need a special type if the block contains udb_rel_ptr's. + * You can use udb_type_data for plain data. + * @param sz: amount to allocate. + * @return 0 on alloc failure. + */ +int udb_ptr_alloc_space(udb_ptr* ptr, udb_base* udb, udb_chunk_type type, + size_t sz); + +/** + * Ease of use udb ptr, free space and set ptr to NULL (to it can be deleted). + * The space is freed on disk. + * @param ptr: the ptr. + * @param udb: udb base. + * @param sz: the size of the data you stop using. + */ +void udb_ptr_free_space(udb_ptr* ptr, udb_base* udb, size_t sz); + +/** + * Get pointer to the data of the ptr. or use a macro to cast UDB_PTR to + * the type of your structure(.._d) + */ +static inline uint8_t* udb_ptr_data(udb_ptr* ptr) { + return (uint8_t*)UDB_PTR(ptr); +} + +/** + * See if udb ptr is null + */ +static inline int udb_ptr_is_null(udb_ptr* ptr) { + return (ptr->data == 0); +} + +/** + * Get the type of a udb_ptr chunk. + * @param ptr: udb pointer + * @return type of chunk */ +udb_chunk_type udb_ptr_get_type(udb_ptr* ptr); + +/** Ease of use, create new pointer to destination relptr + * You MUST udb_ptr_set it to 0 before you stop using the ptr. */ +static inline void udb_ptr_new(udb_ptr* ptr, udb_base* udb, udb_rel_ptr* d) { + udb_ptr_init(ptr, udb); + udb_ptr_set(ptr, udb, d->data); +} + +/** Ease of use. Stop using this ptr */ +static inline void udb_ptr_unlink(udb_ptr* ptr, udb_base* udb) { + if(ptr->data) + udb_base_unlink_ptr(udb, ptr); +} + +/* Ease of use. Assign rptr from rptr */ +static inline void udb_rptr_set_rptr(udb_rel_ptr* dest, udb_base* udb, + udb_rel_ptr* p) { +#ifdef UDB_CHECK + if(dest->data) { assert(udb_valid_rptr(udb, + UDB_SYSTOREL(udb->base, dest), dest->data)); } + if(p->data) { assert(udb_valid_rptr(udb, + UDB_SYSTOREL(udb->base, p), p->data)); } +#endif + udb_rel_ptr_set(udb->base, dest, p->data); +} + +/* Ease of use. Assign rptr from ptr */ +static inline void udb_rptr_set_ptr(udb_rel_ptr* dest, udb_base* udb, + udb_ptr* p) { +#ifdef UDB_CHECK + if(dest->data) { assert(udb_valid_rptr(udb, + UDB_SYSTOREL(udb->base, dest), dest->data)); } + if(p->data) { assert(udb_valid_dataptr(udb, p->data)); } +#endif + udb_rel_ptr_set(udb->base, dest, p->data); +} + +/* Ease of use. Assign ptr from rptr */ +static inline void udb_ptr_set_rptr(udb_ptr* dest, udb_base* udb, + udb_rel_ptr* p) { +#ifdef UDB_CHECK + if(p->data) { assert(udb_valid_rptr(udb, + UDB_SYSTOREL(udb->base, p), p->data)); } +#endif + udb_ptr_set(dest, udb, p->data); +} + +/* Ease of use. Assign ptr from ptr */ +static inline void udb_ptr_set_ptr(udb_ptr* dest, udb_base* udb, udb_ptr* p) { + udb_ptr_set(dest, udb, p->data); +} + +/* Ease of use, zero rptr. You use this to zero an existing pointer. + * A new rptr should be rel_ptr_init-ed before it is taken into use. */ +static inline void udb_rptr_zero(udb_rel_ptr* dest, udb_base* udb) { +#ifdef UDB_CHECK + if(dest->data) { assert(udb_valid_rptr(udb, + UDB_SYSTOREL(udb->base, dest), dest->data)); } +#endif + udb_rel_ptr_set(udb->base, dest, 0); +} + +/* Ease of use, zero ptr */ +static inline void udb_ptr_zero(udb_ptr* dest, udb_base* udb) { + udb_ptr_set(dest, udb, 0); +} + +/** ease of use, delete memory pointed at by relptr */ +static inline void udb_rel_ptr_free_space(udb_rel_ptr* ptr, udb_base* udb, + size_t sz) { + udb_void d = ptr->data; +#ifdef UDB_CHECK + if(d) { assert(udb_valid_rptr(udb, UDB_SYSTOREL(udb->base, ptr), d)); } +#endif + udb_rel_ptr_set(udb->base, ptr, 0); + udb_alloc_free(udb->alloc, d, sz); +} + +#endif /* UDB_H */ diff --git a/usr.sbin/nsd/udbradtree.c b/usr.sbin/nsd/udbradtree.c new file mode 100644 index 00000000000..d9be6b9c255 --- /dev/null +++ b/usr.sbin/nsd/udbradtree.c @@ -0,0 +1,1463 @@ +/* + * udbradtree -- radix tree for binary strings for in udb file. + * + * Copyright (c) 2011, NLnet Labs. See LICENSE for license. + */ +#include "config.h" +#include <string.h> +#include <assert.h> +#include <stdio.h> +#include "udbradtree.h" +#include "radtree.h" +#define RADARRAY(ptr) ((struct udb_radarray_d*)UDB_PTR(ptr)) + +/** see if radarray can be reduced (by a factor of two) */ +static int udb_radarray_reduce_if_needed(udb_base* udb, udb_ptr* n); + +int udb_radix_tree_create(udb_base* udb, udb_ptr* ptr) +{ + if(!udb_ptr_alloc_space(ptr, udb, udb_chunk_type_radtree, + sizeof(struct udb_radtree_d))) + return 0; + udb_rel_ptr_init(&RADTREE(ptr)->root); + RADTREE(ptr)->count = 0; + return 1; +} + +/** size of radarray */ +static size_t size_of_radarray(struct udb_radarray_d* a) +{ + return sizeof(struct udb_radarray_d)+((size_t)a->capacity)*( + sizeof(struct udb_radsel_d)+(size_t)a->str_cap); +} + +/** size in bytes of data in the array lookup structure */ +static size_t size_of_lookup(udb_ptr* node) +{ + assert(udb_ptr_get_type(node) == udb_chunk_type_radnode); + return size_of_radarray((struct udb_radarray_d*)UDB_REL(*node->base, + RADNODE(node)->lookup.data)); +} + +/** external variant, size in bytes of data in the array lookup structure */ +size_t size_of_lookup_ext(udb_ptr* lookup) +{ + return size_of_lookup(lookup); +} + +/** size needed for a lookup array like this */ +static size_t size_of_lookup_needed(uint16_t capacity, udb_radstrlen_t str_cap) +{ + return sizeof(struct udb_radarray_d)+ ((size_t)capacity)*( + sizeof(struct udb_radsel_d)+(size_t)str_cap); +} + +/** get the lookup array for a node */ +static struct udb_radarray_d* lookup(udb_ptr* n) +{ + assert(udb_ptr_get_type(n) == udb_chunk_type_radnode); + return (struct udb_radarray_d*)UDB_REL(*n->base, + RADNODE(n)->lookup.data); +} + +/** get a length in the lookup array */ +static udb_radstrlen_t lookup_len(udb_ptr* n, unsigned i) +{ + return lookup(n)->array[i].len; +} + +/** get a string in the lookup array */ +static uint8_t* lookup_string(udb_ptr* n, unsigned i) +{ + return ((uint8_t*)&(lookup(n)->array[lookup(n)->capacity]))+ + i*lookup(n)->str_cap; +} + +/** get a node in the lookup array */ +static struct udb_radnode_d* lookup_node(udb_ptr* n, unsigned i) +{ + return (struct udb_radnode_d*)UDB_REL(*n->base, + lookup(n)->array[i].node.data); +} + +/** zero the relptrs in radarray */ +static void udb_radarray_zero_ptrs(udb_base* udb, udb_ptr* n) +{ + unsigned i; + for(i=0; i<lookup(n)->len; i++) { + udb_rptr_zero(&lookup(n)->array[i].node, udb); + } +} + +/** delete a radnode */ +static void udb_radnode_delete(udb_base* udb, udb_ptr* n) +{ + if(udb_ptr_is_null(n)) + return; + if(RADNODE(n)->lookup.data) { + udb_radarray_zero_ptrs(udb, n); + udb_rel_ptr_free_space(&RADNODE(n)->lookup, udb, + size_of_lookup(n)); + } + udb_rptr_zero(&RADNODE(n)->lookup, udb); + udb_rptr_zero(&RADNODE(n)->parent, udb); + udb_rptr_zero(&RADNODE(n)->elem, udb); + udb_ptr_free_space(n, udb, sizeof(struct udb_radnode_d)); +} + +/** delete radnodes in postorder recursion, n is ptr to node */ +static void udb_radnode_del_postorder(udb_base* udb, udb_ptr* n) +{ + unsigned i; + udb_ptr sub; + if(udb_ptr_is_null(n)) + return; + /* clear subnodes */ + udb_ptr_init(&sub, udb); + for(i=0; i<lookup(n)->len; i++) { + udb_ptr_set_rptr(&sub, udb, &lookup(n)->array[i].node); + udb_rptr_zero(&lookup(n)->array[i].node, udb); + udb_radnode_del_postorder(udb, &sub); + } + udb_ptr_unlink(&sub, udb); + /* clear lookup */ + udb_rel_ptr_free_space(&RADNODE(n)->lookup, udb, size_of_lookup(n)); + udb_rptr_zero(&RADNODE(n)->parent, udb); + udb_rptr_zero(&RADNODE(n)->elem, udb); + udb_ptr_free_space(n, udb, sizeof(struct udb_radnode_d)); +} + +void udb_radix_tree_clear(udb_base* udb, udb_ptr* rt) +{ + udb_ptr root; + udb_ptr_new(&root, udb, &RADTREE(rt)->root); + udb_rptr_zero(&RADTREE(rt)->root, udb); + /* free the root node (and its descendants, if any) */ + udb_radnode_del_postorder(udb, &root); + udb_ptr_unlink(&root, udb); + + RADTREE(rt)->count = 0; +} + +void udb_radix_tree_delete(udb_base* udb, udb_ptr* rt) +{ + if(rt->data == 0) return; + assert(udb_ptr_get_type(rt) == udb_chunk_type_radtree); + udb_radix_tree_clear(udb, rt); + udb_ptr_free_space(rt, udb, sizeof(struct udb_radtree_d)); +} + +/** + * Find a prefix of the key, in whole-nodes. + * Finds the longest prefix that corresponds to a whole radnode entry. + * There may be a slightly longer prefix in one of the array elements. + * @param result: the longest prefix, the entry itself if *respos==len, + * otherwise an array entry, residx. Output. + * @param respos: pos in string where next unmatched byte is, if == len an + * exact match has been found. If == 0 then a "" match was found. + * @return false if no prefix found, not even the root "" prefix. + */ +static int udb_radix_find_prefix_node(udb_base* udb, udb_ptr* rt, uint8_t* k, + udb_radstrlen_t len, udb_ptr* result, udb_radstrlen_t* respos) +{ + udb_radstrlen_t pos = 0; + uint8_t byte; + udb_ptr n; + udb_ptr_new(&n, udb, &RADTREE(rt)->root); + + *respos = 0; + udb_ptr_set_ptr(result, udb, &n); + if(udb_ptr_is_null(&n)) { + udb_ptr_unlink(&n, udb); + return 0; + } + while(!udb_ptr_is_null(&n)) { + if(pos == len) { + break; + } + byte = k[pos]; + if(byte < RADNODE(&n)->offset) { + break; + } + byte -= RADNODE(&n)->offset; + if(byte >= lookup(&n)->len) { + break; + } + pos++; + if(lookup(&n)->array[byte].len != 0) { + /* must match additional string */ + if(pos+lookup(&n)->array[byte].len > len) { + break; + } + if(memcmp(&k[pos], lookup_string(&n, byte), + lookup(&n)->array[byte].len) != 0) { + break; + } + pos += lookup(&n)->array[byte].len; + } + udb_ptr_set_rptr(&n, udb, &lookup(&n)->array[byte].node); + if(udb_ptr_is_null(&n)) { + break; + } + *respos = pos; + udb_ptr_set_ptr(result, udb, &n); + } + udb_ptr_unlink(&n, udb); + return 1; +} + +/** grow the radnode stringcapacity, copy existing elements */ +static int udb_radnode_str_grow(udb_base* udb, udb_ptr* n, udb_radstrlen_t want) +{ + unsigned ns = ((unsigned)lookup(n)->str_cap)*2; + unsigned i; + udb_ptr a; + if(want > ns) + ns = want; + if(ns > 65535) ns = 65535; /* MAX of udb_radstrlen_t range */ + /* if this fails, the tree is still usable */ + if(!udb_ptr_alloc_space(&a, udb, udb_chunk_type_radarray, + size_of_lookup_needed(lookup(n)->capacity, ns))) + return 0; + /* make sure to zero the newly allocated relptrs to init them */ + memcpy(RADARRAY(&a), lookup(n), sizeof(struct udb_radarray_d)); + RADARRAY(&a)->str_cap = ns; + for(i = 0; i < lookup(n)->len; i++) { + udb_rel_ptr_init(&RADARRAY(&a)->array[i].node); + udb_rptr_set_rptr(&RADARRAY(&a)->array[i].node, udb, + &lookup(n)->array[i].node); + RADARRAY(&a)->array[i].len = lookup_len(n, i); + memmove(((uint8_t*)(&RADARRAY(&a)->array[ + lookup(n)->capacity]))+i*ns, + lookup_string(n, i), lookup(n)->str_cap); + } + udb_radarray_zero_ptrs(udb, n); + udb_rel_ptr_free_space(&RADNODE(n)->lookup, udb, size_of_lookup(n)); + udb_rptr_set_ptr(&RADNODE(n)->lookup, udb, &a); + udb_ptr_unlink(&a, udb); + return 1; +} + +/** grow the radnode array, copy existing elements to start of new array */ +static int udb_radnode_array_grow(udb_base* udb, udb_ptr* n, size_t want) +{ + unsigned i; + unsigned ns = ((unsigned)lookup(n)->capacity)*2; + udb_ptr a; + assert(want <= 256); /* cannot be more, range of uint8 */ + if(want > ns) + ns = want; + if(ns > 256) ns = 256; + /* if this fails, the tree is still usable */ + if(!udb_ptr_alloc_space(&a, udb, udb_chunk_type_radarray, + size_of_lookup_needed(ns, lookup(n)->str_cap))) + return 0; + /* zero the newly allocated rel ptrs to init them */ + memset(UDB_PTR(&a), 0, size_of_lookup_needed(ns, lookup(n)->str_cap)); + assert(lookup(n)->len <= lookup(n)->capacity); + assert(lookup(n)->capacity < ns); + memcpy(RADARRAY(&a), lookup(n), sizeof(struct udb_radarray_d)); + RADARRAY(&a)->capacity = ns; + for(i=0; i<lookup(n)->len; i++) { + udb_rptr_set_rptr(&RADARRAY(&a)->array[i].node, udb, + &lookup(n)->array[i].node); + RADARRAY(&a)->array[i].len = lookup_len(n, i); + } + memmove(&RADARRAY(&a)->array[ns], lookup_string(n, 0), + lookup(n)->len * lookup(n)->str_cap); + udb_radarray_zero_ptrs(udb, n); + udb_rel_ptr_free_space(&RADNODE(n)->lookup, udb, size_of_lookup(n)); + udb_rptr_set_ptr(&RADNODE(n)->lookup, udb, &a); + udb_ptr_unlink(&a, udb); + return 1; +} + +/** make empty array in radnode */ +static int udb_radnode_array_create(udb_base* udb, udb_ptr* n) +{ + /* is there an array? */ + if(RADNODE(n)->lookup.data == 0) { + /* create array */ + udb_ptr a; + uint16_t cap = 0; + udb_radstrlen_t len = 0; + if(!udb_ptr_alloc_space(&a, udb, udb_chunk_type_radarray, + size_of_lookup_needed(cap, len))) + return 0; + memset(UDB_PTR(&a), 0, size_of_lookup_needed(cap, len)); + udb_rptr_set_ptr(&RADNODE(n)->lookup, udb, &a); + RADARRAY(&a)->len = cap; + RADARRAY(&a)->capacity = cap; + RADARRAY(&a)->str_cap = len; + RADNODE(n)->offset = 0; + udb_ptr_unlink(&a, udb); + } + return 1; +} + +/** make space in radnode for another byte, or longer strings */ +static int udb_radnode_array_space(udb_base* udb, udb_ptr* n, uint8_t byte, + udb_radstrlen_t len) +{ + /* is there an array? */ + if(RADNODE(n)->lookup.data == 0) { + /* create array */ + udb_ptr a; + uint16_t cap = 1; + if(!udb_ptr_alloc_space(&a, udb, udb_chunk_type_radarray, + size_of_lookup_needed(cap, len))) + return 0; + /* this memset inits the relptr that is allocated */ + memset(UDB_PTR(&a), 0, size_of_lookup_needed(cap, len)); + udb_rptr_set_ptr(&RADNODE(n)->lookup, udb, &a); + RADARRAY(&a)->len = cap; + RADARRAY(&a)->capacity = cap; + RADARRAY(&a)->str_cap = len; + RADNODE(n)->offset = byte; + udb_ptr_unlink(&a, udb); + return 1; + } + if(lookup(n)->capacity == 0) { + if(!udb_radnode_array_grow(udb, n, 1)) + return 0; + } + + /* make space for this stringsize */ + if(lookup(n)->str_cap < len) { + /* must resize for stringsize */ + if(!udb_radnode_str_grow(udb, n, len)) + return 0; + } + + /* other cases */ + /* is the array unused? */ + if(lookup(n)->len == 0 && lookup(n)->capacity != 0) { + lookup(n)->len = 1; + RADNODE(n)->offset = byte; + memset(&lookup(n)->array[0], 0, sizeof(struct udb_radsel_d)); + /* is it below the offset? */ + } else if(byte < RADNODE(n)->offset) { + /* is capacity enough? */ + int i; + unsigned need = RADNODE(n)->offset-byte; + if(lookup(n)->len+need > lookup(n)->capacity) { + /* grow array */ + if(!udb_radnode_array_grow(udb, n, lookup(n)->len+need)) + return 0; + } + /* take a piece of capacity into use, init the relptrs */ + for(i = lookup(n)->len; i< (int)(lookup(n)->len + need); i++) { + udb_rel_ptr_init(&lookup(n)->array[i].node); + } + /* reshuffle items to end */ + for(i = lookup(n)->len-1; i >= 0; i--) { + udb_rptr_set_rptr(&lookup(n)->array[need+i].node, + udb, &lookup(n)->array[i].node); + lookup(n)->array[need+i].len = lookup_len(n, i); + /* fixup pidx */ + if(lookup(n)->array[i+need].node.data) + lookup_node(n, i+need)->pidx = i+need; + } + memmove(lookup_string(n, need), lookup_string(n, 0), + lookup(n)->len*lookup(n)->str_cap); + /* zero the first */ + for(i = 0; i < (int)need; i++) { + udb_rptr_zero(&lookup(n)->array[i].node, udb); + lookup(n)->array[i].len = 0; + } + lookup(n)->len += need; + RADNODE(n)->offset = byte; + /* is it above the max? */ + } else if(byte - RADNODE(n)->offset >= lookup(n)->len) { + /* is capacity enough? */ + int i; + unsigned need = (byte-RADNODE(n)->offset) - lookup(n)->len + 1; + /* grow array */ + if(lookup(n)->len + need > lookup(n)->capacity) { + if(!udb_radnode_array_grow(udb, n, lookup(n)->len+need)) + return 0; + } + /* take new entries into use, init relptrs */ + for(i = lookup(n)->len; i< (int)(lookup(n)->len + need); i++) { + udb_rel_ptr_init(&lookup(n)->array[i].node); + lookup(n)->array[i].len = 0; + } + /* grow length */ + lookup(n)->len += need; + } + return 1; +} + +/** make space for string size */ +static int udb_radnode_str_space(udb_base* udb, udb_ptr* n, udb_radstrlen_t len) +{ + if(RADNODE(n)->lookup.data == 0) { + return udb_radnode_array_space(udb, n, 0, len); + } + if(lookup(n)->str_cap < len) { + /* must resize for stringsize */ + if(!udb_radnode_str_grow(udb, n, len)) + return 0; + } + return 1; +} + +/** copy remainder from prefixes for a split: + * plen: len prefix, l: longer bstring, llen: length of l. */ +static void udb_radsel_prefix_remainder(udb_radstrlen_t plen, + uint8_t* l, udb_radstrlen_t llen, + uint8_t* s, udb_radstrlen_t* slen) +{ + *slen = llen - plen; + /* assert(*slen <= lookup(n)->str_cap); */ + memmove(s, l+plen, llen-plen); +} + +/** create a prefix in the array strs */ +static void udb_radsel_str_create(uint8_t* s, udb_radstrlen_t* slen, + uint8_t* k, udb_radstrlen_t pos, udb_radstrlen_t len) +{ + *slen = len-pos; + /* assert(*slen <= lookup(n)->str_cap); */ + memmove(s, k+pos, len-pos); +} + +static udb_radstrlen_t +udb_bstr_common(uint8_t* x, udb_radstrlen_t xlen, + uint8_t* y, udb_radstrlen_t ylen) +{ + assert(sizeof(radstrlen_t) == sizeof(udb_radstrlen_t)); + return bstr_common_ext(x, xlen, y, ylen); +} + +static int +udb_bstr_is_prefix(uint8_t* p, udb_radstrlen_t plen, + uint8_t* x, udb_radstrlen_t xlen) +{ + assert(sizeof(radstrlen_t) == sizeof(udb_radstrlen_t)); + return bstr_is_prefix_ext(p, plen, x, xlen); +} + +/** grow array space for byte N after a string, (but if string shorter) */ +static int +udb_radnode_array_space_strremain(udb_base* udb, udb_ptr* n, + uint8_t* str, udb_radstrlen_t len, udb_radstrlen_t pos) +{ + assert(pos < len); + /* shift by one char because it goes in lookup array */ + return udb_radnode_array_space(udb, n, str[pos], len-(pos+1)); +} + + +/** radsel create a split when two nodes have shared prefix. + * @param udb: udb + * @param n: node with the radsel that gets changed, it contains a node. + * @param idx: the index of the radsel that gets changed. + * @param k: key byte string + * @param pos: position where the string enters the radsel (e.g. r.str) + * @param len: length of k. + * @param add: additional node for the string k. + * removed by called on failure. + * @return false on alloc failure, no changes made. + */ +static int udb_radsel_split(udb_base* udb, udb_ptr* n, uint8_t idx, uint8_t* k, + udb_radstrlen_t pos, udb_radstrlen_t len, udb_ptr* add) +{ + uint8_t* addstr = k+pos; + udb_radstrlen_t addlen = len-pos; + if(udb_bstr_is_prefix(addstr, addlen, lookup_string(n, idx), + lookup_len(n, idx))) { + udb_radstrlen_t split_len = 0; + /* 'add' is a prefix of r.node */ + /* also for empty addstr */ + /* set it up so that the 'add' node has r.node as child */ + /* so, r.node gets moved below the 'add' node, but we do + * this so that the r.node stays the same pointer for its + * key name */ + assert(addlen != lookup_len(n, idx)); + assert(addlen < lookup_len(n, idx)); + /* make space for new string sizes */ + if(!udb_radnode_str_space(udb, n, addlen)) + return 0; + if(lookup_len(n, idx) - addlen > 1) + /* shift one because a char is in the lookup array */ + split_len = lookup_len(n, idx) - (addlen+1); + if(!udb_radnode_array_space(udb, add, + lookup_string(n, idx)[addlen], split_len)) + return 0; + /* alloc succeeded, now link it in */ + udb_rptr_set_rptr(&RADNODE(add)->parent, udb, + &lookup_node(n, idx)->parent); + RADNODE(add)->pidx = lookup_node(n, idx)->pidx; + udb_rptr_set_rptr(&lookup(add)->array[0].node, udb, + &lookup(n)->array[idx].node); + if(lookup_len(n, idx) - addlen > 1) { + udb_radsel_prefix_remainder(addlen+1, + lookup_string(n, idx), lookup_len(n, idx), + lookup_string(add, 0), + &lookup(add)->array[0].len); + } else { + lookup(add)->array[0].len = 0; + } + udb_rptr_set_ptr(&lookup_node(n, idx)->parent, udb, add); + lookup_node(n, idx)->pidx = 0; + + udb_rptr_set_ptr(&lookup(n)->array[idx].node, udb, add); + memmove(lookup_string(n, idx), addstr, addlen); + lookup(n)->array[idx].len = addlen; + /* n's string may have become shorter */ + if(!udb_radarray_reduce_if_needed(udb, n)) { + /* ignore this, our tree has become inefficient */ + } + } else if(udb_bstr_is_prefix(lookup_string(n, idx), lookup_len(n, idx), + addstr, addlen)) { + udb_radstrlen_t split_len = 0; + udb_ptr rnode; + /* r.node is a prefix of 'add' */ + /* set it up so that the 'r.node' has 'add' as child */ + /* and basically, r.node is already completely fine, + * we only need to create a node as its child */ + assert(addlen != lookup_len(n, idx)); + assert(lookup_len(n, idx) < addlen); + udb_ptr_new(&rnode, udb, &lookup(n)->array[idx].node); + /* make space for string length */ + if(addlen-lookup_len(n, idx) > 1) { + /* shift one because a character goes into array */ + split_len = addlen - (lookup_len(n, idx)+1); + } + if(!udb_radnode_array_space(udb, &rnode, + addstr[lookup_len(n, idx)], split_len)) { + udb_ptr_unlink(&rnode, udb); + return 0; + } + /* alloc succeeded, now link it in */ + udb_rptr_set_ptr(&RADNODE(add)->parent, udb, &rnode); + RADNODE(add)->pidx = addstr[lookup_len(n, idx)] - + RADNODE(&rnode)->offset; + udb_rptr_set_ptr(&lookup(&rnode)->array[ RADNODE(add)->pidx ] + .node, udb, add); + if(addlen-lookup_len(n, idx) > 1) { + udb_radsel_prefix_remainder(lookup_len(n, idx)+1, + addstr, addlen, + lookup_string(&rnode, RADNODE(add)->pidx), + &lookup(&rnode)->array[ RADNODE(add)->pidx] + .len); + } else { + lookup(&rnode)->array[ RADNODE(add)->pidx].len = 0; + } + /* rnode's string has become shorter */ + if(!udb_radarray_reduce_if_needed(udb, &rnode)) { + /* ignore this, our tree has become inefficient */ + } + udb_ptr_unlink(&rnode, udb); + } else { + /* okay we need to create a new node that chooses between + * the nodes 'add' and r.node + * We do this so that r.node stays the same pointer for its + * key name. */ + udb_ptr com, rnode; + udb_radstrlen_t common_len = udb_bstr_common( + lookup_string(n, idx), lookup_len(n, idx), + addstr, addlen); + assert(common_len < lookup_len(n, idx)); + assert(common_len < addlen); + udb_ptr_new(&rnode, udb, &lookup(n)->array[idx].node); + + /* create the new node for choice */ + if(!udb_ptr_alloc_space(&com, udb, udb_chunk_type_radnode, + sizeof(struct udb_radnode_d))) { + udb_ptr_unlink(&rnode, udb); + return 0; /* out of space */ + } + memset(UDB_PTR(&com), 0, sizeof(struct udb_radnode_d)); + /* make stringspace for the two substring choices */ + /* this allocates the com->lookup array */ + if(!udb_radnode_array_space_strremain(udb, &com, + lookup_string(n, idx), lookup_len(n, idx), common_len) + || !udb_radnode_array_space_strremain(udb, &com, + addstr, addlen, common_len)) { + udb_ptr_unlink(&rnode, udb); + udb_radnode_delete(udb, &com); + return 0; + } + /* create stringspace for the shared prefix */ + if(common_len > 0) { + if(!udb_radnode_str_space(udb, n, common_len-1)) { + udb_ptr_unlink(&rnode, udb); + udb_radnode_delete(udb, &com); + return 0; + } + } + /* allocs succeeded, proceed to link it all up */ + udb_rptr_set_rptr(&RADNODE(&com)->parent, udb, + &RADNODE(&rnode)->parent); + RADNODE(&com)->pidx = RADNODE(&rnode)->pidx; + udb_rptr_set_ptr(&RADNODE(&rnode)->parent, udb, &com); + RADNODE(&rnode)->pidx = lookup_string(n, idx)[common_len] - + RADNODE(&com)->offset; + udb_rptr_set_ptr(&RADNODE(add)->parent, udb, &com); + RADNODE(add)->pidx = addstr[common_len] - + RADNODE(&com)->offset; + udb_rptr_set_ptr(&lookup(&com)->array[RADNODE(&rnode)->pidx] + .node, udb, &rnode); + if(lookup_len(n, idx)-common_len > 1) { + udb_radsel_prefix_remainder(common_len+1, + lookup_string(n, idx), lookup_len(n, idx), + lookup_string(&com, RADNODE(&rnode)->pidx), + &lookup(&com)->array[RADNODE(&rnode)->pidx].len); + } else { + lookup(&com)->array[RADNODE(&rnode)->pidx].len= 0; + } + udb_rptr_set_ptr(&lookup(&com)->array[RADNODE(add)->pidx] + .node, udb, add); + if(addlen-common_len > 1) { + udb_radsel_prefix_remainder(common_len+1, + addstr, addlen, + lookup_string(&com, RADNODE(add)->pidx), + &lookup(&com)->array[RADNODE(add)->pidx].len); + } else { + lookup(&com)->array[RADNODE(add)->pidx].len = 0; + } + memmove(lookup_string(n, idx), addstr, common_len); + lookup(n)->array[idx].len = common_len; + udb_rptr_set_ptr(&lookup(n)->array[idx].node, udb, &com); + udb_ptr_unlink(&rnode, udb); + udb_ptr_unlink(&com, udb); + /* n's string has become shorter */ + if(!udb_radarray_reduce_if_needed(udb, n)) { + /* ignore this, our tree has become inefficient */ + } + } + return 1; +} + +uint64_t* result_data = NULL; +udb_void udb_radix_insert(udb_base* udb, udb_ptr* rt, uint8_t* k, + udb_radstrlen_t len, udb_ptr* elem, udb_ptr* result) +{ + udb_void ret; + udb_ptr add, n; /* type udb_radnode_d */ + udb_radstrlen_t pos = 0; + /* create new element to add */ + if(!udb_ptr_alloc_space(&add, udb, udb_chunk_type_radnode, + sizeof(struct udb_radnode_d))) { + return 0; /* alloc failure */ + } + memset(UDB_PTR(&add), 0, sizeof(struct udb_radnode_d)); + udb_rptr_set_ptr(&RADNODE(&add)->elem, udb, elem); + if(!udb_radnode_array_create(udb, &add)) { + udb_ptr_free_space(&add, udb, sizeof(struct udb_radnode_d)); + return 0; /* alloc failure */ + } + udb_ptr_init(&n, udb); + result_data = &n.data; + + /* find out where to add it */ + if(!udb_radix_find_prefix_node(udb, rt, k, len, &n, &pos)) { + /* new root */ + assert(RADTREE(rt)->root.data == 0); + if(len == 0) { + udb_rptr_set_ptr(&RADTREE(rt)->root, udb, &add); + } else { + /* add a root to point to new node */ + udb_ptr_zero(&n, udb); + if(!udb_ptr_alloc_space(&n, udb, + udb_chunk_type_radnode, + sizeof(struct udb_radnode_d))) { + udb_radnode_delete(udb, &add); + udb_ptr_unlink(&n, udb); + return 0; /* alloc failure */ + } + memset(RADNODE(&n), 0, sizeof(struct udb_radnode_d)); + /* this creates the array lookup structure for n */ + if(!udb_radnode_array_space(udb, &n, k[0], len-1)) { + udb_radnode_delete(udb, &add); + udb_ptr_free_space(&n, udb, + sizeof(struct udb_radnode_d)); + return 0; /* alloc failure */ + } + udb_rptr_set_ptr(&RADNODE(&add)->parent, udb, &n); + RADNODE(&add)->pidx = 0; + udb_rptr_set_ptr(&lookup(&n)->array[0].node, udb, &add); + if(len > 1) { + udb_radsel_prefix_remainder(1, k, len, + lookup_string(&n, 0), + &lookup(&n)->array[0].len); + } + udb_rptr_set_ptr(&RADTREE(rt)->root, udb, &n); + } + } else if(pos == len) { + /* found an exact match */ + if(RADNODE(&n)->elem.data) { + /* already exists, failure */ + udb_radnode_delete(udb, &add); + udb_ptr_unlink(&n, udb); + return 0; + } + udb_rptr_set_ptr(&RADNODE(&n)->elem, udb, elem); + udb_radnode_delete(udb, &add); + udb_ptr_set_ptr(&add, udb, &n); + } else { + /* n is a node which can accomodate */ + uint8_t byte; + assert(pos < len); + byte = k[pos]; + + /* see if it falls outside of array */ + if(byte < RADNODE(&n)->offset || byte-RADNODE(&n)->offset >= + lookup(&n)->len) { + /* make space in the array for it; adjusts offset */ + if(!udb_radnode_array_space(udb, &n, byte, + len-(pos+1))) { + udb_radnode_delete(udb, &add); + udb_ptr_unlink(&n, udb); + return 0; + } + assert(byte>=RADNODE(&n)->offset && byte-RADNODE(&n)-> + offset<lookup(&n)->len); + byte -= RADNODE(&n)->offset; + /* see if more prefix needs to be split off */ + if(pos+1 < len) { + udb_radsel_str_create(lookup_string(&n, byte), + &lookup(&n)->array[byte].len, + k, pos+1, len); + } + /* insert the new node in the new bucket */ + udb_rptr_set_ptr(&RADNODE(&add)->parent, udb, &n); + RADNODE(&add)->pidx = byte; + udb_rptr_set_ptr(&lookup(&n)->array[byte].node, udb, + &add); + /* so a bucket exists and byte falls in it */ + } else if(lookup(&n)->array[byte - RADNODE(&n)->offset] + .node.data == 0) { + /* use existing bucket */ + byte -= RADNODE(&n)->offset; + if(pos+1 < len) { + /* make space and split off more prefix */ + if(!udb_radnode_str_space(udb, &n, + len-(pos+1))) { + udb_radnode_delete(udb, &add); + udb_ptr_unlink(&n, udb); + return 0; + } + udb_radsel_str_create(lookup_string(&n, byte), + &lookup(&n)->array[byte].len, + k, pos+1, len); + } + /* insert the new node in the new bucket */ + udb_rptr_set_ptr(&RADNODE(&add)->parent, udb, &n); + RADNODE(&add)->pidx = byte; + udb_rptr_set_ptr(&lookup(&n)->array[byte].node, udb, + &add); + } else { + /* use bucket but it has a shared prefix, + * split that out and create a new intermediate + * node to split out between the two. + * One of the two might exactmatch the new + * intermediate node */ + if(!udb_radsel_split(udb, &n, byte-RADNODE(&n)->offset, + k, pos+1, len, &add)) { + udb_radnode_delete(udb, &add); + udb_ptr_unlink(&n, udb); + return 0; + } + } + } + RADTREE(rt)->count ++; + ret = add.data; + udb_ptr_init(result, udb); + udb_ptr_set_ptr(result, udb, &add); + udb_ptr_unlink(&add, udb); + udb_ptr_unlink(&n, udb); + return ret; +} + +/** Cleanup node with one child, it is removed and joined into parent[x] str */ +static int +udb_radnode_cleanup_onechild(udb_base* udb, udb_ptr* n) +{ + udb_ptr par, child; + uint8_t pidx = RADNODE(n)->pidx; + radstrlen_t joinlen; + udb_ptr_new(&par, udb, &RADNODE(n)->parent); + udb_ptr_new(&child, udb, &lookup(n)->array[0].node); + + /* node had one child, merge them into the parent. */ + /* keep the child node, so its pointers stay valid. */ + + /* at parent, append child->str to array str */ + assert(pidx < lookup(&par)->len); + joinlen = lookup_len(&par, pidx) + lookup_len(n, 0) + 1; + /* make stringspace for the joined string */ + if(!udb_radnode_str_space(udb, &par, joinlen)) { + /* cleanup failed due to out of memory */ + /* the tree is inefficient, with node n still existing */ + udb_ptr_unlink(&par, udb); + udb_ptr_unlink(&child, udb); + udb_ptr_zero(n, udb); + return 0; + } + /* the string(par, pidx) is already there */ + /* the array lookup is gone, put its character in the lookup string*/ + lookup_string(&par, pidx)[lookup_len(&par, pidx)] = + RADNODE(&child)->pidx + RADNODE(n)->offset; + memmove(lookup_string(&par, pidx)+lookup_len(&par, pidx)+1, + lookup_string(n, 0), lookup_len(n, 0)); + lookup(&par)->array[pidx].len = joinlen; + /* and set the node to our child. */ + udb_rptr_set_ptr(&lookup(&par)->array[pidx].node, udb, &child); + udb_rptr_set_ptr(&RADNODE(&child)->parent, udb, &par); + RADNODE(&child)->pidx = pidx; + /* we are unlinked, delete our node */ + udb_radnode_delete(udb, n); + udb_ptr_unlink(&par, udb); + udb_ptr_unlink(&child, udb); + udb_ptr_zero(n, udb); + return 1; +} + +/** reduce the size of radarray, does a malloc */ +static int +udb_radarray_reduce(udb_base* udb, udb_ptr* n, uint16_t cap, + udb_radstrlen_t strcap) +{ + udb_ptr a; + unsigned i; + assert(lookup(n)->len <= cap); + assert(cap <= lookup(n)->capacity); + assert(strcap <= lookup(n)->str_cap); + if(!udb_ptr_alloc_space(&a, udb, udb_chunk_type_radarray, + size_of_lookup_needed(cap, strcap))) + return 0; + memset(RADARRAY(&a), 0, size_of_lookup_needed(cap, strcap)); + memcpy(RADARRAY(&a), lookup(n), sizeof(struct udb_radarray_d)); + RADARRAY(&a)->capacity = cap; + RADARRAY(&a)->str_cap = strcap; + for(i=0; i<lookup(n)->len; i++) { + udb_rel_ptr_init(&RADARRAY(&a)->array[i].node); + udb_rptr_set_rptr(&RADARRAY(&a)->array[i].node, udb, + &lookup(n)->array[i].node); + RADARRAY(&a)->array[i].len = lookup_len(n, i); + memmove(((uint8_t*)(&RADARRAY(&a)->array[cap]))+i*strcap, + lookup_string(n, i), lookup_len(n, i)); + } + udb_radarray_zero_ptrs(udb, n); + udb_rel_ptr_free_space(&RADNODE(n)->lookup, udb, size_of_lookup(n)); + udb_rptr_set_ptr(&RADNODE(n)->lookup, udb, &a); + udb_ptr_unlink(&a, udb); + return 1; +} + +/** find the max stringlength in the array */ +static udb_radstrlen_t udb_radarray_max_len(udb_ptr* n) +{ + unsigned i; + udb_radstrlen_t maxlen = 0; + for(i=0; i<lookup(n)->len; i++) { + if(lookup(n)->array[i].node.data && + lookup(n)->array[i].len > maxlen) + maxlen = lookup(n)->array[i].len; + } + return maxlen; +} + +/** see if radarray can be reduced (by a factor of two) */ +static int +udb_radarray_reduce_if_needed(udb_base* udb, udb_ptr* n) +{ + udb_radstrlen_t maxlen = udb_radarray_max_len(n); + if((lookup(n)->len <= lookup(n)->capacity/2 || lookup(n)->len == 0 + || maxlen <= lookup(n)->str_cap/2 || maxlen == 0) && + (lookup(n)->len != lookup(n)->capacity || + lookup(n)->str_cap != maxlen)) + return udb_radarray_reduce(udb, n, lookup(n)->len, maxlen); + return 1; +} + +static int +udb_radnode_array_clean_all(udb_base* udb, udb_ptr* n) +{ + RADNODE(n)->offset = 0; + lookup(n)->len = 0; + /* reallocate lookup to a smaller capacity structure */ + return udb_radarray_reduce(udb, n, 0, 0); +} + +/** remove NULL nodes from front of array */ +static int +udb_radnode_array_clean_front(udb_base* udb, udb_ptr* n) +{ + /* move them up and adjust offset */ + unsigned idx, shuf = 0; + /* remove until a nonNULL entry */ + while(shuf < lookup(n)->len && lookup(n)->array[shuf].node.data == 0) + shuf++; + if(shuf == 0) + return 1; + if(shuf == lookup(n)->len) { + /* the array is empty, the tree is inefficient */ + return udb_radnode_array_clean_all(udb, n); + } + assert(shuf < lookup(n)->len); + assert((int)shuf <= 255-(int)RADNODE(n)->offset); + /* move them */ + for(idx=0; idx<lookup(n)->len-shuf; idx++) { + udb_rptr_set_rptr(&lookup(n)->array[idx].node, udb, + &lookup(n)->array[shuf+idx].node); + lookup(n)->array[idx].len = lookup_len(n, shuf+idx); + memmove(lookup_string(n, idx), lookup_string(n, shuf+idx), + lookup(n)->array[idx].len); + } + /* zero the to-be-unused entries */ + for(idx=lookup(n)->len-shuf; idx<lookup(n)->len; idx++) { + udb_rptr_zero(&lookup(n)->array[idx].node, udb); + memset(lookup_string(n, idx), 0, lookup(n)->array[idx].len); + lookup(n)->array[idx].len = 0; + } + RADNODE(n)->offset += shuf; + lookup(n)->len -= shuf; + for(idx=0; idx<lookup(n)->len; idx++) + if(lookup(n)->array[idx].node.data) + lookup_node(n, idx)->pidx = idx; + + /* see if capacity has to shrink */ + return udb_radarray_reduce_if_needed(udb, n); +} + +/** remove NULL nodes from end of array */ +static int +udb_radnode_array_clean_end(udb_base* udb, udb_ptr* n) +{ + /* shorten it */ + unsigned shuf = 0; + /* remove until a nonNULL entry */ + /* remove until a nonNULL entry */ + while(shuf < lookup(n)->len && lookup(n)->array[lookup(n)->len-1-shuf] + .node.data == 0) + shuf++; + if(shuf == 0) + return 1; + if(shuf == lookup(n)->len) { + /* the array is empty, the tree is inefficient */ + return udb_radnode_array_clean_all(udb, n); + } + assert(shuf < lookup(n)->len); + lookup(n)->len -= shuf; + /* array elements can stay where they are */ + /* see if capacity has to shrink */ + return udb_radarray_reduce_if_needed(udb, n); +} + +/** clean up radnode leaf, where we know it has a parent */ +static int +udb_radnode_cleanup_leaf(udb_base* udb, udb_ptr* n, udb_ptr* par) +{ + uint8_t pidx; + /* node was a leaf */ + + /* delete leaf node, but store parent+idx */ + pidx = RADNODE(n)->pidx; + assert(pidx < lookup(par)->len); + + /** set parent ptr to this node to NULL before deleting the node, + * because otherwise ptrlinks fail */ + udb_rptr_zero(&lookup(par)->array[pidx].node, udb); + + udb_radnode_delete(udb, n); + + /* set parent+idx entry to NULL str and node.*/ + lookup(par)->array[pidx].len = 0; + + /* see if par offset or len must be adjusted */ + if(lookup(par)->len == 1) { + /* removed final element from array */ + if(!udb_radnode_array_clean_all(udb, par)) + return 0; + } else if(pidx == 0) { + /* removed first element from array */ + if(!udb_radnode_array_clean_front(udb, par)) + return 0; + } else if(pidx == lookup(par)->len-1) { + /* removed last element from array */ + if(!udb_radnode_array_clean_end(udb, par)) + return 0; + } + return 1; +} + +/** + * Cleanup a radix node that was made smaller, see if it can + * be merged with others. + * @param udb: the udb + * @param rt: tree to remove root if needed. + * @param n: node to cleanup + * @return false on alloc failure. + */ +static int +udb_radnode_cleanup(udb_base* udb, udb_ptr* rt, udb_ptr* n) +{ + while(!udb_ptr_is_null(n)) { + if(RADNODE(n)->elem.data) { + /* see if if needs to be reduced in stringsize */ + if(!udb_radarray_reduce_if_needed(udb, n)) { + udb_ptr_zero(n, udb); + return 0; + } + /* cannot delete node with a data element */ + udb_ptr_zero(n, udb); + return 1; + } else if(lookup(n)->len == 1 && RADNODE(n)->parent.data) { + return udb_radnode_cleanup_onechild(udb, n); + } else if(lookup(n)->len == 0) { + udb_ptr par; + if(!RADNODE(n)->parent.data) { + /* root deleted */ + udb_rptr_zero(&RADTREE(rt)->root, udb); + udb_radnode_delete(udb, n); + return 1; + } + udb_ptr_new(&par, udb, &RADNODE(n)->parent); + /* remove and delete the leaf node */ + if(!udb_radnode_cleanup_leaf(udb, n, &par)) { + udb_ptr_unlink(&par, udb); + udb_ptr_zero(n, udb); + return 0; + } + /* see if parent can now be cleaned up */ + udb_ptr_set_ptr(n, udb, &par); + udb_ptr_unlink(&par, udb); + } else { + /* see if if needs to be reduced in stringsize */ + if(!udb_radarray_reduce_if_needed(udb, n)) { + udb_ptr_zero(n, udb); + return 0; + } + /* node cannot be cleaned up */ + udb_ptr_zero(n, udb); + return 1; + } + } + /* ENOTREACH */ + return 1; +} + +void udb_radix_delete(udb_base* udb, udb_ptr* rt, udb_ptr* n) +{ + if(udb_ptr_is_null(n)) + return; + udb_rptr_zero(&RADNODE(n)->elem, udb); + RADTREE(rt)->count --; + if(!udb_radnode_cleanup(udb, rt, n)) { + /* out of memory in cleanup. the elem ptr is NULL, but + * the radix tree could be inefficient. */ + } +} + +udb_void udb_radix_search(udb_ptr* rt, uint8_t* k, udb_radstrlen_t len) +{ + /* since we only perform reads, and no udb_mallocs or udb_frees + * we know the pointers stay the same */ + struct udb_radnode_d* n; + udb_radstrlen_t pos = 0; + uint8_t byte; + void* base = *rt->base; + + n = (struct udb_radnode_d*)UDB_REL(base, RADTREE(rt)->root.data); +#define NARRAY(n) ((struct udb_radarray_d*)UDB_REL(base, n->lookup.data)) +#define NSTR(n, byte) (((uint8_t*)(&NARRAY(n)->array[NARRAY(n)->capacity]))+byte*NARRAY(n)->str_cap) + while(n != *rt->base) { + if(pos == len) + return UDB_SYSTOREL(*rt->base, n); + byte = k[pos]; + if(byte < n->offset) + return 0; + byte -= n->offset; + if(byte >= NARRAY(n)->len) + return 0; + pos++; + if(NARRAY(n)->array[byte].len != 0) { + /* must match additional string */ + if(pos+NARRAY(n)->array[byte].len > len) + return 0; /* no match */ + if(memcmp(&k[pos], NSTR(n, byte), + NARRAY(n)->array[byte].len) != 0) + return 0; /* no match */ + pos += NARRAY(n)->array[byte].len; + } + n = (struct udb_radnode_d*)UDB_REL(base, + NARRAY(n)->array[byte].node.data); + } + return 0; +} + +/** go to last elem-containing node in this subtree (excl self) */ +static void +udb_radnode_last_in_subtree(udb_base* udb, udb_ptr* n) +{ + int idx; + /* try last entry in array first */ + for(idx=((int)lookup(n)->len)-1; idx >= 0; idx--) { + if(lookup(n)->array[idx].node.data) { + udb_ptr s; + udb_ptr_init(&s, udb); + udb_ptr_set_rptr(&s, udb, &lookup(n)->array[idx].node); + /* does it have entries in its subtrees? */ + if(lookup(&s)->len > 0) { + udb_radnode_last_in_subtree(udb, &s); + if(!udb_ptr_is_null(&s)) { + udb_ptr_set_ptr(n, udb, &s); + udb_ptr_unlink(&s, udb); + return; + } + } + udb_ptr_set_rptr(&s, udb, &lookup(n)->array[idx].node); + /* no, does it have an entry itself? */ + if(RADNODE(&s)->elem.data) { + udb_ptr_set_ptr(n, udb, &s); + udb_ptr_unlink(&s, udb); + return; + } + udb_ptr_unlink(&s, udb); + } + } + udb_ptr_zero(n, udb); +} + +/** last in subtree, incl self */ +static void +udb_radnode_last_in_subtree_incl_self(udb_base* udb, udb_ptr* n) +{ + udb_ptr self; + udb_ptr_init(&self, udb); + udb_ptr_set_ptr(&self, udb, n); + udb_radnode_last_in_subtree(udb, n); + if(!udb_ptr_is_null(n)) { + udb_ptr_unlink(&self, udb); + return; + } + if(RADNODE(&self)->elem.data) { + udb_ptr_set_ptr(n, udb, &self); + udb_ptr_unlink(&self, udb); + return; + } + udb_ptr_zero(n, udb); + udb_ptr_unlink(&self, udb); +} + +/** return first elem-containing node in this subtree (excl self) */ +static void +udb_radnode_first_in_subtree(udb_base* udb, udb_ptr* n) +{ + unsigned idx; + /* try every subnode */ + for(idx=0; idx<lookup(n)->len; idx++) { + if(lookup(n)->array[idx].node.data) { + udb_ptr s; + udb_ptr_init(&s, udb); + udb_ptr_set_rptr(&s, udb, &lookup(n)->array[idx].node); + /* does it have elem itself? */ + if(RADNODE(&s)->elem.data) { + udb_ptr_set_ptr(n, udb, &s); + udb_ptr_unlink(&s, udb); + return; + } + /* try its subtrees */ + udb_radnode_first_in_subtree(udb, &s); + if(!udb_ptr_is_null(&s)) { + udb_ptr_set_ptr(n, udb, &s); + udb_ptr_unlink(&s, udb); + return; + } + + } + } + udb_ptr_zero(n, udb); +} + +/** Find an entry in arrays from idx-1 to 0 */ +static void +udb_radnode_find_prev_from_idx(udb_base* udb, udb_ptr* n, unsigned from) +{ + unsigned idx = from; + while(idx > 0) { + idx --; + if(lookup(n)->array[idx].node.data) { + udb_ptr_set_rptr(n, udb, &lookup(n)->array[idx].node); + udb_radnode_last_in_subtree_incl_self(udb, n); + if(!udb_ptr_is_null(n)) + return; + } + } + udb_ptr_zero(n, udb); +} + +/** return self or a previous element */ +static int udb_ret_self_or_prev(udb_base* udb, udb_ptr* n, udb_ptr* result) +{ + if(RADNODE(n)->elem.data) { + udb_ptr_set_ptr(result, udb, n); + } else { + udb_ptr_set_ptr(result, udb, n); + udb_radix_prev(udb, result); + } + udb_ptr_unlink(n, udb); + return 0; +} + + +int udb_radix_find_less_equal(udb_base* udb, udb_ptr* rt, uint8_t* k, + udb_radstrlen_t len, udb_ptr* result) +{ + udb_ptr n; + udb_radstrlen_t pos = 0; + uint8_t byte; + int r; + /* set result to NULL */ + udb_ptr_init(result, udb); + if(RADTREE(rt)->count == 0) { + /* empty tree */ + return 0; + } + udb_ptr_new(&n, udb, &RADTREE(rt)->root); + while(pos < len) { + byte = k[pos]; + if(byte < RADNODE(&n)->offset) { + /* so the previous is the element itself */ + /* or something before this element */ + return udb_ret_self_or_prev(udb, &n, result); + } + byte -= RADNODE(&n)->offset; + if(byte >= lookup(&n)->len) { + /* so, the previous is the last of array, or itself */ + /* or something before this element */ + udb_ptr_set_ptr(result, udb, &n); + udb_radnode_last_in_subtree_incl_self(udb, result); + if(udb_ptr_is_null(result)) { + udb_ptr_set_ptr(result, udb, &n); + udb_radix_prev(udb, result); + } + goto done_fail; + } + pos++; + if(!lookup(&n)->array[byte].node.data) { + /* no match */ + /* Find an entry in arrays from byte-1 to 0 */ + udb_ptr_set_ptr(result, udb, &n); + udb_radnode_find_prev_from_idx(udb, result, byte); + if(!udb_ptr_is_null(result)) + goto done_fail; + /* this entry or something before it */ + udb_ptr_zero(result, udb); + return udb_ret_self_or_prev(udb, &n, result); + } + if(lookup_len(&n, byte) != 0) { + /* must match additional string */ + if(pos+lookup_len(&n, byte) > len) { + /* the additional string is longer than key*/ + if( (r=memcmp(&k[pos], lookup_string(&n, byte), + len-pos)) <= 0) { + /* and the key is before this node */ + udb_ptr_set_rptr(result, udb, + &lookup(&n)->array[byte].node); + udb_radix_prev(udb, result); + } else { + /* the key is after the additional + * string, thus everything in that + * subtree is smaller. */ + udb_ptr_set_rptr(result, udb, + &lookup(&n)->array[byte].node); + udb_radnode_last_in_subtree_incl_self(udb, result); + /* if somehow that is NULL, + * then we have an inefficient tree: + * byte+1 is larger than us, so find + * something in byte-1 and before */ + if(udb_ptr_is_null(result)) { + udb_ptr_set_rptr(result, udb, + &lookup(&n)->array[byte].node); + udb_radix_prev(udb, result); + } + } + goto done_fail; /* no match */ + } + if( (r=memcmp(&k[pos], lookup_string(&n, byte), + lookup_len(&n, byte))) < 0) { + udb_ptr_set_rptr(result, udb, + &lookup(&n)->array[byte].node); + udb_radix_prev(udb, result); + goto done_fail; /* no match */ + } else if(r > 0) { + /* the key is larger than the additional + * string, thus everything in that subtree + * is smaller */ + udb_ptr_set_rptr(result, udb, + &lookup(&n)->array[byte].node); + udb_radnode_last_in_subtree_incl_self(udb, result); + /* if we have an inefficient tree */ + if(udb_ptr_is_null(result)) { + udb_ptr_set_rptr(result, udb, + &lookup(&n)->array[byte].node); + udb_radix_prev(udb, result); + } + goto done_fail; /* no match */ + } + pos += lookup_len(&n, byte); + } + udb_ptr_set_rptr(&n, udb, &lookup(&n)->array[byte].node); + } + if(RADNODE(&n)->elem.data) { + /* exact match */ + udb_ptr_set_ptr(result, udb, &n); + udb_ptr_unlink(&n, udb); + return 1; + } + /* there is a node which is an exact match, but it has no element */ + udb_ptr_set_ptr(result, udb, &n); + udb_radix_prev(udb, result); +done_fail: + udb_ptr_unlink(&n, udb); + return 0; +} + +void udb_radix_first(udb_base* udb, udb_ptr* rt, udb_ptr* p) +{ + udb_ptr_init(p, udb); + if(!rt || udb_ptr_is_null(rt) || RADTREE(rt)->count == 0) + return; + udb_ptr_set_rptr(p, udb, &RADTREE(rt)->root); + if(RADNODE(p)->elem.data) + return; + udb_radix_next(udb, p); +} + +void udb_radix_last(udb_base* udb, udb_ptr* rt, udb_ptr* p) +{ + udb_ptr_init(p, udb); + if(!rt || udb_ptr_is_null(rt) || RADTREE(rt)->count == 0) + return; + udb_ptr_set_rptr(p, udb, &RADTREE(rt)->root); + udb_radnode_last_in_subtree_incl_self(udb, p); +} + +void udb_radix_next(udb_base* udb, udb_ptr* n) +{ + udb_ptr s; + udb_ptr_init(&s, udb); + if(lookup(n)->len) { + /* go down */ + udb_ptr_set_ptr(&s, udb, n); + udb_radnode_first_in_subtree(udb, &s); + if(!udb_ptr_is_null(&s)) { + udb_ptr_set_ptr(n, udb, &s); + udb_ptr_unlink(&s, udb); + return; + } + } + /* go up - the parent->elem is not useful, because it is before us */ + while(RADNODE(n)->parent.data) { + unsigned idx = RADNODE(n)->pidx; + udb_ptr_set_rptr(n, udb, &RADNODE(n)->parent); + idx++; + for(; idx < lookup(n)->len; idx++) { + /* go down the next branch */ + if(lookup(n)->array[idx].node.data) { + udb_ptr_set_rptr(&s, udb, + &lookup(n)->array[idx].node); + /* node itself */ + if(RADNODE(&s)->elem.data) { + udb_ptr_set_ptr(n, udb, &s); + udb_ptr_unlink(&s, udb); + return; + } + /* or subtree */ + udb_radnode_first_in_subtree(udb, &s); + if(!udb_ptr_is_null(&s)) { + udb_ptr_set_ptr(n, udb, &s); + udb_ptr_unlink(&s, udb); + return; + } + } + } + } + udb_ptr_unlink(&s, udb); + udb_ptr_zero(n, udb); +} + +void udb_radix_prev(udb_base* udb, udb_ptr* n) +{ + /* must go up, since all array nodes are after this node */ + while(RADNODE(n)->parent.data) { + uint8_t idx = RADNODE(n)->pidx; + udb_ptr s; + udb_ptr_set_rptr(n, udb, &RADNODE(n)->parent); + assert(lookup(n)->len > 0); /* since we are a child */ + /* see if there are elements in previous branches there */ + udb_ptr_init(&s, udb); + udb_ptr_set_ptr(&s, udb, n); + udb_radnode_find_prev_from_idx(udb, &s, idx); + if(!udb_ptr_is_null(&s)) { + udb_ptr_set_ptr(n, udb, &s); + udb_ptr_unlink(&s, udb); + return; + } + udb_ptr_unlink(&s, udb); + /* the current node is before the array */ + if(RADNODE(n)->elem.data) + return; + } + udb_ptr_zero(n, udb); +} + +udb_void udb_radname_insert(udb_base* udb, udb_ptr* rt, const uint8_t* dname, + size_t dlen, udb_ptr* elem, udb_ptr* result) +{ + uint8_t k[300]; + radstrlen_t klen = (radstrlen_t)sizeof(k); + radname_d2r(k, &klen, dname, dlen); + return udb_radix_insert(udb, rt, k, klen, elem, result); +} + +int udb_radname_search(udb_base* udb, udb_ptr* rt, const uint8_t* dname, + size_t dlen, udb_ptr* result) +{ + udb_void r; + uint8_t k[300]; + radstrlen_t klen = (radstrlen_t)sizeof(k); + radname_d2r(k, &klen, dname, dlen); + r = udb_radix_search(rt, k, klen); + udb_ptr_init(result, udb); + udb_ptr_set(result, udb, r); + return (r != 0); +} + +void udb_radix_tree_walk_chunk(void* base, void* d, uint64_t s, + udb_walk_relptr_cb* cb, void* arg) +{ + struct udb_radtree_d* p = (struct udb_radtree_d*)d; + assert(s >= sizeof(struct udb_radtree_d)); + (void)s; + (*cb)(base, &p->root, arg); +} + +void udb_radix_node_walk_chunk(void* base, void* d, uint64_t s, + udb_walk_relptr_cb* cb, void* arg) +{ + struct udb_radnode_d* p = (struct udb_radnode_d*)d; + assert(s >= sizeof(struct udb_radnode_d)); + (void)s; + (*cb)(base, &p->elem, arg); + (*cb)(base, &p->parent, arg); + (*cb)(base, &p->lookup, arg); +} + +void udb_radix_array_walk_chunk(void* base, void* d, uint64_t s, + udb_walk_relptr_cb* cb, void* arg) +{ + struct udb_radarray_d* p = (struct udb_radarray_d*)d; + unsigned i; + assert(s >= sizeof(struct udb_radarray_d)+ + p->capacity*(sizeof(struct udb_radsel_d)+p->str_cap)); + (void)s; + for(i=0; i<p->len; i++) { + (*cb)(base, &p->array[i].node, arg); + } +} diff --git a/usr.sbin/nsd/udbradtree.h b/usr.sbin/nsd/udbradtree.h new file mode 100644 index 00000000000..6f4bc735819 --- /dev/null +++ b/usr.sbin/nsd/udbradtree.h @@ -0,0 +1,245 @@ +/* + * udbradtree -- radix tree for binary strings for in udb file. + * + * Copyright (c) 2011, NLnet Labs. See LICENSE for license. + */ +#ifndef UDB_RADTREE_H +#define UDB_RADTREE_H +#include "udb.h" +struct udb_radnode; + +/** length of the binary string */ +typedef uint16_t udb_radstrlen_t; + +/** + * The radix tree + * + * The elements are stored based on binary strings(0-255) of a given length. + * They are sorted, a prefix is sorted before its suffixes. + * If you want to know the key string, you should store it yourself, the + * tree stores it in the parts necessary for lookup. + * For binary strings for domain names see the radname routines. + * + * This is the tree on disk representation. It has _d suffix in the name + * to help delineate disk structures from normal structures. + */ +struct udb_radtree_d { + /** root node in tree, to udb_radnode_d */ + struct udb_rel_ptr root; + /** count of number of elements */ + uint64_t count; +}; + +/** + * A radix tree lookup node. It is stored on disk, and the lookup array + * is allocated. + */ +struct udb_radnode_d { + /** data element associated with the binary string up to this node */ + struct udb_rel_ptr elem; + /** parent node (NULL for the root), to udb_radnode_d */ + struct udb_rel_ptr parent; + /** the array structure, for lookup by [byte-offset]. udb_radarray_d */ + struct udb_rel_ptr lookup; + /** index in the parent lookup array */ + uint8_t pidx; + /** offset of the lookup array, add to [i] for lookups */ + uint8_t offset; +}; + +/** + * radix select edge in array + * The string for this element is the Nth string in the stringarray. + */ +struct udb_radsel_d { + /** length of the additional string for this edge, + * additional string after the selection-byte for this edge.*/ + udb_radstrlen_t len; + /** padding for non64bit compilers to 64bit boundaries, to make + * the udb file more portable, without this the file would work + * on the system it is created on (which is what we promise), but + * with this, you have a chance of it working on other platforms */ + uint16_t padding16; + uint32_t padding32; + /** node that deals with byte+str, to udb_radnode_d */ + struct udb_rel_ptr node; +}; + +/** + * Array of radsel elements. + * This is the header, the array is allocated contiguously behind it. + * The strings (often very short) are allocated behind the array. + * All strings are given the same amount of space (str_cap), + * so there is capacity*str_cap bytes at the end. + */ +struct udb_radarray_d { + /** length of the lookup array */ + uint16_t len; + /** capacity of the lookup array (can be larger than length) */ + uint16_t capacity; + /** space capacity of for every string */ + udb_radstrlen_t str_cap; + /** padding to 64bit alignment, just in case compiler goes mad */ + uint16_t padding; + /** the elements (allocated contiguously after this structure) */ + struct udb_radsel_d array[0]; +}; + +/** + * Create new radix tree on udb storage + * @param udb: the udb to allocate space on. + * @param ptr: ptr to the udbradtree is returned here. pass uninitialised. + * type is udb_radtree_d. + * @return 0 on alloc failure. + */ +int udb_radix_tree_create(udb_base* udb, udb_ptr* ptr); + +/** + * Delete intermediate nodes from radix tree + * @param udb: the udb. + * @param rt: radix tree to be cleared. type udb_radtree_d. + */ +void udb_radix_tree_clear(udb_base* udb, udb_ptr* rt); + +/** + * Delete radix tree. + * You must have deleted the elements, this deletes the nodes. + * @param udb: the udb. + * @param rt: radix tree to be deleted. type udb_radtree_d. + */ +void udb_radix_tree_delete(udb_base* udb, udb_ptr* rt); + +/** + * Insert element into radix tree. + * @param udb: the udb. + * @param rt: the radix tree, type udb_radtree_d. + * @param key: key string. + * @param len: length of key. + * @param elem: pointer to element data, on the udb store. + * @param result: the inserted node is set to this value. Pass uninited. + Not set if the routine fails. + * @return NULL on failure - out of memory. + * NULL on failure - duplicate entry. + * On success the new radix node for this element (udb_radnode_d). + */ +udb_void udb_radix_insert(udb_base* udb, udb_ptr* rt, uint8_t* k, + udb_radstrlen_t len, udb_ptr* elem, udb_ptr* result); + +/** + * Delete element from radix tree. + * @param udb: the udb. + * @param rt: the radix tree. type udb_radtree_d + * @param n: radix node for that element. type udb_radnode_d + * if NULL, nothing is deleted. + */ +void udb_radix_delete(udb_base* udb, udb_ptr* rt, udb_ptr* n); + +/** + * Find radix element in tree. + * @param rt: the radix tree, type udb_radtree_d. + * @param key: key string. + * @param len: length of key. + * @return the radix node or NULL if not found. type udb_radnode_d + */ +udb_void udb_radix_search(udb_ptr* rt, uint8_t* k, + udb_radstrlen_t len); + +/** + * Find radix element in tree, and if not found, find the closest smaller or + * equal element in the tree. + * @param udb: the udb. + * @param rt: the radix tree, type udb_radtree_d. + * @param key: key string. + * @param len: length of key. + * @param result: returns the radix node or closest match (NULL if key is + * smaller than the smallest key in the tree). type udb_radnode_d. + * you can pass an uninitialized ptr, an unlinked or a zeroed one. + * @return true if exact match, false if no match. + */ +int udb_radix_find_less_equal(udb_base* udb, udb_ptr* rt, uint8_t* k, + udb_radstrlen_t len, udb_ptr* result); + +/** + * Return the first (smallest) element in the tree. + * @param udb: the udb. + * @param rt: the radix tree, type udb_radtree_d. + * @param p: set to the first node in the tree, or NULL if none. + * type udb_radnode_d. + * pass uninited, zero or unlinked udb_ptr. + */ +void udb_radix_first(udb_base* udb, udb_ptr* rt, udb_ptr* p); + +/** + * Return the last (largest) element in the tree. + * @param udb: the udb. + * @param rt: the radix tree, type udb_radtree_d. + * @param p: last node or NULL if none, type udb_radnode_d. + * pass uninited, zero or unlinked udb_ptr. + */ +void udb_radix_last(udb_base* udb, udb_ptr* rt, udb_ptr* p); + +/** + * Return the next element. + * @param udb: the udb. + * @param n: adjusted to the next element, or NULL if none. type udb_radnode_d. + */ +void udb_radix_next(udb_base* udb, udb_ptr* n); + +/** + * Return the previous element. + * @param udb: the udb. + * @param n: adjusted to the prev node or NULL if none. type udb_radnode_d. + */ +void udb_radix_prev(udb_base* udb, udb_ptr* n); + +/* + * Perform a walk through all elements of the tree. + * node: variable of type struct radnode*. + * tree: pointer to the tree. + * for(udb_radix_first(tree, node); node->data; udb_radix_next(node)) +*/ + +/** for use in udb-walkfunc, walks relptrs in udb_chunk_type_radtree */ +void udb_radix_tree_walk_chunk(void* base, void* d, uint64_t s, + udb_walk_relptr_cb* cb, void* arg); + +/** for use in udb-walkfunc, walks relptrs in udb_chunk_type_radnode */ +void udb_radix_node_walk_chunk(void* base, void* d, uint64_t s, + udb_walk_relptr_cb* cb, void* arg); + +/** for use in udb-walkfunc, walks relptrs in udb_chunk_type_radarray */ +void udb_radix_array_walk_chunk(void* base, void* d, uint64_t s, + udb_walk_relptr_cb* cb, void* arg); + +/** get the memory used by the lookup structure for a radnode */ +size_t size_of_lookup_ext(udb_ptr* node); + +/** insert radtree element, key is a domain name + * @param udb: udb. + * @param rt: the tree. + * @param dname: domain name in uncompressed wireformat. + * @param dlen: length of k. + * @param elem: element to store + * @param result: the inserted node is set to this value. Pass uninited. + Not set if the routine fails. + * @return 0 on failure + */ +udb_void udb_radname_insert(udb_base* udb, udb_ptr* rt, const uint8_t* dname, + size_t dlen, udb_ptr* elem, udb_ptr* result); + +/** search for a radname element, key is a domain name. + * @param udb: udb + * @param rt: the tree + * @param dname: domain name in uncompressed wireformat. + * @param dlen: length of k. + * @param result: result ptr to store the node into. + * may be uninitialized. + * @return 0 if not found. + */ +int udb_radname_search(udb_base* udb, udb_ptr* rt, const uint8_t* dname, + size_t dlen, udb_ptr* result); + +#define RADNODE(ptr) ((struct udb_radnode_d*)UDB_PTR(ptr)) +#define RADTREE(ptr) ((struct udb_radtree_d*)UDB_PTR(ptr)) + +#endif /* UDB_RADTREE_H */ diff --git a/usr.sbin/nsd/udbzone.c b/usr.sbin/nsd/udbzone.c new file mode 100644 index 00000000000..bd5929b3929 --- /dev/null +++ b/usr.sbin/nsd/udbzone.c @@ -0,0 +1,786 @@ +/* + * udbzone -- store zone and rrset information in udb file. + * + * Copyright (c) 2011, NLnet Labs. See LICENSE for license. + */ +#include "config.h" +#include "udbzone.h" +#include "util.h" +#include "iterated_hash.h" +#include "dns.h" +#include "dname.h" +#include "difffile.h" +#include <string.h> + +/** delete the zone plain its own data */ +static void +udb_zone_delete_plain(udb_base* udb, udb_ptr* zone) +{ + udb_ptr dtree; + assert(udb_ptr_get_type(zone) == udb_chunk_type_zone); + udb_zone_clear(udb, zone); + udb_rptr_zero(&ZONE(zone)->node, udb); + udb_rptr_zero(&ZONE(zone)->nsec3param, udb); + udb_rptr_zero(&ZONE(zone)->log_str, udb); + udb_ptr_new(&dtree, udb, &ZONE(zone)->domains); + udb_rptr_zero(&ZONE(zone)->domains, udb); + udb_radix_tree_delete(udb, &dtree); + udb_ptr_free_space(zone, udb, + sizeof(struct zone_d)+ZONE(zone)->namelen); +} + +int +udb_dns_init_file(udb_base* udb) +{ + udb_ptr ztree; + if(!udb_radix_tree_create(udb, &ztree)) { + return 0; + } + udb_base_set_userdata(udb, ztree.data); + udb_ptr_unlink(&ztree, udb); + return 1; +} + +void +udb_dns_deinit_file(udb_base* udb) +{ + udb_ptr ztree; + udb_ptr z; + udb_ptr_new(&ztree, udb, udb_base_get_userdata(udb)); + if(udb_ptr_is_null(&ztree)) { + return; + } + assert(udb_ptr_get_type(&ztree) == udb_chunk_type_radtree); + /* delete all zones */ + for(udb_radix_first(udb, &ztree, &z); z.data; udb_radix_next(udb, &z)){ + udb_ptr zone; + udb_ptr_new(&zone, udb, &RADNODE(&z)->elem); + udb_rptr_zero(&RADNODE(&z)->elem, udb); + udb_zone_delete_plain(udb, &zone); + } + udb_ptr_unlink(&z, udb); + + udb_base_set_userdata(udb, 0); + udb_radix_tree_delete(udb, &ztree); +} + +int +udb_zone_create(udb_base* udb, udb_ptr* result, const uint8_t* dname, + size_t dlen) +{ + udb_ptr ztree, z, node, dtree; + udb_ptr_new(&ztree, udb, udb_base_get_userdata(udb)); + assert(udb_ptr_get_type(&ztree) == udb_chunk_type_radtree); + udb_ptr_init(result, udb); + if(udb_zone_search(udb, &z, dname, dlen)) { + udb_ptr_unlink(&ztree, udb); + udb_ptr_unlink(&z, udb); + /* duplicate */ + return 0; + } + if(!udb_ptr_alloc_space(&z, udb, udb_chunk_type_zone, + sizeof(struct zone_d)+dlen)) { + udb_ptr_unlink(&ztree, udb); + /* failed alloc */ + return 0; + } + /* init the zone object */ + udb_rel_ptr_init(&ZONE(&z)->node); + udb_rel_ptr_init(&ZONE(&z)->domains); + udb_rel_ptr_init(&ZONE(&z)->nsec3param); + udb_rel_ptr_init(&ZONE(&z)->log_str); + ZONE(&z)->rrset_count = 0; + ZONE(&z)->rr_count = 0; + ZONE(&z)->expired = 0; + ZONE(&z)->mtime = 0; + ZONE(&z)->namelen = dlen; + memmove(ZONE(&z)->name, dname, dlen); + if(!udb_radix_tree_create(udb, &dtree)) { + udb_ptr_free_space(&z, udb, sizeof(struct zone_d)+dlen); + udb_ptr_unlink(&ztree, udb); + /* failed alloc */ + return 0; + } + udb_rptr_set_ptr(&ZONE(&z)->domains, udb, &dtree); + + /* insert it */ + if(!udb_radname_insert(udb, &ztree, dname, dlen, &z, &node)) { + udb_ptr_free_space(&z, udb, sizeof(struct zone_d)+dlen); + udb_ptr_unlink(&ztree, udb); + udb_radix_tree_delete(udb, &dtree); + udb_ptr_unlink(&dtree, udb); + /* failed alloc */ + return 0; + } + udb_rptr_set_ptr(&ZONE(&z)->node, udb, &node); + udb_ptr_set_ptr(result, udb, &z); + udb_ptr_unlink(&z, udb); + udb_ptr_unlink(&dtree, udb); + udb_ptr_unlink(&ztree, udb); + udb_ptr_unlink(&node, udb); + return 1; +} + +/** delete an RR */ +static void +rr_delete(udb_base* udb, udb_ptr* rr) +{ + assert(udb_ptr_get_type(rr) == udb_chunk_type_rr); + udb_rptr_zero(&RR(rr)->next, udb); + udb_ptr_free_space(rr, udb, sizeof(struct rr_d)+RR(rr)->len); +} + +/** delete an rrset */ +static void +rrset_delete(udb_base* udb, udb_ptr* rrset) +{ + udb_ptr rr, n; + assert(udb_ptr_get_type(rrset) == udb_chunk_type_rrset); + + /* free RRs */ + udb_ptr_new(&rr, udb, &RRSET(rrset)->rrs); + udb_ptr_init(&n, udb); + udb_rptr_zero(&RRSET(rrset)->rrs, udb); + while(!udb_ptr_is_null(&rr)) { + udb_ptr_set_rptr(&n, udb, &RR(&rr)->next); + rr_delete(udb, &rr); + udb_ptr_set_ptr(&rr, udb, &n); + udb_ptr_zero(&n, udb); + } + udb_ptr_unlink(&n, udb); + udb_ptr_unlink(&rr, udb); + + udb_rptr_zero(&RRSET(rrset)->next, udb); + udb_ptr_free_space(rrset, udb, sizeof(struct rrset_d)); +} + +/** clear a domain of its rrsets, rrs */ +static void +domain_clear(udb_base* udb, udb_ptr* d) +{ + udb_ptr rrset, n; + assert(udb_ptr_get_type(d) == udb_chunk_type_domain); + udb_ptr_new(&rrset, udb, &DOMAIN(d)->rrsets); + udb_ptr_init(&n, udb); + udb_rptr_zero(&DOMAIN(d)->rrsets, udb); + while(!udb_ptr_is_null(&rrset)) { + udb_ptr_set_rptr(&n, udb, &RRSET(&rrset)->next); + rrset_delete(udb, &rrset); + udb_ptr_set_ptr(&rrset, udb, &n); + udb_ptr_zero(&n, udb); + } + udb_ptr_unlink(&n, udb); + udb_ptr_unlink(&rrset, udb); +} + +/** delete a domain and all its rrsets, rrs */ +static void +domain_delete(udb_base* udb, udb_ptr* d) +{ + domain_clear(udb, d); + udb_rptr_zero(&DOMAIN(d)->node, udb); + udb_ptr_free_space(d, udb, + sizeof(struct domain_d)+DOMAIN(d)->namelen); +} + +/** delete domain but also unlink from tree at zone */ +static void +domain_delete_unlink(udb_base* udb, udb_ptr* z, udb_ptr* d) +{ + udb_ptr dtree, n; + udb_ptr_new(&dtree, udb, &ZONE(z)->domains); + udb_ptr_new(&n, udb, &DOMAIN(d)->node); + udb_rptr_zero(&DOMAIN(d)->node, udb); + udb_radix_delete(udb, &dtree, &n); + udb_ptr_unlink(&dtree, udb); + udb_ptr_unlink(&n, udb); + domain_delete(udb, d); +} + +void +udb_zone_clear(udb_base* udb, udb_ptr* zone) +{ + udb_ptr dtree, d; + assert(udb_ptr_get_type(zone) == udb_chunk_type_zone); + udb_ptr_new(&dtree, udb, &ZONE(zone)->domains); + udb_rptr_zero(&ZONE(zone)->nsec3param, udb); + udb_zone_set_log_str(udb, zone, NULL); + + /* walk and delete all domains, rrsets, rrs, but keep tree */ + for(udb_radix_first(udb, &dtree, &d); d.data; udb_radix_next(udb, &d)){ + udb_ptr domain; + udb_ptr_new(&domain, udb, &RADNODE(&d)->elem); + udb_rptr_zero(&RADNODE(&d)->elem, udb); + domain_delete(udb, &domain); + } + udb_ptr_unlink(&d, udb); + udb_radix_tree_clear(udb, &dtree); + ZONE(zone)->rrset_count = 0; + ZONE(zone)->rr_count = 0; + ZONE(zone)->expired = 0; + ZONE(zone)->mtime = 0; + udb_ptr_unlink(&dtree, udb); +} + +void +udb_zone_delete(udb_base* udb, udb_ptr* zone) +{ + udb_ptr ztree, n; + udb_ptr_new(&ztree, udb, udb_base_get_userdata(udb)); + udb_ptr_new(&n, udb, &ZONE(zone)->node); + udb_rptr_zero(&ZONE(zone)->node, udb); + udb_radix_delete(udb, &ztree, &n); + udb_ptr_unlink(&ztree, udb); + udb_ptr_unlink(&n, udb); + udb_zone_delete_plain(udb, zone); +} + +int +udb_zone_search(udb_base* udb, udb_ptr* result, const uint8_t* dname, + size_t dname_len) +{ + udb_ptr ztree; + udb_ptr_new(&ztree, udb, udb_base_get_userdata(udb)); + assert(udb_ptr_get_type(&ztree) == udb_chunk_type_radtree); + if(udb_radname_search(udb, &ztree, dname, dname_len, result)) { + if(result->data) + udb_ptr_set_rptr(result, udb, &RADNODE(result)->elem); + udb_ptr_unlink(&ztree, udb); + return (result->data != 0); + } + udb_ptr_unlink(&ztree, udb); + return 0; +} + +uint64_t udb_zone_get_mtime(udb_base* udb, const uint8_t* dname, size_t dlen) +{ + udb_ptr z; + if(udb_zone_search(udb, &z, dname, dlen)) { + uint64_t t = ZONE(&z)->mtime; + udb_ptr_unlink(&z, udb); + return t; + } + return 0; +} + +void udb_zone_set_log_str(udb_base* udb, udb_ptr* zone, const char* str) +{ + /* delete original log str (if any) */ + if(ZONE(zone)->log_str.data) { + udb_ptr s; + size_t sz; + udb_ptr_new(&s, udb, &ZONE(zone)->log_str); + udb_rptr_zero(&ZONE(zone)->log_str, udb); + sz = strlen((char*)udb_ptr_data(&s))+1; + udb_ptr_free_space(&s, udb, sz); + } + + /* set new log str */ + if(str) { + udb_ptr s; + size_t sz = strlen(str)+1; + if(!udb_ptr_alloc_space(&s, udb, udb_chunk_type_data, sz)) { + return; /* failed to allocate log string */ + } + memmove(udb_ptr_data(&s), str, sz); + udb_rptr_set_ptr(&ZONE(zone)->log_str, udb, &s); + udb_ptr_unlink(&s, udb); + } +} + +#ifdef NSEC3 +/** select the nsec3param for nsec3 usage */ +static void +select_nsec3_param(udb_base* udb, udb_ptr* zone, udb_ptr* rrset) +{ + udb_ptr rr; + udb_ptr_new(&rr, udb, &RRSET(rrset)->rrs); + while(rr.data) { + if(RR(&rr)->len >= 5 && RR(&rr)->wire[0] == NSEC3_SHA1_HASH && + RR(&rr)->wire[1] == 0) { + udb_rptr_set_ptr(&ZONE(zone)->nsec3param, udb, &rr); + udb_ptr_unlink(&rr, udb); + return; + } + udb_ptr_set_rptr(&rr, udb, &RR(&rr)->next); + } + udb_ptr_unlink(&rr, udb); +} + +const char* +udb_nsec3param_string(udb_ptr* rr) +{ + /* max saltlenth plus first couple of numbers (3+1+5+1+3+1) */ + static char params[MAX_RDLENGTH*2+16]; + char* p; + assert(RR(rr)->len >= 5); + p = params + snprintf(params, sizeof(params), "%u %u %u ", + (unsigned)RR(rr)->wire[0], (unsigned)RR(rr)->wire[1], + (unsigned)read_uint16(&RR(rr)->wire[2])); + if(RR(rr)->wire[4] == 0) { + *p++ = '-'; + } else { + assert(RR(rr)->len >= 5+RR(rr)->wire[4]); + p += hex_ntop(&RR(rr)->wire[5], RR(rr)->wire[4], p, + sizeof(params)-strlen(params)-1); + } + *p = 0; + return params; +} + +/** look in zone for new selected nsec3param record from rrset */ +static void +zone_hash_nsec3param(udb_base* udb, udb_ptr* zone, udb_ptr* rrset) +{ + select_nsec3_param(udb, zone, rrset); + if(ZONE(zone)->nsec3param.data == 0) + return; + /* prettyprint the nsec3 parameters we are using */ + if(2 <= verbosity) { + udb_ptr par; + udb_ptr_new(&par, udb, &ZONE(zone)->nsec3param); + VERBOSITY(1, (LOG_INFO, "rehash of zone %s with parameters %s", + wiredname2str(ZONE(zone)->name), + udb_nsec3param_string(&par))); + udb_ptr_unlink(&par, udb); + } +} +#endif /* NSEC3 */ + +/** create a new domain name */ +static int +domain_create(udb_base* udb, udb_ptr* zone, const uint8_t* nm, size_t nmlen, + udb_ptr* result) +{ + udb_ptr dtree, node; + /* create domain chunk */ + if(!udb_ptr_alloc_space(result, udb, udb_chunk_type_domain, + sizeof(struct domain_d)+nmlen)) + return 0; + udb_rel_ptr_init(&DOMAIN(result)->node); + udb_rel_ptr_init(&DOMAIN(result)->rrsets); + DOMAIN(result)->namelen = nmlen; + memmove(DOMAIN(result)->name, nm, nmlen); + + /* insert into domain tree */ + udb_ptr_new(&dtree, udb, &ZONE(zone)->domains); + if(!udb_radname_insert(udb, &dtree, nm, nmlen, result, &node)) { + udb_ptr_free_space(result, udb, sizeof(struct domain_d)+nmlen); + udb_ptr_unlink(&dtree, udb); + return 0; + } + udb_rptr_set_ptr(&DOMAIN(result)->node, udb, &node); + udb_ptr_unlink(&dtree, udb); + udb_ptr_unlink(&node, udb); + return 1; +} + +int +udb_domain_find(udb_base* udb, udb_ptr* zone, const uint8_t* nm, size_t nmlen, + udb_ptr* result) +{ + int r; + udb_ptr dtree; + assert(udb_ptr_get_type(zone) == udb_chunk_type_zone); + udb_ptr_new(&dtree, udb, &ZONE(zone)->domains); + r = udb_radname_search(udb, &dtree, nm, nmlen, result); + if(result->data) + udb_ptr_set_rptr(result, udb, &RADNODE(result)->elem); + udb_ptr_unlink(&dtree, udb); + return r && result->data; +} + +/** find or create a domain name in the zone domain tree */ +static int +domain_find_or_create(udb_base* udb, udb_ptr* zone, const uint8_t* nm, + size_t nmlen, udb_ptr* result) +{ + assert(udb_ptr_get_type(zone) == udb_chunk_type_zone); + if(udb_domain_find(udb, zone, nm, nmlen, result)) + return 1; + return domain_create(udb, zone, nm, nmlen, result); +} + +/** remove rrset from the domain name rrset-list */ +static void +domain_remove_rrset(udb_base* udb, udb_ptr* domain, uint16_t t) +{ + udb_ptr p, prev; + assert(udb_ptr_get_type(domain) == udb_chunk_type_domain); + udb_ptr_new(&p, udb, &DOMAIN(domain)->rrsets); + udb_ptr_init(&prev, udb); + while(p.data) { + if(RRSET(&p)->type == t) { + /* remove it */ + if(prev.data == 0) { + /* first rrset */ + udb_rptr_set_rptr(&DOMAIN(domain)->rrsets, + udb, &RRSET(&p)->next); + } else { + udb_rptr_set_rptr(&RRSET(&prev)->next, + udb, &RRSET(&p)->next); + } + udb_ptr_unlink(&prev, udb); + rrset_delete(udb, &p); + return; + } + udb_ptr_set_ptr(&prev, udb, &p); + udb_ptr_set_rptr(&p, udb, &RRSET(&p)->next); + } + /* rrset does not exist */ + udb_ptr_unlink(&prev, udb); + udb_ptr_unlink(&p, udb); +} + +/** create rrset in the domain rrset list */ +static int +rrset_create(udb_base* udb, udb_ptr* domain, uint16_t t, udb_ptr* res) +{ + /* create it */ + if(!udb_ptr_alloc_space(res, udb, udb_chunk_type_rrset, + sizeof(struct rrset_d))) + return 0; + udb_rel_ptr_init(&RRSET(res)->next); + udb_rel_ptr_init(&RRSET(res)->rrs); + RRSET(res)->type = t; + +#if 0 + /* link it in, at the front */ + udb_rptr_set_rptr(&RRSET(res)->next, udb, &DOMAIN(domain)->rrsets); + udb_rptr_set_ptr(&DOMAIN(domain)->rrsets, udb, res); +#else + /* preserve RRset order, link at end */ + if(DOMAIN(domain)->rrsets.data == 0) { + udb_rptr_set_ptr(&DOMAIN(domain)->rrsets, udb, res); + } else { + udb_ptr p; + udb_ptr_new(&p, udb, &DOMAIN(domain)->rrsets); + while(RRSET(&p)->next.data) + udb_ptr_set_rptr(&p, udb, &RRSET(&p)->next); + udb_rptr_set_ptr(&RRSET(&p)->next, udb, res); + udb_ptr_unlink(&p, udb); + } +#endif + return 1; +} + +int +udb_rrset_find(udb_base* udb, udb_ptr* domain, uint16_t t, udb_ptr* res) +{ + assert(udb_ptr_get_type(domain) == udb_chunk_type_domain); + udb_ptr_init(res, udb); + udb_ptr_set_rptr(res, udb, &DOMAIN(domain)->rrsets); + while(res->data) { + if(RRSET(res)->type == t) + return 1; + udb_ptr_set_rptr(res, udb, &RRSET(res)->next); + } + /* rrset does not exist and res->data is conveniently zero */ + return 0; +} + +/** find or create rrset in the domain rrset list */ +static int +rrset_find_or_create(udb_base* udb, udb_ptr* domain, uint16_t t, udb_ptr* res) +{ + if(udb_rrset_find(udb, domain, t, res)) + return 1; + return rrset_create(udb, domain, t, res); +} + +/** see if RR matches type, class and rdata */ +static int +rr_match(udb_ptr* rr, uint16_t t, uint16_t k, uint8_t* rdata, size_t rdatalen) +{ + return RR(rr)->type == t && RR(rr)->klass == k && + RR(rr)->len == rdatalen && + memcmp(RR(rr)->wire, rdata, rdatalen) == 0; +} + +/** see if RR exists in the RR list that matches the rdata, and return it */ +static int +rr_search(udb_base* udb, udb_ptr* rrset, uint16_t t, uint16_t k, + uint8_t* rdata, size_t rdatalen, udb_ptr* result) +{ + assert(udb_ptr_get_type(rrset) == udb_chunk_type_rrset); + udb_ptr_init(result, udb); + udb_ptr_set_rptr(result, udb, &RRSET(rrset)->rrs); + while(result->data) { + if(rr_match(result, t, k, rdata, rdatalen)) + return 1; /* found */ + udb_ptr_set_rptr(result, udb, &RR(result)->next); + } + /* not found and result->data is conveniently zero */ + return 0; +} + +/** create RR chunk */ +static int +rr_create(udb_base* udb, uint16_t t, uint16_t k, uint32_t ttl, + uint8_t* rdata, size_t rdatalen, udb_ptr* rr) +{ + if(!udb_ptr_alloc_space(rr, udb, udb_chunk_type_rr, + sizeof(struct rr_d)+rdatalen)) + return 0; + udb_rel_ptr_init(&RR(rr)->next); + RR(rr)->type = t; + RR(rr)->klass = k; + RR(rr)->ttl = ttl; + RR(rr)->len = rdatalen; + memmove(RR(rr)->wire, rdata, rdatalen); + return 1; +} + +/** add an RR to an RRset. */ +static int +rrset_add_rr(udb_base* udb, udb_ptr* rrset, uint16_t t, uint16_t k, + uint32_t ttl, uint8_t* rdata, size_t rdatalen) +{ + udb_ptr rr; + assert(udb_ptr_get_type(rrset) == udb_chunk_type_rrset); + /* create it */ + if(!rr_create(udb, t, k, ttl, rdata, rdatalen, &rr)) + return 0; + + /* add at end, to preserve order of RRs */ + if(RRSET(rrset)->rrs.data == 0) { + udb_rptr_set_ptr(&RRSET(rrset)->rrs, udb, &rr); + } else { + udb_ptr lastrr; + udb_ptr_new(&lastrr, udb, &RRSET(rrset)->rrs); + while(RR(&lastrr)->next.data) + udb_ptr_set_rptr(&lastrr, udb, &RR(&lastrr)->next); + udb_rptr_set_ptr(&RR(&lastrr)->next, udb, &rr); + udb_ptr_unlink(&lastrr, udb); + } + udb_ptr_unlink(&rr, udb); + return 1; +} + +/** remove an RR from an RRset. return 0 if RR did not exist. */ +static int +rrset_del_rr(udb_base* udb, udb_ptr* rrset, uint16_t t, uint16_t k, + uint8_t* rdata, size_t rdatalen) +{ + udb_ptr p, prev; + assert(udb_ptr_get_type(rrset) == udb_chunk_type_rrset); + udb_ptr_new(&p, udb, &RRSET(rrset)->rrs); + udb_ptr_init(&prev, udb); + while(p.data) { + if(rr_match(&p, t, k, rdata, rdatalen)) { + /* remove it */ + if(prev.data == 0) { + /* first in list */ + udb_rptr_set_rptr(&RRSET(rrset)->rrs, udb, + &RR(&p)->next); + } else { + udb_rptr_set_rptr(&RR(&prev)->next, udb, + &RR(&p)->next); + } + udb_ptr_unlink(&prev, udb); + rr_delete(udb, &p); + return 1; + } + udb_ptr_set_ptr(&prev, udb, &p); + udb_ptr_set_rptr(&p, udb, &RR(&p)->next); + } + /* not found */ + udb_ptr_unlink(&prev, udb); + udb_ptr_unlink(&p, udb); + return 0; +} + +int +udb_zone_add_rr(udb_base* udb, udb_ptr* zone, const uint8_t* nm, size_t nmlen, + uint16_t t, uint16_t k, uint32_t ttl, uint8_t* rdata, size_t rdatalen) +{ + udb_ptr domain, rrset, rr; + int created_rrset = 0; + assert(udb_ptr_get_type(zone) == udb_chunk_type_zone); + + /* find or create domain */ + if(!domain_find_or_create(udb, zone, nm, nmlen, &domain)) { + return 0; + } + /* find or create rrset(type) */ + if(!rrset_find_or_create(udb, &domain, t, &rrset)) { + goto exit_clean_domain; + } + if(RRSET(&rrset)->rrs.data == 0) + created_rrset = 1; + /* test for duplicate RRs */ + if(rr_search(udb, &rrset, t, k, rdata, rdatalen, &rr)) { + udb_ptr_unlink(&rr, udb); + goto exit_clean_domain_rrset; + } + /* add RR to rrset */ + if(!rrset_add_rr(udb, &rrset, t, k, ttl, rdata, rdatalen)) { + exit_clean_domain_rrset: + /* if rrset was created, remove it */ + if(RRSET(&rrset)->rrs.data == 0) { + udb_ptr_zero(&rrset, udb); + domain_remove_rrset(udb, &domain, t); + } + udb_ptr_unlink(&rrset, udb); + exit_clean_domain: + /* if domain created, delete it */ + if(DOMAIN(&domain)->rrsets.data == 0) + domain_delete_unlink(udb, zone, &domain); + udb_ptr_unlink(&domain, udb); + return 0; + } + /* success, account changes */ + if(created_rrset) + ZONE(zone)->rrset_count ++; + ZONE(zone)->rr_count ++; +#ifdef NSEC3 + if(t == TYPE_NSEC3PARAM && ZONE(zone)->nsec3param.data == 0) + zone_hash_nsec3param(udb, zone, &rrset); +#endif /* NSEC3 */ + udb_ptr_unlink(&domain, udb); + udb_ptr_unlink(&rrset, udb); + return 1; +} + +void +udb_zone_del_rr(udb_base* udb, udb_ptr* zone, const uint8_t* nm, size_t nmlen, + uint16_t t, uint16_t k, uint8_t* rdata, size_t rdatalen) +{ + udb_ptr domain, rrset; + assert(udb_ptr_get_type(zone) == udb_chunk_type_zone); + /* find the domain */ + if(!udb_domain_find(udb, zone, nm, nmlen, &domain)) + return; + /* find the rrset */ + if(!udb_rrset_find(udb, &domain, t, &rrset)) { + udb_ptr_unlink(&domain, udb); + return; + } + /* remove the RR */ +#ifdef NSEC3 + if(t == TYPE_NSEC3PARAM) { + udb_ptr rr; + if(rr_search(udb, &rrset, t, k, rdata, rdatalen, &rr)) { + if(rr.data == ZONE(zone)->nsec3param.data) { + udb_rptr_zero(&ZONE(zone)->nsec3param, udb); + } + udb_ptr_unlink(&rr, udb); + } + } +#endif /* NSEC3 */ + if(!rrset_del_rr(udb, &rrset, t, k, rdata, rdatalen)) { + /* rr did not exist */ + udb_ptr_unlink(&domain, udb); + udb_ptr_unlink(&rrset, udb); + return; + } + ZONE(zone)->rr_count --; +#ifdef NSEC3 + if(t == TYPE_NSEC3PARAM && ZONE(zone)->nsec3param.data == 0 && + RRSET(&rrset)->rrs.data != 0) { + zone_hash_nsec3param(udb, zone, &rrset); + } +#endif /* NSEC3 */ + /* see we we can remove the rrset too */ + if(RRSET(&rrset)->rrs.data == 0) { + udb_ptr_zero(&rrset, udb); + domain_remove_rrset(udb, &domain, t); + ZONE(zone)->rrset_count --; + } + /* see if we can remove the domain name too */ + if(DOMAIN(&domain)->rrsets.data == 0) { + domain_delete_unlink(udb, zone, &domain); + } + udb_ptr_unlink(&rrset, udb); + udb_ptr_unlink(&domain, udb); +} + +void +udb_zone_walk_chunk(void* base, void* d, uint64_t s, udb_walk_relptr_cb* cb, + void* arg) +{ + struct zone_d* p = (struct zone_d*)d; + assert(s >= sizeof(struct zone_d)+p->namelen); + (void)s; + (*cb)(base, &p->node, arg); + (*cb)(base, &p->domains, arg); + (*cb)(base, &p->nsec3param, arg); + (*cb)(base, &p->log_str, arg); +} + +void +udb_domain_walk_chunk(void* base, void* d, uint64_t s, udb_walk_relptr_cb* cb, + void* arg) +{ + struct domain_d* p = (struct domain_d*)d; + assert(s >= sizeof(struct domain_d)+p->namelen); + (void)s; + (*cb)(base, &p->node, arg); + (*cb)(base, &p->rrsets, arg); +} + +void +udb_rrset_walk_chunk(void* base, void* d, uint64_t s, udb_walk_relptr_cb* cb, + void* arg) +{ + struct rrset_d* p = (struct rrset_d*)d; + assert(s >= sizeof(struct rrset_d)); + (void)s; + (*cb)(base, &p->next, arg); + (*cb)(base, &p->rrs, arg); +} + +void +udb_rr_walk_chunk(void* base, void* d, uint64_t s, udb_walk_relptr_cb* cb, + void* arg) +{ + struct rr_d* p = (struct rr_d*)d; + assert(s >= sizeof(struct rr_d)+p->len); + (void)s; + (*cb)(base, &p->next, arg); +} + +void +udb_task_walk_chunk(void* base, void* d, uint64_t s, udb_walk_relptr_cb* cb, + void* arg) +{ + struct task_list_d* p = (struct task_list_d*)d; + assert(s >= p->size); + (void)s; + (*cb)(base, &p->next, arg); +} + +void namedb_walkfunc(void* base, void* warg, uint8_t t, void* d, uint64_t s, + udb_walk_relptr_cb* cb, void* arg) +{ + (void)warg; + switch(t) { + case udb_chunk_type_radtree: + udb_radix_tree_walk_chunk(base, d, s, cb, arg); + break; + case udb_chunk_type_radnode: + udb_radix_node_walk_chunk(base, d, s, cb, arg); + break; + case udb_chunk_type_radarray: + udb_radix_array_walk_chunk(base, d, s, cb, arg); + break; + case udb_chunk_type_zone: + udb_zone_walk_chunk(base, d, s, cb, arg); + break; + case udb_chunk_type_domain: + udb_domain_walk_chunk(base, d, s, cb, arg); + break; + case udb_chunk_type_rrset: + udb_rrset_walk_chunk(base, d, s, cb, arg); + break; + case udb_chunk_type_rr: + udb_rr_walk_chunk(base, d, s, cb, arg); + break; + case udb_chunk_type_task: + udb_task_walk_chunk(base, d, s, cb, arg); + break; + default: + /* no rel ptrs */ + break; + } +} diff --git a/usr.sbin/nsd/udbzone.h b/usr.sbin/nsd/udbzone.h new file mode 100644 index 00000000000..f1163e4dfe5 --- /dev/null +++ b/usr.sbin/nsd/udbzone.h @@ -0,0 +1,147 @@ +/* + * udbzone -- store zone and rrset information in udb file. + * + * Copyright (c) 2011, NLnet Labs. See LICENSE for license. + */ +#ifndef UDB_ZONE_H +#define UDB_ZONE_H +#include "udb.h" +#include "dns.h" +#include "udbradtree.h" + +/** + * Store the DNS information in udb file on disk. + * udb_global + * | + * v + * zonetree -> zone -- zone_name + * radtree | + * v + * domain --> rrset -> rr + * radtree list list + * |-- name + */ + +/** zone information in the nsd.udb. Name allocated after it. */ +struct zone_d { + /** radtree node in the zonetree for this zone */ + udb_rel_ptr node; + /** the radtree for the domain names in the zone */ + udb_rel_ptr domains; + /** the NSEC3PARAM rr used for hashing (or 0), rr_d pointer */ + udb_rel_ptr nsec3param; + /** the log_str for the AXFR change, or 0 */ + udb_rel_ptr log_str; + /** modification time, time when the zone data was changed */ + uint64_t mtime; + /** number of RRsets in the zone */ + uint64_t rrset_count; + /** number of RRs in the zone */ + uint64_t rr_count; + /** the length of the zone name */ + udb_radstrlen_t namelen; + /** if the zone is expired */ + uint8_t expired; + /** if the zone has been changed by AXFR */ + uint8_t is_changed; + /** the zone (wire uncompressed) name in DNS format */ + uint8_t name[0]; +}; + +/** domain name in the nametree. name allocated after it */ +struct domain_d { + /** radtree node in the nametree for this domain */ + udb_rel_ptr node; + /** the list of rrsets for this name, single linked */ + udb_rel_ptr rrsets; + /** length of the domain name */ + udb_radstrlen_t namelen; + /** the domain (wire uncompressed) name in DNS format */ + uint8_t name[0]; +}; + +/** rrset information. */ +struct rrset_d { + /** next in rrset list */ + udb_rel_ptr next; + /** the singly linked list of rrs for this rrset */ + udb_rel_ptr rrs; + /** type of the RRs in this rrset (host order) */ + uint16_t type; +}; + +/** rr information; wireformat data allocated after it */ +struct rr_d { + /** next in rr list */ + udb_rel_ptr next; + /** type (host order) */ + uint16_t type; + /** class (host order) */ + uint16_t klass; + /** ttl (host order) */ + uint32_t ttl; + /** length of wireformat */ + uint16_t len; + /** wireformat of rdata (without rdatalen) */ + uint8_t wire[0]; +}; + +/** init an udb for use as DNS store */ +int udb_dns_init_file(udb_base* udb); +/** de-init an udb for use as DNS store */ +void udb_dns_deinit_file(udb_base* udb); + +/** create a zone */ +int udb_zone_create(udb_base* udb, udb_ptr* result, const uint8_t* dname, + size_t dlen); +/** clear all RRsets from a zone */ +void udb_zone_clear(udb_base* udb, udb_ptr* zone); +/** delete a zone */ +void udb_zone_delete(udb_base* udb, udb_ptr* zone); +/** find a zone by name (exact match) */ +int udb_zone_search(udb_base* udb, udb_ptr* result, const uint8_t* dname, + size_t dlen); +/** get modification time for zone or 0 */ +uint64_t udb_zone_get_mtime(udb_base* udb, const uint8_t* dname, size_t dlen); +/** set log str in udb, or remove it */ +void udb_zone_set_log_str(udb_base* udb, udb_ptr* zone, const char* str); +/** find a domain name in the zone domain tree */ +int udb_domain_find(udb_base* udb, udb_ptr* zone, const uint8_t* nm, + size_t nmlen, udb_ptr* result); +/** find rrset in domain */ +int udb_rrset_find(udb_base* udb, udb_ptr* domain, uint16_t t, udb_ptr* res); + +/** add an RR to a zone */ +int udb_zone_add_rr(udb_base* udb, udb_ptr* zone, const uint8_t* nm, + size_t nmlen, uint16_t t, uint16_t k, uint32_t ttl, uint8_t* rdata, + size_t rdatalen); +/** del an RR from a zone */ +void udb_zone_del_rr(udb_base* udb, udb_ptr* zone, const uint8_t* nm, + size_t nmlen, uint16_t t, uint16_t k, uint8_t* rdata, size_t rdatalen); + +/** get pretty string for nsec3parameters (static buffer returned) */ +const char* udb_nsec3param_string(udb_ptr* rr); + +/** for use in udb-walkfunc, walks relptrs in udb_chunk_type_zone */ +void udb_zone_walk_chunk(void* base, void* d, uint64_t s, + udb_walk_relptr_cb* cb, void* arg); +/** for use in udb-walkfunc, walks relptrs in udb_chunk_type_domain */ +void udb_domain_walk_chunk(void* base, void* d, uint64_t s, + udb_walk_relptr_cb* cb, void* arg); +/** for use in udb-walkfunc, walks relptrs in udb_chunk_type_rrset */ +void udb_rrset_walk_chunk(void* base, void* d, uint64_t s, + udb_walk_relptr_cb* cb, void* arg); +/** for use in udb-walkfunc, walks relptrs in udb_chunk_type_rr */ +void udb_rr_walk_chunk(void* base, void* d, uint64_t s, + udb_walk_relptr_cb* cb, void* arg); + +/** walk through relptrs in registered types */ +void namedb_walkfunc(void* base, void* warg, uint8_t t, void* d, uint64_t s, + udb_walk_relptr_cb* cb, void* arg); + +#define ZONE(ptr) ((struct zone_d*)UDB_PTR(ptr)) +#define DOMAIN(ptr) ((struct domain_d*)UDB_PTR(ptr)) +#define RRSET(ptr) ((struct rrset_d*)UDB_PTR(ptr)) +#define RR(ptr) ((struct rr_d*)UDB_PTR(ptr)) + +#endif /* UDB_ZONE_H */ diff --git a/usr.sbin/nsd/xfrd-disk.h b/usr.sbin/nsd/xfrd-disk.h index 42db1993180..2c8e23fc752 100644 --- a/usr.sbin/nsd/xfrd-disk.h +++ b/usr.sbin/nsd/xfrd-disk.h @@ -1,7 +1,7 @@ /* * xfrd-disk.h - XFR (transfer) Daemon TCP system header file. Save/Load state to disk. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -10,8 +10,8 @@ #ifndef XFRD_DISK_H #define XFRD_DISK_H -#include "config.h" struct xfrd_state; +struct nsd; /* magic string to identify xfrd state file */ #define XFRD_FILE_MAGIC "NSDXFRD1" @@ -21,4 +21,13 @@ void xfrd_read_state(struct xfrd_state* xfrd); /* write xfrd zone state if possible */ void xfrd_write_state(struct xfrd_state* xfrd); +/* create temp directory */ +void xfrd_make_tempdir(struct nsd* nsd); +/* rmdir temp directory */ +void xfrd_del_tempdir(struct nsd* nsd); +/* open temp file, makes directory if needed */ +FILE* xfrd_open_xfrfile(struct nsd* nsd, uint64_t number, char* mode); +/* unlink temp file */ +void xfrd_unlink_xfrfile(struct nsd* nsd, uint64_t number); + #endif /* XFRD_DISK_H */ diff --git a/usr.sbin/nsd/xfrd-notify.c b/usr.sbin/nsd/xfrd-notify.c index 0aa5c2c6cd7..6fb8e00e1e8 100644 --- a/usr.sbin/nsd/xfrd-notify.c +++ b/usr.sbin/nsd/xfrd-notify.c @@ -1,7 +1,7 @@ /* * xfrd-notify.c - notify sending routines * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -11,7 +11,7 @@ #include <assert.h> #include <string.h> #include <unistd.h> - +#include <errno.h> #include "xfrd-notify.h" #include "xfrd.h" #include "xfrd-tcp.h" @@ -22,8 +22,6 @@ /* start sending notifies */ static void notify_enable(struct notify_zone_t* zone, struct xfrd_soa* new_soa); -/* stop sending notifies */ -static void notify_disable(struct notify_zone_t* zone); /* setup the notify active state */ static void setup_notify_active(struct notify_zone_t* zone); @@ -31,21 +29,29 @@ static void setup_notify_active(struct notify_zone_t* zone); static int xfrd_handle_notify_reply(struct notify_zone_t* zone, buffer_type* packet); /* handle zone notify send */ -static void xfrd_handle_notify_send(netio_type *netio, - netio_handler_type *handler, netio_event_types_type event_types); +static void xfrd_handle_notify_send(int fd, short event, void* arg); static void xfrd_notify_next(struct notify_zone_t* zone); static void xfrd_notify_send_udp(struct notify_zone_t* zone, buffer_type* packet); static void +notify_send_disable(struct notify_zone_t* zone) +{ + zone->notify_send_enable = 0; + event_del(&zone->notify_send_handler); + if(zone->notify_send_handler.ev_fd != -1) { + close(zone->notify_send_handler.ev_fd); + } +} + +void notify_disable(struct notify_zone_t* zone) { zone->notify_current = 0; - zone->notify_send_handler.timeout = NULL; - if(zone->notify_send_handler.fd != -1) { - close(zone->notify_send_handler.fd); - zone->notify_send_handler.fd = -1; + /* if added, then remove */ + if(zone->notify_send_enable) { + notify_send_disable(zone); } if(xfrd->notify_udp_num == XFRD_MAX_UDP_NOTIFY) { @@ -56,6 +62,8 @@ notify_disable(struct notify_zone_t* zone) assert(wz->is_waiting); wz->is_waiting = 0; xfrd->notify_waiting_first = wz->waiting_next; + if(wz->waiting_next) + wz->waiting_next->waiting_prev = NULL; if(xfrd->notify_waiting_last == wz) xfrd->notify_waiting_last = NULL; /* see if this zone needs notify sending */ @@ -72,13 +80,12 @@ notify_disable(struct notify_zone_t* zone) } void -init_notify_send(rbtree_t* tree, netio_type* netio, region_type* region, - const dname_type* apex, zone_options_t* options, zone_type* dbzone) +init_notify_send(rbtree_t* tree, region_type* region, zone_options_t* options) { struct notify_zone_t* not = (struct notify_zone_t*) region_alloc(region, sizeof(struct notify_zone_t)); memset(not, 0, sizeof(struct notify_zone_t)); - not->apex = apex; + not->apex = options->node.key; not->apex_str = options->name; not->node.key = not->apex; not->options = options; @@ -87,23 +94,49 @@ init_notify_send(rbtree_t* tree, netio_type* netio, region_type* region, not->current_soa = (struct xfrd_soa*)region_alloc(region, sizeof(struct xfrd_soa)); memset(not->current_soa, 0, sizeof(struct xfrd_soa)); - if(dbzone && dbzone->soa_rrset && dbzone->soa_rrset->rrs) { - xfrd_copy_soa(not->current_soa, dbzone->soa_rrset->rrs); - } not->is_waiting = 0; - not->notify_send_handler.fd = -1; - not->notify_send_handler.timeout = 0; - not->notify_send_handler.user_data = not; - not->notify_send_handler.event_types = - NETIO_EVENT_READ|NETIO_EVENT_TIMEOUT; - not->notify_send_handler.event_handler = xfrd_handle_notify_send; - netio_add_handler(netio, ¬->notify_send_handler); - tsig_create_record_custom(¬->notify_tsig, region, 0, 0, 4); + + not->notify_send_enable = 0; + tsig_create_record_custom(¬->notify_tsig, NULL, 0, 0, 4); not->notify_current = 0; rbtree_insert(tree, (rbnode_t*)not); } +void +xfrd_del_notify(xfrd_state_t* xfrd, const dname_type* dname) +{ + /* find it */ + struct notify_zone_t* not = (struct notify_zone_t*)rbtree_delete( + xfrd->notify_zones, dname); + if(!not) + return; + + /* waiting list */ + if(not->is_waiting) { + if(not->waiting_prev) + not->waiting_prev->waiting_next = not->waiting_next; + else xfrd->notify_waiting_first = not->waiting_next; + if(not->waiting_next) + not->waiting_next->waiting_prev = not->waiting_prev; + else xfrd->notify_waiting_last = not->waiting_prev; + not->is_waiting = 0; + } + + /* event */ + if(not->notify_send_enable) { + notify_disable(not); + } + + /* del tsig */ + tsig_delete_record(¬->notify_tsig, NULL); + + /* free it */ + region_recycle(xfrd->region, not->current_soa, sizeof(xfrd_soa_t)); + /* the apex is recycled when the zone_options.node.key is removed */ + region_recycle(xfrd->region, not, sizeof(*not)); +} + static int xfrd_handle_notify_reply(struct notify_zone_t* zone, buffer_type* packet) { @@ -151,13 +184,15 @@ xfrd_notify_next(struct notify_zone_t* zone) static void xfrd_notify_send_udp(struct notify_zone_t* zone, buffer_type* packet) { - if(zone->notify_send_handler.fd != -1) - close(zone->notify_send_handler.fd); - zone->notify_send_handler.fd = -1; + int fd; + if(zone->notify_send_enable) { + notify_send_disable(zone); + } /* Set timeout for next reply */ - zone->notify_timeout.tv_sec = xfrd_time() + XFRD_NOTIFY_RETRY_TIMOUT; + zone->notify_timeout.tv_sec = XFRD_NOTIFY_RETRY_TIMOUT; /* send NOTIFY to secondary. */ - xfrd_setup_packet(packet, TYPE_SOA, CLASS_IN, zone->apex); + xfrd_setup_packet(packet, TYPE_SOA, CLASS_IN, zone->apex, + qid_generate()); zone->notify_query_id = ID(packet); OPCODE_SET(packet, OPCODE_NOTIFY); AA_SET(packet); @@ -170,41 +205,53 @@ xfrd_notify_send_udp(struct notify_zone_t* zone, buffer_type* packet) xfrd_tsig_sign_request(packet, &zone->notify_tsig, zone->notify_current); } buffer_flip(packet); - zone->notify_send_handler.fd = xfrd_send_udp(zone->notify_current, - packet, zone->options->outgoing_interface); - if(zone->notify_send_handler.fd == -1) { + fd = xfrd_send_udp(zone->notify_current, packet, + zone->options->pattern->outgoing_interface); + if(fd == -1) { log_msg(LOG_ERR, "xfrd: zone %s: could not send notify #%d to %s", zone->apex_str, zone->notify_retry, zone->notify_current->ip_address_spec); + event_set(&zone->notify_send_handler, -1, EV_TIMEOUT, + xfrd_handle_notify_send, zone); + if(event_base_set(xfrd->event_base, &zone->notify_send_handler) != 0) + log_msg(LOG_ERR, "notify_send: event_base_set failed"); + if(evtimer_add(&zone->notify_send_handler, &zone->notify_timeout) != 0) + log_msg(LOG_ERR, "notify_send: evtimer_add failed"); + zone->notify_send_enable = 1; return; } + event_set(&zone->notify_send_handler, fd, EV_READ | EV_TIMEOUT, + xfrd_handle_notify_send, zone); + if(event_base_set(xfrd->event_base, &zone->notify_send_handler) != 0) + log_msg(LOG_ERR, "notify_send: event_base_set failed"); + if(event_add(&zone->notify_send_handler, &zone->notify_timeout) != 0) + log_msg(LOG_ERR, "notify_send: evtimer_add failed"); + zone->notify_send_enable = 1; DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: zone %s: sent notify #%d to %s", zone->apex_str, zone->notify_retry, zone->notify_current->ip_address_spec)); } static void -xfrd_handle_notify_send(netio_type* ATTR_UNUSED(netio), - netio_handler_type *handler, netio_event_types_type event_types) +xfrd_handle_notify_send(int fd, short event, void* arg) { - struct notify_zone_t* zone = (struct notify_zone_t*)handler->user_data; + struct notify_zone_t* zone = (struct notify_zone_t*)arg; buffer_type* packet = xfrd_get_temp_buffer(); assert(zone->notify_current); if(zone->is_waiting) { DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: notify waiting, skipped, %s", zone->apex_str)); - assert(zone->notify_send_handler.fd == -1); return; } - if(event_types & NETIO_EVENT_READ) { + if((event & EV_READ)) { DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: zone %s: read notify ACK", zone->apex_str)); - assert(handler->fd != -1); - if(xfrd_udp_read_packet(packet, zone->notify_send_handler.fd)) { + assert(fd != -1); + if(xfrd_udp_read_packet(packet, fd)) { if(xfrd_handle_notify_reply(zone, packet)) xfrd_notify_next(zone); } - } else if(event_types & NETIO_EVENT_TIMEOUT) { + } else if((event & EV_TIMEOUT)) { DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: zone %s: notify timeout", zone->apex_str)); /* timeout, try again */ @@ -212,7 +259,7 @@ xfrd_handle_notify_send(netio_type* ATTR_UNUSED(netio), /* see if notify is still enabled */ if(zone->notify_current) { zone->notify_retry++; - if(zone->notify_retry > zone->options->notify_retry) { + if(zone->notify_retry > zone->options->pattern->notify_retry) { log_msg(LOG_ERR, "xfrd: zone %s: max notify send count reached, %s unreachable", zone->apex_str, zone->notify_current->ip_address_spec); xfrd_notify_next(zone); @@ -228,16 +275,25 @@ static void setup_notify_active(struct notify_zone_t* zone) { zone->notify_retry = 0; - zone->notify_current = zone->options->notify; - zone->notify_send_handler.timeout = &zone->notify_timeout; - zone->notify_timeout.tv_sec = xfrd_time(); - zone->notify_timeout.tv_nsec = 0; + zone->notify_current = zone->options->pattern->notify; + zone->notify_timeout.tv_sec = 0; + zone->notify_timeout.tv_usec = 0; + + if(zone->notify_send_enable) + notify_send_disable(zone); + event_set(&zone->notify_send_handler, -1, EV_TIMEOUT, + xfrd_handle_notify_send, zone); + if(event_base_set(xfrd->event_base, &zone->notify_send_handler) != 0) + log_msg(LOG_ERR, "notifysend: event_base_set failed"); + if(evtimer_add(&zone->notify_send_handler, &zone->notify_timeout) != 0) + log_msg(LOG_ERR, "notifysend: evtimer_add failed"); + zone->notify_send_enable = 1; } static void notify_enable(struct notify_zone_t* zone, struct xfrd_soa* new_soa) { - if(!zone->options->notify) { + if(!zone->options->pattern->notify) { return; /* no notify acl, nothing to do */ } @@ -254,27 +310,37 @@ notify_enable(struct notify_zone_t* zone, struct xfrd_soa* new_soa) return; } /* put it in waiting list */ - zone->notify_current = zone->options->notify; + zone->notify_current = zone->options->pattern->notify; zone->is_waiting = 1; zone->waiting_next = NULL; + zone->waiting_prev = xfrd->notify_waiting_last; if(xfrd->notify_waiting_last) { xfrd->notify_waiting_last->waiting_next = zone; } else { xfrd->notify_waiting_first = zone; } xfrd->notify_waiting_last = zone; - zone->notify_send_handler.timeout = NULL; DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: zone %s: notify on waiting list.", zone->apex_str)); } void +xfrd_notify_start(struct notify_zone_t* zone) +{ + if(zone->is_waiting || zone->notify_send_enable) + return; + notify_enable(zone, NULL); +} + +void xfrd_send_notify(rbtree_t* tree, const dname_type* apex, struct xfrd_soa* new_soa) { /* lookup the zone */ struct notify_zone_t* zone = (struct notify_zone_t*) rbtree_search(tree, apex); assert(zone); + if(zone->notify_send_enable) + notify_disable(zone); notify_enable(zone, new_soa); } @@ -286,24 +352,24 @@ notify_handle_master_zone_soainfo(rbtree_t* tree, /* lookup the zone */ struct notify_zone_t* zone = (struct notify_zone_t*) rbtree_search(tree, apex); - assert(zone); + if(!zone) return; /* got SOAINFO but zone was deleted meanwhile */ /* check if SOA changed */ if( (new_soa == NULL && zone->current_soa->serial == 0) || (new_soa && new_soa->serial == zone->current_soa->serial)) return; - + if(zone->notify_send_enable) + notify_disable(zone); notify_enable(zone, new_soa); } -void close_notify_fds(rbtree_t* tree) +void +close_notify_fds(rbtree_t* tree) { struct notify_zone_t* zone; RBTREE_FOR(zone, struct notify_zone_t*, tree) { - if(zone->notify_send_handler.fd != -1) { - close(zone->notify_send_handler.fd); - zone->notify_send_handler.fd = -1; - } + if(zone->notify_send_enable) + notify_send_disable(zone); } } diff --git a/usr.sbin/nsd/xfrd-notify.h b/usr.sbin/nsd/xfrd-notify.h index 242c7e763ca..4f084d302e7 100644 --- a/usr.sbin/nsd/xfrd-notify.h +++ b/usr.sbin/nsd/xfrd-notify.h @@ -1,7 +1,7 @@ /* * xfrd-notify.h - notify sending routines. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -10,9 +10,12 @@ #ifndef XFRD_NOTIFY_H #define XFRD_NOTIFY_H -#include "config.h" +#ifndef USE_MINI_EVENT +#include <event.h> +#else +#include "mini_event.h" +#endif #include "tsig.h" -#include "netio.h" #include "rbtree.h" struct nsd; @@ -22,6 +25,7 @@ struct zone_options; struct zone; struct xfrd_soa; struct acl_options; +struct xfrd_state; /** * This struct keeps track of outbound notifies for a zone. @@ -38,26 +42,32 @@ struct notify_zone_t { /* notify sending handler */ /* Not saved on disk (i.e. kill of daemon stops notifies) */ - netio_handler_type notify_send_handler; - struct timespec notify_timeout; + int notify_send_enable; + struct event notify_send_handler; + struct timeval notify_timeout; struct acl_options* notify_current; /* current slave to notify */ + uint8_t notify_restart; /* restart notify after repattern */ uint8_t notify_retry; /* how manieth retry in sending to current */ uint16_t notify_query_id; /* is this notify waiting for a socket? */ uint8_t is_waiting; - /* next in the waiting list for the udp sockets */ + /* the double linked waiting list for the udp sockets */ struct notify_zone_t* waiting_next; + struct notify_zone_t* waiting_prev; }; /* initialise outgoing notifies */ -void init_notify_send(rbtree_t* tree, netio_type* netio, region_type* region, - const dname_type* apex, struct zone_options* options, - struct zone* dbzone); +void init_notify_send(rbtree_t* tree, region_type* region, + struct zone_options* options); +/* delete notify zone */ +void xfrd_del_notify(struct xfrd_state* xfrd, const dname_type* dname); /* send notifications to all in the notify list */ void xfrd_send_notify(rbtree_t* tree, const struct dname* apex, struct xfrd_soa* new_soa); +/* start notifications, if not started already (does not clobber SOA) */ +void xfrd_notify_start(struct notify_zone_t* zone); /* handle soa update notify for a master zone. newsoa can be NULL. Makes sure that the soa (serial) has changed. Or drops notify. */ @@ -66,5 +76,7 @@ void notify_handle_master_zone_soainfo(rbtree_t* tree, /* close fds in use for notification sending */ void close_notify_fds(rbtree_t* tree); +/* stop send of notify */ +void notify_disable(struct notify_zone_t* zone); #endif /* XFRD_NOTIFY_H */ diff --git a/usr.sbin/nsd/xfrd-tcp.h b/usr.sbin/nsd/xfrd-tcp.h index e42e1a4456a..ac3f9dc5aab 100644 --- a/usr.sbin/nsd/xfrd-tcp.h +++ b/usr.sbin/nsd/xfrd-tcp.h @@ -1,7 +1,7 @@ /* * xfrd-tcp.h - XFR (transfer) Daemon TCP system header file. Manages tcp conn. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -10,7 +10,6 @@ #ifndef XFRD_TCP_H #define XFRD_TCP_H -#include "config.h" #include "xfrd.h" struct buffer; @@ -21,6 +20,7 @@ struct region; struct dname; struct acl_options; +struct xfrd_tcp_pipeline; typedef struct xfrd_tcp xfrd_tcp_t; typedef struct xfrd_tcp_set xfrd_tcp_set_t; /* @@ -28,12 +28,14 @@ typedef struct xfrd_tcp_set xfrd_tcp_set_t; */ struct xfrd_tcp_set { /* tcp connections, each has packet and read/wr state */ - struct xfrd_tcp *tcp_state[XFRD_MAX_TCP]; + struct xfrd_tcp_pipeline *tcp_state[XFRD_MAX_TCP]; /* number of TCP connections in use. */ int tcp_count; /* TCP timeout. */ int tcp_timeout; - /* linked list of zones waiting for a TCP connection */ + /* rbtree with pipelines sorted by master */ + rbtree_t* pipetree; + /* double linked list of zones waiting for a TCP connection */ struct xfrd_zone *tcp_waiting_first, *tcp_waiting_last; }; @@ -61,27 +63,91 @@ struct xfrd_tcp { struct buffer* packet; }; +/* use illegal pointer value to denote skipped ID number. + * if this does not work, we can allocate with malloc */ +#define TCP_NULL_SKIP ((struct xfrd_zone*)-1) +/* the number of ID values (16 bits) for a pipeline */ +#define ID_PIPE_NUM 65536 + +/** + * Structure to keep track of a pipelined set of queries on + * an open tcp connection. The queries may be answered with + * interleaved answer packets, the ID number disambiguates. + * Sorted by the master IP address so you can use lookup with + * smaller-or-equal to find the tcp connection most suitable. + */ +struct xfrd_tcp_pipeline { + /* the rbtree node, sorted by IP and nr of unused queries */ + rbnode_t node; + /* destination IP address */ +#ifdef INET6 + struct sockaddr_storage ip; +#else + struct sockaddr_in ip; +#endif /* INET6 */ + socklen_t ip_len; + /* number of unused IDs. used IDs are waiting to send their query, + * or have been sent but not not all answer packets have been received. + * Sorted by num_unused, so a lookup smaller-equal for 65536 finds the + * connection to that master that has the most free IDs. */ + int num_unused; + /* number of skip-set IDs (these are 'in-use') */ + int num_skip; + + int handler_added; + /* the event handler for this pipe (it'll disambiguate by ID) */ + struct event handler; + + /* the tcp connection to use for reading */ + xfrd_tcp_t* tcp_r; + /* the tcp connection to use for writing, if it is done successfully, + * then the first zone from the sendlist can be removed. */ + xfrd_tcp_t* tcp_w; + /* once a byte has been written, handshake complete */ + int connection_established; + + /* list of queries that want to send, first to get write event, + * if NULL, no write event interest */ + struct xfrd_zone* tcp_send_first, *tcp_send_last; + /* the unused and id arrays must be last in the structure */ + /* per-ID number the queries that have this ID number, every + * query owns one ID numbers (until it is done). NULL: unused + * When a query is done but not all answer-packets have been + * consumed for that ID number, the rest is skipped, this + * is denoted with the pointer-value TCP_NULL_SKIP, the ids that + * are skipped are not on the unused list. They may be + * removed once the last answer packet is skipped. + * ID_PIPE_NUM-num_unused values in the id array are nonNULL (either + * a zone pointer or SKIP) */ + struct xfrd_zone* id[ID_PIPE_NUM]; + /* unused ID numbers; the first part of the array contains the IDs */ + uint16_t unused[ID_PIPE_NUM]; +}; + /* create set of tcp connections */ xfrd_tcp_set_t* xfrd_tcp_set_create(struct region* region); /* init tcp state */ -xfrd_tcp_t* xfrd_tcp_create(struct region* region); +xfrd_tcp_t* xfrd_tcp_create(struct region* region, size_t bufsize); /* obtain tcp connection for a zone (or wait) */ void xfrd_tcp_obtain(xfrd_tcp_set_t* set, struct xfrd_zone* zone); /* release tcp connection for a zone (starts waiting) */ void xfrd_tcp_release(xfrd_tcp_set_t* set, struct xfrd_zone* zone); +/* release tcp pipe entirely (does not stop the zones inside it) */ +void xfrd_tcp_pipe_release(xfrd_tcp_set_t* set, struct xfrd_tcp_pipeline* tp, + int conn); /* use tcp connection to start xfr */ -void xfrd_tcp_xfr(xfrd_tcp_set_t* set, struct xfrd_zone* zone); +void xfrd_tcp_setup_write_packet(struct xfrd_tcp_pipeline* tp, + struct xfrd_zone* zone); /* initialize tcp_state for a zone. Opens the connection. true on success.*/ -int xfrd_tcp_open(xfrd_tcp_set_t* set, struct xfrd_zone* zone); +int xfrd_tcp_open(xfrd_tcp_set_t* set, struct xfrd_tcp_pipeline* tp, struct xfrd_zone* zone); /* read data from tcp, maybe partial read */ -void xfrd_tcp_read(xfrd_tcp_set_t* set, struct xfrd_zone* zone); +void xfrd_tcp_read(struct xfrd_tcp_pipeline* tp); /* write data to tcp, maybe a partial write */ -void xfrd_tcp_write(xfrd_tcp_set_t* set, struct xfrd_zone* zone); +void xfrd_tcp_write(struct xfrd_tcp_pipeline* tp, struct xfrd_zone* zone); +/* handle tcp pipe events */ +void xfrd_handle_tcp_pipe(int fd, short event, void* arg); -/* see if the tcp connection is in the reading stage (else writin) */ -static inline int xfrd_tcp_is_reading(xfrd_tcp_set_t* set, int conn) -{return set->tcp_state[conn]->is_reading;} /* * Read from a stream connection (size16)+packet into buffer. * returns value is @@ -103,7 +169,7 @@ int conn_write(xfrd_tcp_t* conn); /* setup DNS packet for a query of this type */ void xfrd_setup_packet(struct buffer* packet, - uint16_t type, uint16_t klass, const struct dname* dname); + uint16_t type, uint16_t klass, const struct dname* dname, uint16_t qid); /* write soa in network format to the packet buffer */ void xfrd_write_soa_buffer(struct buffer* packet, const struct dname* apex, struct xfrd_soa* soa); @@ -122,4 +188,7 @@ socklen_t xfrd_acl_sockaddr_frm(struct acl_options* acl, struct sockaddr_in *frm); #endif /* INET6 */ +/* create pipeline tcp structure */ +struct xfrd_tcp_pipeline* xfrd_tcp_pipeline_create(region_type* region); + #endif /* XFRD_TCP_H */ diff --git a/usr.sbin/nsd/xfrd.h b/usr.sbin/nsd/xfrd.h index e4d6a278259..b71f8c54f5e 100644 --- a/usr.sbin/nsd/xfrd.h +++ b/usr.sbin/nsd/xfrd.h @@ -1,7 +1,7 @@ /* * xfrd.h - XFR (transfer) Daemon header file. Coordinates SOA updates. * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved. * * See LICENSE for the license. * @@ -10,8 +10,11 @@ #ifndef XFRD_H #define XFRD_H -#include "config.h" -#include "netio.h" +#ifndef USE_MINI_EVENT +#include <event.h> +#else +#include "mini_event.h" +#endif #include "rbtree.h" #include "namedb.h" #include "options.h" @@ -24,6 +27,7 @@ struct buffer; struct xfrd_tcp; struct xfrd_tcp_set; struct notify_zone_t; +struct udb_ptr; typedef struct xfrd_state xfrd_state_t; typedef struct xfrd_zone xfrd_zone_t; typedef struct xfrd_soa xfrd_soa_t; @@ -35,41 +39,47 @@ struct xfrd_state { /* time when daemon was last started */ time_t xfrd_start_time; struct region* region; - netio_type* netio; + struct event_base* event_base; struct nsd* nsd; struct xfrd_tcp_set* tcp_set; /* packet buffer for udp packets */ struct buffer* packet; - /* udp waiting list */ + /* udp waiting list, double linked list */ struct xfrd_zone *udp_waiting_first, *udp_waiting_last; /* number of udp sockets (for sending queries) in use */ size_t udp_use_num; + /* activated waiting list, double linked list */ + struct xfrd_zone *activated_first; /* current time is cached */ uint8_t got_time; time_t current_time; + /* counter for xfr file numbers */ + uint64_t xfrfilenumber; + /* timer for NSD reload */ - struct timespec reload_timeout; - netio_handler_type reload_handler; + struct timeval reload_timeout; + struct event reload_handler; + int reload_added; /* last reload must have caught all zone updates before this time */ time_t reload_cmd_last_sent; uint8_t can_send_reload; + pid_t reload_pid; /* communication channel with server_main */ - netio_handler_type ipc_handler; - uint8_t ipc_is_soa; - uint8_t parent_soa_info_pass; + struct event ipc_handler; + int ipc_handler_flags; struct xfrd_tcp *ipc_conn; struct buffer* ipc_pass; /* sending ipc to server_main */ - struct xfrd_tcp *ipc_conn_write; + uint8_t need_to_send_shutdown; uint8_t need_to_send_reload; + uint8_t need_to_send_stats; uint8_t need_to_send_quit; - uint8_t sending_zone_state; uint8_t ipc_send_blocked; - stack_type* dirty_zones; /* stack of xfrd_zone* */ + struct udb_ptr* last_task; /* xfrd shutdown flag */ uint8_t shutdown; @@ -138,10 +148,6 @@ struct xfrd_zone { xfrd_zone_expired } state; - /* if state is dirty it needs to be sent to server_main. - * it is also on the dirty_stack. Not saved on disk. */ - uint8_t dirty; - /* master to try to transfer from, number for persistence */ acl_options_t* master; int master_num; @@ -152,8 +158,10 @@ struct xfrd_zone { int fresh_xfr_timeout; /* handler for timeouts */ - struct timespec timeout; - netio_handler_type zone_handler; + struct timeval timeout; + struct event zone_handler; + int zone_handler_flags; + int event_added; /* tcp connection zone is using, or -1 */ int tcp_conn; @@ -161,10 +169,22 @@ struct xfrd_zone { uint8_t tcp_waiting; /* next zone in waiting list */ xfrd_zone_t* tcp_waiting_next; + xfrd_zone_t* tcp_waiting_prev; + /* zone is in its tcp send queue */ + uint8_t in_tcp_send; + /* next zone in tcp send queue */ + xfrd_zone_t* tcp_send_next; + xfrd_zone_t* tcp_send_prev; /* zone is waiting for a udp connection (tcp is preferred) */ uint8_t udp_waiting; /* next zone in waiting list for UDP */ xfrd_zone_t* udp_waiting_next; + xfrd_zone_t* udp_waiting_prev; + /* zone has been activated to run now (after the other events + * but before blocking in select again) */ + uint8_t is_activated; + xfrd_zone_t* activated_next; + xfrd_zone_t* activated_prev; /* xfr message handling data */ /* query id */ @@ -174,6 +194,8 @@ struct xfrd_zone { size_t msg_rr_count; uint8_t msg_is_ixfr; /* 1:IXFR detected. 2:middle IXFR SOA seen. */ tsig_record_type tsig; /* tsig state for IXFR/AXFR */ + uint64_t xfrfilenumber; /* identifier for file to store xfr into, + valid if msg_seq_nr nonzero */ }; enum xfrd_packet_result { @@ -194,18 +216,24 @@ enum xfrd_packet_result { Note that also some sockets are used for writing the ixfr.db, xfrd.state files and for the pipes to the main parent process. */ -#define XFRD_MAX_TCP 50 /* max number of TCP AXFR/IXFR concurrent connections.*/ +#define XFRD_MAX_TCP 32 /* max number of TCP AXFR/IXFR concurrent connections.*/ /* Each entry has 64Kb buffer preallocated.*/ -#define XFRD_MAX_UDP 100 /* max number of UDP sockets at a time for IXFR */ -#define XFRD_MAX_UDP_NOTIFY 50 /* max concurrent UDP sockets for NOTIFY */ +#define XFRD_MAX_UDP 64 /* max number of UDP sockets at a time for IXFR */ +#define XFRD_MAX_UDP_NOTIFY 64 /* max concurrent UDP sockets for NOTIFY */ extern xfrd_state_t* xfrd; /* start xfrd, new start. Pass socket to server_main. */ -void xfrd_init(int socket, struct nsd* nsd); +void xfrd_init(int socket, struct nsd* nsd, int shortsoa, int reload_active); + +/* add new slave zone, dname(from zone_opt) and given options */ +void xfrd_init_slave_zone(xfrd_state_t* xfrd, zone_options_t* zone_opt); + +/* delete slave zone */ +void xfrd_del_slave_zone(xfrd_state_t* xfrd, const dname_type* dname); /* get the current time epoch. Cached for speed. */ -time_t xfrd_time(); +time_t xfrd_time(void); /* * Handle final received packet from network. @@ -220,6 +248,8 @@ void xfrd_set_timer(xfrd_zone_t* zone, time_t t); void xfrd_set_refresh_now(xfrd_zone_t* zone); /* unset the timer - no more timeouts, for when zone is queued */ void xfrd_unset_timer(xfrd_zone_t* zone); +/* remove the 'refresh now', remove it from the activated list */ +void xfrd_deactivate_zone(xfrd_zone_t* z); /* * Make a new request to next master server. @@ -249,7 +279,7 @@ void xfrd_udp_release(xfrd_zone_t* zone); /* * Get a static buffer for temporary use (to build a packet). */ -struct buffer* xfrd_get_temp_buffer(); +struct buffer* xfrd_get_temp_buffer(void); /* * TSIG sign outgoing request. Call if acl has a key. @@ -268,27 +298,41 @@ void xfrd_handle_incoming_soa(xfrd_zone_t* zone, xfrd_soa_t* soa, void xfrd_handle_passed_packet(buffer_type* packet, int acl_num, int acl_xfr); -/* send expiry notify for all zones to nsd (sets all dirty). */ -void xfrd_send_expy_all_zones(); - /* try to reopen the logfile. */ -void xfrd_reopen_logfile(); +void xfrd_reopen_logfile(void); + +/* free namedb for xfrd usage */ +void xfrd_free_namedb(struct nsd* nsd); /* copy SOA info from rr to soa struct. */ void xfrd_copy_soa(xfrd_soa_t* soa, rr_type* rr); /* check for failed updates - it is assumed that now the reload has finished, and all zone SOAs have been sent. */ -void xfrd_check_failed_updates(); +void xfrd_check_failed_updates(void); /* * Prepare zones for a reload, this sets the times on the zones to be * before the current time, so the reload happens after. */ -void xfrd_prepare_zones_for_reload(); +void xfrd_prepare_zones_for_reload(void); /* Bind a local interface to a socket descriptor, return 1 on success */ int xfrd_bind_local_interface(int sockd, acl_options_t* ifc, acl_options_t* acl, int tcp); +/* process results and soa info from reload */ +void xfrd_process_task_result(xfrd_state_t* xfrd, struct udb_base* taskudb); + +/* set to reload right away (for user controlled reload events) */ +void xfrd_set_reload_now(xfrd_state_t* xfrd); + +/* handle incoming notify (soa or NULL) and start zone xfr if necessary */ +void xfrd_handle_notify_and_start_xfr(xfrd_zone_t* zone, xfrd_soa_t* soa); + +/* handle zone timeout, event */ +void xfrd_handle_zone(int fd, short event, void* arg); + +const char* xfrd_pretty_time(time_t v); + #endif /* XFRD_H */ diff --git a/usr.sbin/nsd/zlexer.lex b/usr.sbin/nsd/zlexer.lex index 666a4ba3135..bcb5661ab80 100644 --- a/usr.sbin/nsd/zlexer.lex +++ b/usr.sbin/nsd/zlexer.lex @@ -2,7 +2,7 @@ /* * zlexer.lex - lexical analyzer for (DNS) zone files * - * Copyright (c) 2001-2011, NLnet Labs. All rights reserved. + * Copyright (c) 2001-2006, NLnet Labs. All rights reserved * * See LICENSE for the license. * @@ -19,8 +19,6 @@ #include "dname.h" #include "zparser.h" -#define YY_NO_UNPUT - #if 0 #define LEXOUT(s) printf s /* used ONLY when debugging */ #else @@ -68,6 +66,23 @@ pop_parser_state(void) yy_switch_to_buffer(include_stack[include_stack_ptr]); } +static YY_BUFFER_STATE oldstate; +/* Start string scan */ +void +parser_push_stringbuf(char* str) +{ + oldstate = YY_CURRENT_BUFFER; + yy_switch_to_buffer(yy_scan_string(str)); +} + +void +parser_pop_stringbuf(void) +{ + yy_delete_buffer(YY_CURRENT_BUFFER); + yy_switch_to_buffer(oldstate); + oldstate = NULL; +} + #ifndef yy_set_bol /* compat definition, for flex 2.4.6 */ #define yy_set_bol(at_bol) \ { \ @@ -78,6 +93,16 @@ pop_parser_state(void) #endif %} +%option noinput +%option nounput +%{ +#ifndef YY_NO_UNPUT +#define YY_NO_UNPUT 1 +#endif +#ifndef YY_NO_INPUT +#define YY_NO_INPUT 1 +#endif +%} SPACE [ \t] LETTER [a-zA-Z] @@ -244,6 +269,8 @@ ANY [^\"\n\\]|\\. <bitlabel><<EOF>> { zc_error("EOF inside bitlabel"); BEGIN(INITIAL); + yyrestart(yyin); /* this is so that lex does not give an internal err */ + yyterminate(); } <bitlabel>{BIT}* { yymore(); } <bitlabel>\n { ++parser->line; yymore(); } @@ -258,6 +285,8 @@ ANY [^\"\n\\]|\\. <quotedstring><<EOF>> { zc_error("EOF inside quoted string"); BEGIN(INITIAL); + yyrestart(yyin); /* this is so that lex does not give an internal err */ + yyterminate(); } <quotedstring>{ANY}* { LEXOUT(("STR ")); yymore(); } <quotedstring>\n { ++parser->line; yymore(); } |