2 * iterator/iter_fwd.c - iterative resolver module forward zones.
4 * Copyright (c) 2007, NLnet Labs. All rights reserved.
6 * This software is open source.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
12 * Redistributions of source code must retain the above copyright notice,
13 * this list of conditions and the following disclaimer.
15 * Redistributions in binary form must reproduce the above copyright notice,
16 * this list of conditions and the following disclaimer in the documentation
17 * and/or other materials provided with the distribution.
19 * Neither the name of the NLNET LABS nor the names of its contributors may
20 * be used to endorse or promote products derived from this software without
21 * specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
29 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
30 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 * This file contains functions to assist the iterator module.
40 * Keep track of forward zones and config settings.
43 #include "iterator/iter_fwd.h"
44 #include "iterator/iter_delegpt.h"
46 #include "util/config_file.h"
47 #include "util/net_help.h"
48 #include "util/data/dname.h"
49 #include "sldns/rrdef.h"
50 #include "sldns/str2wire.h"
53 fwd_cmp(const void* k1, const void* k2)
56 struct iter_forward_zone* n1 = (struct iter_forward_zone*)k1;
57 struct iter_forward_zone* n2 = (struct iter_forward_zone*)k2;
58 if(n1->dclass != n2->dclass) {
59 if(n1->dclass < n2->dclass)
63 return dname_lab_cmp(n1->name, n1->namelabs, n2->name, n2->namelabs,
70 struct iter_forwards* fwd = (struct iter_forwards*)calloc(1,
71 sizeof(struct iter_forwards));
77 static void fwd_zone_free(struct iter_forward_zone* n)
80 delegpt_free_mlc(n->dp);
85 static void delfwdnode(rbnode_type* n, void* ATTR_UNUSED(arg))
87 struct iter_forward_zone* node = (struct iter_forward_zone*)n;
91 static void fwd_del_tree(struct iter_forwards* fwd)
94 traverse_postorder(fwd->tree, &delfwdnode, NULL);
99 forwards_delete(struct iter_forwards* fwd)
107 /** insert info into forward structure */
109 forwards_insert_data(struct iter_forwards* fwd, uint16_t c, uint8_t* nm,
110 size_t nmlen, int nmlabs, struct delegpt* dp)
112 struct iter_forward_zone* node = (struct iter_forward_zone*)malloc(
113 sizeof(struct iter_forward_zone));
115 delegpt_free_mlc(dp);
118 node->node.key = node;
120 node->name = memdup(nm, nmlen);
122 delegpt_free_mlc(dp);
126 node->namelen = nmlen;
127 node->namelabs = nmlabs;
129 if(!rbtree_insert(fwd->tree, &node->node)) {
132 log_err("duplicate forward zone %s ignored.", buf);
133 delegpt_free_mlc(dp);
140 /** insert new info into forward structure given dp */
142 forwards_insert(struct iter_forwards* fwd, uint16_t c, struct delegpt* dp)
144 return forwards_insert_data(fwd, c, dp->name, dp->namelen,
148 /** initialise parent pointers in the tree */
150 fwd_init_parents(struct iter_forwards* fwd)
152 struct iter_forward_zone* node, *prev = NULL, *p;
154 RBTREE_FOR(node, struct iter_forward_zone*, fwd->tree) {
156 if(!prev || prev->dclass != node->dclass) {
160 (void)dname_lab_cmp(prev->name, prev->namelabs, node->name,
161 node->namelabs, &m); /* we know prev is smaller */
162 /* sort order like: . com. bla.com. zwb.com. net. */
163 /* find the previous, or parent-parent-parent */
164 for(p = prev; p; p = p->parent)
165 /* looking for name with few labels, a parent */
166 if(p->namelabs <= m) {
167 /* ==: since prev matched m, this is closest*/
168 /* <: prev matches more, but is not a parent,
169 * this one is a (grand)parent */
178 static struct delegpt*
179 read_fwds_name(struct config_stub* s)
185 log_err("forward zone without a name (use name \".\" to forward everything)");
188 dname = sldns_str2wire_dname(s->name, &dname_len);
190 log_err("cannot parse forward zone name %s", s->name);
193 if(!(dp=delegpt_create_mlc(dname))) {
195 log_err("out of memory");
202 /** set fwd host names */
204 read_fwds_host(struct config_stub* s, struct delegpt* dp)
206 struct config_strlist* p;
209 for(p = s->hosts; p; p = p->next) {
211 dname = sldns_str2wire_dname(p->str, &dname_len);
213 log_err("cannot parse forward %s server name: '%s'",
217 if(!delegpt_add_ns_mlc(dp, dname, 0)) {
219 log_err("out of memory");
227 /** set fwd server addresses */
229 read_fwds_addr(struct config_stub* s, struct delegpt* dp)
231 struct config_strlist* p;
232 struct sockaddr_storage addr;
235 for(p = s->addrs; p; p = p->next) {
237 if(!authextstrtoaddr(p->str, &addr, &addrlen, &tls_auth_name)) {
238 log_err("cannot parse forward %s ip address: '%s'",
242 #if ! defined(HAVE_SSL_SET1_HOST) && ! defined(HAVE_X509_VERIFY_PARAM_SET1_HOST)
244 log_err("no name verification functionality in "
245 "ssl library, ignored name for %s", p->str);
247 if(!delegpt_add_addr_mlc(dp, &addr, addrlen, 0, 0,
249 log_err("out of memory");
256 /** read forwards config */
258 read_forwards(struct iter_forwards* fwd, struct config_file* cfg)
260 struct config_stub* s;
261 for(s = cfg->forwards; s; s = s->next) {
263 if(!(dp=read_fwds_name(s)))
265 if(!read_fwds_host(s, dp) || !read_fwds_addr(s, dp)) {
266 delegpt_free_mlc(dp);
269 /* set flag that parent side NS information is included.
270 * Asking a (higher up) server on the internet is not useful */
271 /* the flag is turned off for 'forward-first' so that the
272 * last resort will ask for parent-side NS record and thus
273 * fallback to the internet name servers on a failure */
274 dp->has_parent_side_NS = (uint8_t)!s->isfirst;
275 /* Do not cache if set. */
276 dp->no_cache = s->no_cache;
277 /* use SSL for queries to this forwarder */
278 dp->ssl_upstream = (uint8_t)s->ssl_upstream;
279 verbose(VERB_QUERY, "Forward zone server list:");
280 delegpt_log(VERB_QUERY, dp);
281 if(!forwards_insert(fwd, LDNS_RR_CLASS_IN, dp))
287 /** insert a stub hole (if necessary) for stub name */
289 fwd_add_stub_hole(struct iter_forwards* fwd, uint16_t c, uint8_t* nm)
291 struct iter_forward_zone key;
295 key.namelabs = dname_count_size_labels(key.name, &key.namelen);
296 return forwards_insert_data(fwd, key.dclass, key.name,
297 key.namelen, key.namelabs, NULL);
300 /** make NULL entries for stubs */
302 make_stub_holes(struct iter_forwards* fwd, struct config_file* cfg)
304 struct config_stub* s;
307 for(s = cfg->stubs; s; s = s->next) {
308 if(!s->name) continue;
309 dname = sldns_str2wire_dname(s->name, &dname_len);
311 log_err("cannot parse stub name '%s'", s->name);
314 if(!fwd_add_stub_hole(fwd, LDNS_RR_CLASS_IN, dname)) {
316 log_err("out of memory");
325 forwards_apply_cfg(struct iter_forwards* fwd, struct config_file* cfg)
328 fwd->tree = rbtree_create(fwd_cmp);
332 /* read forward zones */
333 if(!read_forwards(fwd, cfg))
335 if(!make_stub_holes(fwd, cfg))
337 fwd_init_parents(fwd);
342 forwards_find(struct iter_forwards* fwd, uint8_t* qname, uint16_t qclass)
344 rbnode_type* res = NULL;
345 struct iter_forward_zone key;
349 key.namelabs = dname_count_size_labels(qname, &key.namelen);
350 res = rbtree_search(fwd->tree, &key);
351 if(res) return ((struct iter_forward_zone*)res)->dp;
356 forwards_lookup(struct iter_forwards* fwd, uint8_t* qname, uint16_t qclass)
358 /* lookup the forward zone in the tree */
359 rbnode_type* res = NULL;
360 struct iter_forward_zone *result;
361 struct iter_forward_zone key;
365 key.namelabs = dname_count_size_labels(qname, &key.namelen);
366 if(rbtree_find_less_equal(fwd->tree, &key, &res)) {
368 result = (struct iter_forward_zone*)res;
370 /* smaller element (or no element) */
372 result = (struct iter_forward_zone*)res;
373 if(!result || result->dclass != qclass)
375 /* count number of labels matched */
376 (void)dname_lab_cmp(result->name, result->namelabs, key.name,
378 while(result) { /* go up until qname is subdomain of stub */
379 if(result->namelabs <= m)
381 result = result->parent;
390 forwards_lookup_root(struct iter_forwards* fwd, uint16_t qclass)
393 return forwards_lookup(fwd, &root, qclass);
397 forwards_next_root(struct iter_forwards* fwd, uint16_t* dclass)
399 struct iter_forward_zone key;
401 struct iter_forward_zone* p;
403 /* first root item is first item in tree */
404 n = rbtree_first(fwd->tree);
407 p = (struct iter_forward_zone*)n;
408 if(dname_is_root(p->name)) {
412 /* root not first item? search for higher items */
413 *dclass = p->dclass + 1;
414 return forwards_next_root(fwd, dclass);
416 /* find class n in tree, we may get a direct hit, or if we don't
417 * this is the last item of the previous class so rbtree_next() takes
418 * us to the next root (if any) */
420 key.name = (uint8_t*)"\000";
423 key.dclass = *dclass;
425 if(rbtree_find_less_equal(fwd->tree, &key, &n)) {
429 /* smaller element */
430 if(!n || n == RBTREE_NULL)
431 return 0; /* nothing found */
434 return 0; /* no higher */
435 p = (struct iter_forward_zone*)n;
436 if(dname_is_root(p->name)) {
440 /* not a root node, return next higher item */
441 *dclass = p->dclass+1;
442 return forwards_next_root(fwd, dclass);
447 forwards_get_mem(struct iter_forwards* fwd)
449 struct iter_forward_zone* p;
453 s = sizeof(*fwd) + sizeof(*fwd->tree);
454 RBTREE_FOR(p, struct iter_forward_zone*, fwd->tree) {
455 s += sizeof(*p) + p->namelen + delegpt_get_mem(p->dp);
460 static struct iter_forward_zone*
461 fwd_zone_find(struct iter_forwards* fwd, uint16_t c, uint8_t* nm)
463 struct iter_forward_zone key;
467 key.namelabs = dname_count_size_labels(nm, &key.namelen);
468 return (struct iter_forward_zone*)rbtree_search(fwd->tree, &key);
472 forwards_add_zone(struct iter_forwards* fwd, uint16_t c, struct delegpt* dp)
474 struct iter_forward_zone *z;
475 if((z=fwd_zone_find(fwd, c, dp->name)) != NULL) {
476 (void)rbtree_delete(fwd->tree, &z->node);
479 if(!forwards_insert(fwd, c, dp))
481 fwd_init_parents(fwd);
486 forwards_delete_zone(struct iter_forwards* fwd, uint16_t c, uint8_t* nm)
488 struct iter_forward_zone *z;
489 if(!(z=fwd_zone_find(fwd, c, nm)))
490 return; /* nothing to do */
491 (void)rbtree_delete(fwd->tree, &z->node);
493 fwd_init_parents(fwd);
497 forwards_add_stub_hole(struct iter_forwards* fwd, uint16_t c, uint8_t* nm)
499 if(!fwd_add_stub_hole(fwd, c, nm)) {
502 fwd_init_parents(fwd);
507 forwards_delete_stub_hole(struct iter_forwards* fwd, uint16_t c, uint8_t* nm)
509 struct iter_forward_zone *z;
510 if(!(z=fwd_zone_find(fwd, c, nm)))
511 return; /* nothing to do */
513 return; /* not a stub hole */
514 (void)rbtree_delete(fwd->tree, &z->node);
516 fwd_init_parents(fwd);