diff options
Diffstat (limited to 'iterator/iter_hints.c')
| -rw-r--r-- | iterator/iter_hints.c | 534 |
1 files changed, 534 insertions, 0 deletions
diff --git a/iterator/iter_hints.c b/iterator/iter_hints.c new file mode 100644 index 000000000000..cfb9db7abb8c --- /dev/null +++ b/iterator/iter_hints.c @@ -0,0 +1,534 @@ +/* + * iterator/iter_hints.c - iterative resolver module stub and root hints. + * + * 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 contains functions to assist the iterator module. + * Keep track of stub and root hints, and read those from config. + */ +#include "config.h" +#include <ldns/dname.h> +#include <ldns/rr.h> +#include "iterator/iter_hints.h" +#include "iterator/iter_delegpt.h" +#include "util/log.h" +#include "util/config_file.h" +#include "util/net_help.h" +#include "util/data/dname.h" + +struct iter_hints* +hints_create(void) +{ + struct iter_hints* hints = (struct iter_hints*)calloc(1, + sizeof(struct iter_hints)); + if(!hints) + return NULL; + return hints; +} + +static void hints_stub_free(struct iter_hints_stub* s) +{ + if(!s) return; + delegpt_free_mlc(s->dp); + free(s); +} + +static void delhintnode(rbnode_t* n, void* ATTR_UNUSED(arg)) +{ + struct iter_hints_stub* node = (struct iter_hints_stub*)n; + hints_stub_free(node); +} + +static void hints_del_tree(struct iter_hints* hints) +{ + traverse_postorder(&hints->tree, &delhintnode, NULL); +} + +void +hints_delete(struct iter_hints* hints) +{ + if(!hints) + return; + hints_del_tree(hints); + free(hints); +} + +/** add hint to delegation hints */ +static int +ah(struct delegpt* dp, const char* sv, const char* ip) +{ + struct sockaddr_storage addr; + socklen_t addrlen; + ldns_rdf* rdf = ldns_dname_new_frm_str(sv); + if(!rdf) { + log_err("could not parse %s", sv); + return 0; + } + if(!delegpt_add_ns_mlc(dp, ldns_rdf_data(rdf), 0) || + !extstrtoaddr(ip, &addr, &addrlen) || + !delegpt_add_target_mlc(dp, ldns_rdf_data(rdf), ldns_rdf_size(rdf), + &addr, addrlen, 0, 0)) { + ldns_rdf_deep_free(rdf); + return 0; + } + ldns_rdf_deep_free(rdf); + return 1; +} + +/** obtain compiletime provided root hints */ +static struct delegpt* +compile_time_root_prime(int do_ip4, int do_ip6) +{ + /* from: + ; This file is made available by InterNIC + ; under anonymous FTP as + ; file /domain/named.cache + ; on server FTP.INTERNIC.NET + ; -OR- RS.INTERNIC.NET + ; + ; related version of root zone: 2010061700 + */ + struct delegpt* dp = delegpt_create_mlc((uint8_t*)"\000"); + if(!dp) + return NULL; + dp->has_parent_side_NS = 1; + if(do_ip4) { + if(!ah(dp, "A.ROOT-SERVERS.NET.", "198.41.0.4")) return 0; + if(!ah(dp, "B.ROOT-SERVERS.NET.", "192.228.79.201")) return 0; + if(!ah(dp, "C.ROOT-SERVERS.NET.", "192.33.4.12")) return 0; + if(!ah(dp, "D.ROOT-SERVERS.NET.", "128.8.10.90")) return 0; + if(!ah(dp, "E.ROOT-SERVERS.NET.", "192.203.230.10")) return 0; + if(!ah(dp, "F.ROOT-SERVERS.NET.", "192.5.5.241")) return 0; + if(!ah(dp, "G.ROOT-SERVERS.NET.", "192.112.36.4")) return 0; + if(!ah(dp, "H.ROOT-SERVERS.NET.", "128.63.2.53")) return 0; + if(!ah(dp, "I.ROOT-SERVERS.NET.", "192.36.148.17")) return 0; + if(!ah(dp, "J.ROOT-SERVERS.NET.", "192.58.128.30")) return 0; + if(!ah(dp, "K.ROOT-SERVERS.NET.", "193.0.14.129")) return 0; + if(!ah(dp, "L.ROOT-SERVERS.NET.", "199.7.83.42")) return 0; + if(!ah(dp, "M.ROOT-SERVERS.NET.", "202.12.27.33")) return 0; + } + if(do_ip6) { + if(!ah(dp, "A.ROOT-SERVERS.NET.", "2001:503:ba3e::2:30")) return 0; + if(!ah(dp, "D.ROOT-SERVERS.NET.", "2001:500:2d::d")) return 0; + if(!ah(dp, "F.ROOT-SERVERS.NET.", "2001:500:2f::f")) return 0; + if(!ah(dp, "H.ROOT-SERVERS.NET.", "2001:500:1::803f:235")) return 0; + if(!ah(dp, "I.ROOT-SERVERS.NET.", "2001:7fe::53")) return 0; + if(!ah(dp, "J.ROOT-SERVERS.NET.", "2001:503:c27::2:30")) return 0; + if(!ah(dp, "K.ROOT-SERVERS.NET.", "2001:7fd::1")) return 0; + if(!ah(dp, "L.ROOT-SERVERS.NET.", "2001:500:3::42")) return 0; + if(!ah(dp, "M.ROOT-SERVERS.NET.", "2001:dc3::35")) return 0; + } + return dp; +} + +/** insert new hint info into hint structure */ +static int +hints_insert(struct iter_hints* hints, uint16_t c, struct delegpt* dp, + int noprime) +{ + struct iter_hints_stub* node = (struct iter_hints_stub*)malloc( + sizeof(struct iter_hints_stub)); + if(!node) { + delegpt_free_mlc(dp); + return 0; + } + node->dp = dp; + node->noprime = (uint8_t)noprime; + if(!name_tree_insert(&hints->tree, &node->node, dp->name, dp->namelen, + dp->namelabs, c)) { + log_err("second hints ignored."); + delegpt_free_mlc(dp); + free(node); + } + return 1; +} + +/** set stub name */ +static struct delegpt* +read_stubs_name(struct config_stub* s) +{ + struct delegpt* dp; + ldns_rdf* rdf; + if(!s->name) { + log_err("stub zone without a name"); + return NULL; + } + rdf = ldns_dname_new_frm_str(s->name); + if(!rdf) { + log_err("cannot parse stub zone name %s", s->name); + return NULL; + } + if(!(dp=delegpt_create_mlc(ldns_rdf_data(rdf)))) { + ldns_rdf_deep_free(rdf); + log_err("out of memory"); + return NULL; + } + ldns_rdf_deep_free(rdf); + return dp; +} + +/** set stub host names */ +static int +read_stubs_host(struct config_stub* s, struct delegpt* dp) +{ + struct config_strlist* p; + ldns_rdf* rdf; + for(p = s->hosts; p; p = p->next) { + log_assert(p->str); + rdf = ldns_dname_new_frm_str(p->str); + if(!rdf) { + log_err("cannot parse stub %s nameserver name: '%s'", + s->name, p->str); + return 0; + } + if(!delegpt_add_ns_mlc(dp, ldns_rdf_data(rdf), 0)) { + ldns_rdf_deep_free(rdf); + log_err("out of memory"); + return 0; + } + ldns_rdf_deep_free(rdf); + } + return 1; +} + +/** set stub server addresses */ +static int +read_stubs_addr(struct config_stub* s, struct delegpt* dp) +{ + struct config_strlist* p; + struct sockaddr_storage addr; + socklen_t addrlen; + for(p = s->addrs; p; p = p->next) { + log_assert(p->str); + if(!extstrtoaddr(p->str, &addr, &addrlen)) { + log_err("cannot parse stub %s ip address: '%s'", + s->name, p->str); + return 0; + } + if(!delegpt_add_addr_mlc(dp, &addr, addrlen, 0, 0)) { + log_err("out of memory"); + return 0; + } + } + return 1; +} + +/** read stubs config */ +static int +read_stubs(struct iter_hints* hints, struct config_file* cfg) +{ + struct config_stub* s; + struct delegpt* dp; + for(s = cfg->stubs; s; s = s->next) { + if(!(dp=read_stubs_name(s)) || + !read_stubs_host(s, dp) || + !read_stubs_addr(s, dp)) + return 0; + /* the flag is turned off for 'stub-first' so that the + * last resort will ask for parent-side NS record and thus + * fallback to the internet name servers on a failure */ + dp->has_parent_side_NS = (uint8_t)!s->isfirst; + if(!hints_insert(hints, LDNS_RR_CLASS_IN, dp, !s->isprime)) + return 0; + delegpt_log(VERB_QUERY, dp); + } + return 1; +} + +/** read root hints from file */ +static int +read_root_hints(struct iter_hints* hints, char* fname) +{ + int lineno = 0; + uint32_t default_ttl = 0; + ldns_rdf* origin = NULL; + ldns_rdf* prev_rr = NULL; + struct delegpt* dp; + ldns_rr* rr = NULL; + ldns_status status; + uint16_t c = LDNS_RR_CLASS_IN; + FILE* f = fopen(fname, "r"); + if(!f) { + log_err("could not read root hints %s: %s", + fname, strerror(errno)); + return 0; + } + dp = delegpt_create_mlc(NULL); + if(!dp) { + log_err("out of memory reading root hints"); + fclose(f); + return 0; + } + verbose(VERB_QUERY, "Reading root hints from %s", fname); + dp->has_parent_side_NS = 1; + while(!feof(f)) { + status = ldns_rr_new_frm_fp_l(&rr, f, + &default_ttl, &origin, &prev_rr, &lineno); + if(status == LDNS_STATUS_SYNTAX_EMPTY || + status == LDNS_STATUS_SYNTAX_TTL || + status == LDNS_STATUS_SYNTAX_ORIGIN) + continue; + if(status != LDNS_STATUS_OK) { + log_err("reading root hints %s %d: %s", fname, + lineno, ldns_get_errorstr_by_id(status)); + goto stop_read; + } + if(ldns_rr_get_type(rr) == LDNS_RR_TYPE_NS) { + if(!delegpt_add_ns_mlc(dp, + ldns_rdf_data(ldns_rr_rdf(rr, 0)), 0)) { + log_err("out of memory reading root hints"); + goto stop_read; + } + c = ldns_rr_get_class(rr); + if(!dp->name) { + if(!delegpt_set_name_mlc(dp, + ldns_rdf_data(ldns_rr_owner(rr)))){ + log_err("out of memory."); + goto stop_read; + } + } + } else if(ldns_rr_get_type(rr) == LDNS_RR_TYPE_A) { + struct sockaddr_in sa; + socklen_t len = (socklen_t)sizeof(sa); + memset(&sa, 0, len); + sa.sin_family = AF_INET; + sa.sin_port = (in_port_t)htons(UNBOUND_DNS_PORT); + memmove(&sa.sin_addr, + ldns_rdf_data(ldns_rr_rdf(rr, 0)), INET_SIZE); + if(!delegpt_add_target_mlc(dp, + ldns_rdf_data(ldns_rr_owner(rr)), + ldns_rdf_size(ldns_rr_owner(rr)), + (struct sockaddr_storage*)&sa, len, + 0, 0)) { + log_err("out of memory reading root hints"); + goto stop_read; + } + } else if(ldns_rr_get_type(rr) == LDNS_RR_TYPE_AAAA) { + struct sockaddr_in6 sa; + socklen_t len = (socklen_t)sizeof(sa); + memset(&sa, 0, len); + sa.sin6_family = AF_INET6; + sa.sin6_port = (in_port_t)htons(UNBOUND_DNS_PORT); + memmove(&sa.sin6_addr, + ldns_rdf_data(ldns_rr_rdf(rr, 0)), INET6_SIZE); + if(!delegpt_add_target_mlc(dp, + ldns_rdf_data(ldns_rr_owner(rr)), + ldns_rdf_size(ldns_rr_owner(rr)), + (struct sockaddr_storage*)&sa, len, + 0, 0)) { + log_err("out of memory reading root hints"); + goto stop_read; + } + } else { + log_warn("root hints %s:%d skipping type %d", + fname, lineno, ldns_rr_get_type(rr)); + } + + ldns_rr_free(rr); + } + + if (origin) + ldns_rdf_deep_free(origin); + if (prev_rr) + ldns_rdf_deep_free(prev_rr); + fclose(f); + if(!dp->name) { + log_warn("root hints %s: no NS content", fname); + delegpt_free_mlc(dp); + return 1; + } + if(!hints_insert(hints, c, dp, 0)) { + return 0; + } + delegpt_log(VERB_QUERY, dp); + return 1; + +stop_read: + if (origin) + ldns_rdf_deep_free(origin); + if (prev_rr) + ldns_rdf_deep_free(prev_rr); + delegpt_free_mlc(dp); + fclose(f); + return 0; +} + +/** read root hints list */ +static int +read_root_hints_list(struct iter_hints* hints, struct config_file* cfg) +{ + struct config_strlist* p; + for(p = cfg->root_hints; p; p = p->next) { + log_assert(p->str); + if(p->str && p->str[0]) { + char* f = p->str; + if(cfg->chrootdir && cfg->chrootdir[0] && + strncmp(p->str, cfg->chrootdir, + strlen(cfg->chrootdir)) == 0) + f += strlen(cfg->chrootdir); + if(!read_root_hints(hints, f)) + return 0; + } + } + return 1; +} + +int +hints_apply_cfg(struct iter_hints* hints, struct config_file* cfg) +{ + hints_del_tree(hints); + name_tree_init(&hints->tree); + + /* read root hints */ + if(!read_root_hints_list(hints, cfg)) + return 0; + + /* read stub hints */ + if(!read_stubs(hints, cfg)) + return 0; + + /* use fallback compiletime root hints */ + if(!hints_lookup_root(hints, LDNS_RR_CLASS_IN)) { + struct delegpt* dp = compile_time_root_prime(cfg->do_ip4, + cfg->do_ip6); + verbose(VERB_ALGO, "no config, using builtin root hints."); + if(!dp) + return 0; + if(!hints_insert(hints, LDNS_RR_CLASS_IN, dp, 0)) + return 0; + } + + name_tree_init_parents(&hints->tree); + return 1; +} + +struct delegpt* +hints_lookup_root(struct iter_hints* hints, uint16_t qclass) +{ + uint8_t rootlab = 0; + struct iter_hints_stub *stub; + stub = (struct iter_hints_stub*)name_tree_find(&hints->tree, + &rootlab, 1, 1, qclass); + if(!stub) + return NULL; + return stub->dp; +} + +struct iter_hints_stub* +hints_lookup_stub(struct iter_hints* hints, uint8_t* qname, + uint16_t qclass, struct delegpt* cache_dp) +{ + size_t len; + int labs; + struct iter_hints_stub *r; + + /* first lookup the stub */ + labs = dname_count_size_labels(qname, &len); + r = (struct iter_hints_stub*)name_tree_lookup(&hints->tree, qname, + len, labs, qclass); + if(!r) return NULL; + + /* If there is no cache (root prime situation) */ + if(cache_dp == NULL) { + if(r->dp->namelabs != 1) + return r; /* no cache dp, use any non-root stub */ + return NULL; + } + + /* + * If the stub is same as the delegation we got + * And has noprime set, we need to 'prime' to use this stub instead. + */ + if(r->noprime && query_dname_compare(cache_dp->name, r->dp->name)==0) + return r; /* use this stub instead of cached dp */ + + /* + * If our cached delegation point is above the hint, we need to prime. + */ + if(dname_strict_subdomain(r->dp->name, r->dp->namelabs, + cache_dp->name, cache_dp->namelabs)) + return r; /* need to prime this stub */ + return NULL; +} + +int hints_next_root(struct iter_hints* hints, uint16_t* qclass) +{ + return name_tree_next_root(&hints->tree, qclass); +} + +size_t +hints_get_mem(struct iter_hints* hints) +{ + size_t s; + struct iter_hints_stub* p; + if(!hints) return 0; + s = sizeof(*hints); + RBTREE_FOR(p, struct iter_hints_stub*, &hints->tree) { + s += sizeof(*p) + delegpt_get_mem(p->dp); + } + return s; +} + +int +hints_add_stub(struct iter_hints* hints, uint16_t c, struct delegpt* dp, + int noprime) +{ + struct iter_hints_stub *z; + if((z=(struct iter_hints_stub*)name_tree_find(&hints->tree, + dp->name, dp->namelen, dp->namelabs, c)) != NULL) { + (void)rbtree_delete(&hints->tree, &z->node); + hints_stub_free(z); + } + if(!hints_insert(hints, c, dp, noprime)) + return 0; + name_tree_init_parents(&hints->tree); + return 1; +} + +void +hints_delete_stub(struct iter_hints* hints, uint16_t c, uint8_t* nm) +{ + struct iter_hints_stub *z; + size_t len; + int labs = dname_count_size_labels(nm, &len); + if(!(z=(struct iter_hints_stub*)name_tree_find(&hints->tree, + nm, len, labs, c))) + return; /* nothing to do */ + (void)rbtree_delete(&hints->tree, &z->node); + hints_stub_free(z); + name_tree_init_parents(&hints->tree); +} + |