2 * services/localzone.c - local zones authority service.
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 enable local zone authority service.
42 #include "services/localzone.h"
43 #include "sldns/str2wire.h"
44 #include "util/regional.h"
45 #include "util/config_file.h"
46 #include "util/data/dname.h"
47 #include "util/data/packed_rrset.h"
48 #include "util/data/msgencode.h"
49 #include "util/net_help.h"
50 #include "util/netevent.h"
51 #include "util/data/msgreply.h"
52 #include "util/data/msgparse.h"
53 #include "util/as112.h"
55 /* maximum RRs in an RRset, to cap possible 'endless' list RRs.
56 * with 16 bytes for an A record, a 64K packet has about 4000 max */
57 #define LOCALZONE_RRSET_COUNT_MAX 4096
60 local_zones_create(void)
62 struct local_zones* zones = (struct local_zones*)calloc(1,
66 rbtree_init(&zones->ztree, &local_zone_cmp);
67 lock_rw_init(&zones->lock);
68 lock_protect(&zones->lock, &zones->ztree, sizeof(zones->ztree));
69 /* also lock protects the rbnode's in struct local_zone */
73 /** helper traverse to delete zones */
75 lzdel(rbnode_type* n, void* ATTR_UNUSED(arg))
77 struct local_zone* z = (struct local_zone*)n->key;
82 local_zones_delete(struct local_zones* zones)
86 lock_rw_destroy(&zones->lock);
87 /* walk through zones and delete them all */
88 traverse_postorder(&zones->ztree, lzdel, NULL);
93 local_zone_delete(struct local_zone* z)
97 lock_rw_destroy(&z->lock);
98 regional_destroy(z->region);
105 local_zone_cmp(const void* z1, const void* z2)
107 /* first sort on class, so that hierarchy can be maintained within
109 struct local_zone* a = (struct local_zone*)z1;
110 struct local_zone* b = (struct local_zone*)z2;
112 if(a->dclass != b->dclass) {
113 if(a->dclass < b->dclass)
117 return dname_lab_cmp(a->name, a->namelabs, b->name, b->namelabs, &m);
121 local_data_cmp(const void* d1, const void* d2)
123 struct local_data* a = (struct local_data*)d1;
124 struct local_data* b = (struct local_data*)d2;
126 return dname_canon_lab_cmp(a->name, a->namelabs, b->name,
130 /* form wireformat from text format domain name */
132 parse_dname(const char* str, uint8_t** res, size_t* len, int* labs)
134 *res = sldns_str2wire_dname(str, len);
137 log_err("cannot parse name %s", str);
140 *labs = dname_count_size_labels(*res, len);
144 /** create a new localzone */
145 static struct local_zone*
146 local_zone_create(uint8_t* nm, size_t len, int labs,
147 enum localzone_type t, uint16_t dclass)
149 struct local_zone* z = (struct local_zone*)calloc(1, sizeof(*z));
159 lock_rw_init(&z->lock);
160 z->region = regional_create_nochunk(sizeof(struct regional));
165 rbtree_init(&z->data, &local_data_cmp);
166 lock_protect(&z->lock, &z->parent, sizeof(*z)-sizeof(rbnode_type));
167 /* also the zones->lock protects node, parent, name*, class */
171 /** enter a new zone with allocated dname returns with WRlock */
172 static struct local_zone*
173 lz_enter_zone_dname(struct local_zones* zones, uint8_t* nm, size_t len,
174 int labs, enum localzone_type t, uint16_t c)
176 struct local_zone* z = local_zone_create(nm, len, labs, t, c);
179 log_err("out of memory");
184 lock_rw_wrlock(&zones->lock);
185 lock_rw_wrlock(&z->lock);
186 if(!rbtree_insert(&zones->ztree, &z->node)) {
187 struct local_zone* oldz;
190 log_warn("duplicate local-zone %s", str);
191 lock_rw_unlock(&z->lock);
192 /* save zone name locally before deallocation,
193 * otherwise, nm is gone if we zone_delete now. */
195 /* find the correct zone, so not an error for duplicate */
196 z = local_zones_find(zones, nm, len, labs, c);
197 lock_rw_wrlock(&z->lock);
198 lock_rw_unlock(&zones->lock);
199 local_zone_delete(oldz);
202 lock_rw_unlock(&zones->lock);
206 /** enter a new zone */
207 static struct local_zone*
208 lz_enter_zone(struct local_zones* zones, const char* name, const char* type,
211 struct local_zone* z;
212 enum localzone_type t;
216 if(!parse_dname(name, &nm, &len, &labs)) {
217 log_err("bad zone name %s %s", name, type);
220 if(!local_zone_str2type(type, &t)) {
221 log_err("bad lz_enter_zone type %s %s", name, type);
225 if(!(z=lz_enter_zone_dname(zones, nm, len, labs, t, dclass))) {
226 log_err("could not enter zone %s %s", name, type);
233 rrstr_get_rr_content(const char* str, uint8_t** nm, uint16_t* type,
234 uint16_t* dclass, time_t* ttl, uint8_t* rr, size_t len,
235 uint8_t** rdata, size_t* rdata_len)
237 size_t dname_len = 0;
238 int e = sldns_str2wire_rr_buf(str, rr, &len, &dname_len, 3600,
241 log_err("error parsing local-data at %d: '%s': %s",
242 LDNS_WIREPARSE_OFFSET(e), str,
243 sldns_get_errorstr_parse(e));
246 *nm = memdup(rr, dname_len);
248 log_err("out of memory");
251 *dclass = sldns_wirerr_get_class(rr, len, dname_len);
252 *type = sldns_wirerr_get_type(rr, len, dname_len);
253 *ttl = (time_t)sldns_wirerr_get_ttl(rr, len, dname_len);
254 *rdata = sldns_wirerr_get_rdatawl(rr, len, dname_len);
255 *rdata_len = sldns_wirerr_get_rdatalen(rr, len, dname_len)+2;
259 /** return name and class of rr; parses string */
261 get_rr_nameclass(const char* str, uint8_t** nm, uint16_t* dclass,
264 uint8_t rr[LDNS_RR_BUF_SIZE];
265 size_t len = sizeof(rr), dname_len = 0;
266 int s = sldns_str2wire_rr_buf(str, rr, &len, &dname_len, 3600,
269 log_err("error parsing local-data at %d '%s': %s",
270 LDNS_WIREPARSE_OFFSET(s), str,
271 sldns_get_errorstr_parse(s));
274 *nm = memdup(rr, dname_len);
275 *dclass = sldns_wirerr_get_class(rr, len, dname_len);
276 *dtype = sldns_wirerr_get_type(rr, len, dname_len);
278 log_err("out of memory");
285 * Find an rrset in local data structure.
286 * @param data: local data domain name structure.
287 * @param type: type to look for (host order).
288 * @param alias_ok: 1 if matching a non-exact, alias type such as CNAME is
289 * allowed. otherwise 0.
290 * @return rrset pointer or NULL if not found.
292 static struct local_rrset*
293 local_data_find_type(struct local_data* data, uint16_t type, int alias_ok)
295 struct local_rrset* p;
297 for(p = data->rrsets; p; p = p->next) {
298 if(p->rrset->rk.type == type)
300 if(alias_ok && p->rrset->rk.type == htons(LDNS_RR_TYPE_CNAME))
306 /** check for RR duplicates */
308 rr_is_duplicate(struct packed_rrset_data* pd, uint8_t* rdata, size_t rdata_len)
311 for(i=0; i<pd->count; i++) {
312 if(pd->rr_len[i] == rdata_len &&
313 memcmp(pd->rr_data[i], rdata, rdata_len) == 0)
319 /** new local_rrset */
320 static struct local_rrset*
321 new_local_rrset(struct regional* region, struct local_data* node,
322 uint16_t rrtype, uint16_t rrclass)
324 struct packed_rrset_data* pd;
325 struct local_rrset* rrset = (struct local_rrset*)
326 regional_alloc_zero(region, sizeof(*rrset));
328 log_err("out of memory");
331 rrset->next = node->rrsets;
332 node->rrsets = rrset;
333 rrset->rrset = (struct ub_packed_rrset_key*)
334 regional_alloc_zero(region, sizeof(*rrset->rrset));
336 log_err("out of memory");
339 rrset->rrset->entry.key = rrset->rrset;
340 pd = (struct packed_rrset_data*)regional_alloc_zero(region,
343 log_err("out of memory");
346 pd->trust = rrset_trust_prim_noglue;
347 pd->security = sec_status_insecure;
348 rrset->rrset->entry.data = pd;
349 rrset->rrset->rk.dname = node->name;
350 rrset->rrset->rk.dname_len = node->namelen;
351 rrset->rrset->rk.type = htons(rrtype);
352 rrset->rrset->rk.rrset_class = htons(rrclass);
356 /** insert RR into RRset data structure; Wastes a couple of bytes */
358 rrset_insert_rr(struct regional* region, struct packed_rrset_data* pd,
359 uint8_t* rdata, size_t rdata_len, time_t ttl, const char* rrstr)
361 size_t* oldlen = pd->rr_len;
362 time_t* oldttl = pd->rr_ttl;
363 uint8_t** olddata = pd->rr_data;
365 /* add RR to rrset */
366 if(pd->count > LOCALZONE_RRSET_COUNT_MAX) {
367 log_warn("RRset '%s' has more than %d records, record ignored",
368 rrstr, LOCALZONE_RRSET_COUNT_MAX);
372 pd->rr_len = regional_alloc(region, sizeof(*pd->rr_len)*pd->count);
373 pd->rr_ttl = regional_alloc(region, sizeof(*pd->rr_ttl)*pd->count);
374 pd->rr_data = regional_alloc(region, sizeof(*pd->rr_data)*pd->count);
375 if(!pd->rr_len || !pd->rr_ttl || !pd->rr_data) {
376 log_err("out of memory");
380 memcpy(pd->rr_len+1, oldlen,
381 sizeof(*pd->rr_len)*(pd->count-1));
382 memcpy(pd->rr_ttl+1, oldttl,
383 sizeof(*pd->rr_ttl)*(pd->count-1));
384 memcpy(pd->rr_data+1, olddata,
385 sizeof(*pd->rr_data)*(pd->count-1));
387 pd->rr_len[0] = rdata_len;
389 pd->rr_data[0] = regional_alloc_init(region, rdata, rdata_len);
390 if(!pd->rr_data[0]) {
391 log_err("out of memory");
397 /** Delete RR from local-zone RRset, wastes memory as the deleted RRs cannot be
398 * free'd (regionally alloc'd) */
400 local_rrset_remove_rr(struct packed_rrset_data* pd, size_t index)
402 log_assert(pd->count > 0);
403 if(index >= pd->count) {
404 log_warn("Trying to remove RR with out of bound index");
407 if(index + 1 < pd->count) {
408 /* not removing last element */
409 size_t nexti = index + 1;
410 size_t num = pd->count - nexti;
411 memmove(pd->rr_len+index, pd->rr_len+nexti, sizeof(*pd->rr_len)*num);
412 memmove(pd->rr_ttl+index, pd->rr_ttl+nexti, sizeof(*pd->rr_ttl)*num);
413 memmove(pd->rr_data+index, pd->rr_data+nexti, sizeof(*pd->rr_data)*num);
420 local_zone_find_data(struct local_zone* z, uint8_t* nm, size_t nmlen, int nmlabs)
422 struct local_data key;
426 key.namelabs = nmlabs;
427 return (struct local_data*)rbtree_search(&z->data, &key.node);
430 /** find a node, create it if not and all its empty nonterminal parents */
432 lz_find_create_node(struct local_zone* z, uint8_t* nm, size_t nmlen,
433 int nmlabs, struct local_data** res)
435 struct local_data* ld = local_zone_find_data(z, nm, nmlen, nmlabs);
437 /* create a domain name to store rr. */
438 ld = (struct local_data*)regional_alloc_zero(z->region,
441 log_err("out of memory adding local data");
445 ld->name = regional_alloc_init(z->region, nm, nmlen);
447 log_err("out of memory");
451 ld->namelabs = nmlabs;
452 if(!rbtree_insert(&z->data, &ld->node)) {
453 log_assert(0); /* duplicate name */
455 /* see if empty nonterminals need to be created */
456 if(nmlabs > z->namelabs) {
457 dname_remove_label(&nm, &nmlen);
458 if(!lz_find_create_node(z, nm, nmlen, nmlabs-1, res))
467 local_zone_enter_rr(struct local_zone* z, uint8_t* nm, size_t nmlen,
468 int nmlabs, uint16_t rrtype, uint16_t rrclass, time_t ttl,
469 uint8_t* rdata, size_t rdata_len, const char* rrstr)
471 struct local_data* node;
472 struct local_rrset* rrset;
473 struct packed_rrset_data* pd;
475 if(!lz_find_create_node(z, nm, nmlen, nmlabs, &node)) {
480 /* Reject it if we would end up having CNAME and other data (including
481 * another CNAME) for a redirect zone. */
482 if((z->type == local_zone_redirect ||
483 z->type == local_zone_inform_redirect) && node->rrsets) {
484 const char* othertype = NULL;
485 if (rrtype == LDNS_RR_TYPE_CNAME)
487 else if (node->rrsets->rrset->rk.type ==
488 htons(LDNS_RR_TYPE_CNAME)) {
492 log_err("local-data '%s' in redirect zone must not "
493 "coexist with %s local-data", rrstr, othertype);
497 rrset = local_data_find_type(node, rrtype, 0);
499 rrset = new_local_rrset(z->region, node, rrtype, rrclass);
502 if(query_dname_compare(node->name, z->name) == 0) {
503 if(rrtype == LDNS_RR_TYPE_NSEC)
504 rrset->rrset->rk.flags = PACKED_RRSET_NSEC_AT_APEX;
505 if(rrtype == LDNS_RR_TYPE_SOA)
506 z->soa = rrset->rrset;
509 pd = (struct packed_rrset_data*)rrset->rrset->entry.data;
510 log_assert(rrset && pd);
512 /* check for duplicate RR */
513 if(rr_is_duplicate(pd, rdata, rdata_len)) {
514 verbose(VERB_ALGO, "ignoring duplicate RR: %s", rrstr);
517 return rrset_insert_rr(z->region, pd, rdata, rdata_len, ttl, rrstr);
520 /** enter data RR into auth zone */
522 lz_enter_rr_into_zone(struct local_zone* z, const char* rrstr)
527 uint16_t rrtype = 0, rrclass = 0;
529 uint8_t rr[LDNS_RR_BUF_SIZE];
532 if(!rrstr_get_rr_content(rrstr, &nm, &rrtype, &rrclass, &ttl, rr,
533 sizeof(rr), &rdata, &rdata_len)) {
534 log_err("bad local-data: %s", rrstr);
537 log_assert(z->dclass == rrclass);
538 if((z->type == local_zone_redirect ||
539 z->type == local_zone_inform_redirect) &&
540 query_dname_compare(z->name, nm) != 0) {
541 log_err("local-data in redirect zone must reside at top of zone"
542 ", not at %s", rrstr);
546 nmlabs = dname_count_size_labels(nm, &nmlen);
547 ret = local_zone_enter_rr(z, nm, nmlen, nmlabs, rrtype, rrclass, ttl,
548 rdata, rdata_len, rrstr);
553 /** enter a data RR into auth data; a zone for it must exist */
555 lz_enter_rr_str(struct local_zones* zones, const char* rr)
558 uint16_t rr_class, rr_type;
561 struct local_zone* z;
563 if(!get_rr_nameclass(rr, &rr_name, &rr_class, &rr_type)) {
564 log_err("bad rr %s", rr);
567 labs = dname_count_size_labels(rr_name, &len);
568 lock_rw_rdlock(&zones->lock);
569 z = local_zones_lookup(zones, rr_name, len, labs, rr_class, rr_type);
571 lock_rw_unlock(&zones->lock);
572 fatal_exit("internal error: no zone for rr %s", rr);
574 lock_rw_wrlock(&z->lock);
575 lock_rw_unlock(&zones->lock);
577 r = lz_enter_rr_into_zone(z, rr);
578 lock_rw_unlock(&z->lock);
582 /** enter tagstring into zone */
584 lz_enter_zone_tag(struct local_zones* zones, char* zname, uint8_t* list,
585 size_t len, uint16_t rr_class)
587 uint8_t dname[LDNS_MAX_DOMAINLEN+1];
588 size_t dname_len = sizeof(dname);
589 int dname_labs, r = 0;
590 struct local_zone* z;
592 if(sldns_str2wire_dname_buf(zname, dname, &dname_len) != 0) {
593 log_err("cannot parse zone name in local-zone-tag: %s", zname);
596 dname_labs = dname_count_labels(dname);
598 lock_rw_rdlock(&zones->lock);
599 z = local_zones_find(zones, dname, dname_len, dname_labs, rr_class);
601 lock_rw_unlock(&zones->lock);
602 log_err("no local-zone for tag %s", zname);
605 lock_rw_wrlock(&z->lock);
606 lock_rw_unlock(&zones->lock);
608 z->taglist = memdup(list, len);
612 lock_rw_unlock(&z->lock);
616 /** enter override into zone */
618 lz_enter_override(struct local_zones* zones, char* zname, char* netblock,
619 char* type, uint16_t rr_class)
621 uint8_t dname[LDNS_MAX_DOMAINLEN+1];
622 size_t dname_len = sizeof(dname);
624 struct sockaddr_storage addr;
627 struct local_zone* z;
628 enum localzone_type t;
630 /* parse zone name */
631 if(sldns_str2wire_dname_buf(zname, dname, &dname_len) != 0) {
632 log_err("cannot parse zone name in local-zone-override: %s %s",
636 dname_labs = dname_count_labels(dname);
639 if(!netblockstrtoaddr(netblock, UNBOUND_DNS_PORT, &addr, &addrlen,
641 log_err("cannot parse netblock in local-zone-override: %s %s",
646 /* parse zone type */
647 if(!local_zone_str2type(type, &t)) {
648 log_err("cannot parse type in local-zone-override: %s %s %s",
649 zname, netblock, type);
653 /* find localzone entry */
654 lock_rw_rdlock(&zones->lock);
655 z = local_zones_find(zones, dname, dname_len, dname_labs, rr_class);
657 lock_rw_unlock(&zones->lock);
658 log_err("no local-zone for local-zone-override %s", zname);
661 lock_rw_wrlock(&z->lock);
662 lock_rw_unlock(&zones->lock);
664 /* create netblock addr_tree if not present yet */
665 if(!z->override_tree) {
666 z->override_tree = (struct rbtree_type*)regional_alloc_zero(
667 z->region, sizeof(*z->override_tree));
668 if(!z->override_tree) {
669 lock_rw_unlock(&z->lock);
670 log_err("out of memory");
673 addr_tree_init(z->override_tree);
675 /* add new elem to tree */
676 if(z->override_tree) {
677 struct local_zone_override* n;
678 n = (struct local_zone_override*)regional_alloc_zero(
679 z->region, sizeof(*n));
681 lock_rw_unlock(&z->lock);
682 log_err("out of memory");
686 if(!addr_tree_insert(z->override_tree,
687 (struct addr_tree_node*)n, &addr, addrlen, net)) {
688 lock_rw_unlock(&z->lock);
689 log_err("duplicate local-zone-override %s %s",
695 lock_rw_unlock(&z->lock);
699 /** parse local-zone: statements */
701 lz_enter_zones(struct local_zones* zones, struct config_file* cfg)
703 struct config_str2list* p;
704 struct local_zone* z;
705 for(p = cfg->local_zones; p; p = p->next) {
706 if(!(z=lz_enter_zone(zones, p->str, p->str2,
709 lock_rw_unlock(&z->lock);
714 /** lookup a zone in rbtree; exact match only; SLOW due to parse */
716 lz_exists(struct local_zones* zones, const char* name)
720 z.dclass = LDNS_RR_CLASS_IN;
721 if(!parse_dname(name, &z.name, &z.namelen, &z.namelabs)) {
722 log_err("bad name %s", name);
725 lock_rw_rdlock(&zones->lock);
726 if(rbtree_search(&zones->ztree, &z.node)) {
727 lock_rw_unlock(&zones->lock);
731 lock_rw_unlock(&zones->lock);
736 /** lookup a zone in cfg->nodefault list */
738 lz_nodefault(struct config_file* cfg, const char* name)
740 struct config_strlist* p;
741 size_t len = strlen(name);
742 if(len == 0) return 0;
743 if(name[len-1] == '.') len--;
745 for(p = cfg->local_zones_nodefault; p; p = p->next) {
746 /* compare zone name, lowercase, compare without ending . */
747 if(strncasecmp(p->str, name, len) == 0 &&
748 (strlen(p->str) == len || (strlen(p->str)==len+1 &&
749 p->str[len] == '.')))
755 /** enter (AS112) empty default zone */
757 add_empty_default(struct local_zones* zones, struct config_file* cfg,
760 struct local_zone* z;
761 char str[1024]; /* known long enough */
762 if(lz_exists(zones, name) || lz_nodefault(cfg, name))
763 return 1; /* do not enter default content */
764 if(!(z=lz_enter_zone(zones, name, "static", LDNS_RR_CLASS_IN)))
766 snprintf(str, sizeof(str), "%s 10800 IN SOA localhost. "
767 "nobody.invalid. 1 3600 1200 604800 10800", name);
768 if(!lz_enter_rr_into_zone(z, str)) {
769 lock_rw_unlock(&z->lock);
772 snprintf(str, sizeof(str), "%s 10800 IN NS localhost. ", name);
773 if(!lz_enter_rr_into_zone(z, str)) {
774 lock_rw_unlock(&z->lock);
777 lock_rw_unlock(&z->lock);
781 /** enter default zones */
782 int local_zone_enter_defaults(struct local_zones* zones, struct config_file* cfg)
784 struct local_zone* z;
787 /* Do not add any default */
788 if(cfg->local_zones_disable_default)
791 /* this list of zones is from RFC 6303 and RFC 7686 */
793 /* block localhost level zones first, then onion and later the LAN zones */
795 /* localhost. zone */
796 if(!lz_exists(zones, "localhost.") &&
797 !lz_nodefault(cfg, "localhost.")) {
798 if(!(z=lz_enter_zone(zones, "localhost.", "redirect",
799 LDNS_RR_CLASS_IN)) ||
800 !lz_enter_rr_into_zone(z,
801 "localhost. 10800 IN NS localhost.") ||
802 !lz_enter_rr_into_zone(z,
803 "localhost. 10800 IN SOA localhost. nobody.invalid. "
804 "1 3600 1200 604800 10800") ||
805 !lz_enter_rr_into_zone(z,
806 "localhost. 10800 IN A 127.0.0.1") ||
807 !lz_enter_rr_into_zone(z,
808 "localhost. 10800 IN AAAA ::1")) {
809 log_err("out of memory adding default zone");
810 if(z) { lock_rw_unlock(&z->lock); }
813 lock_rw_unlock(&z->lock);
815 /* reverse ip4 zone */
816 if(!lz_exists(zones, "127.in-addr.arpa.") &&
817 !lz_nodefault(cfg, "127.in-addr.arpa.")) {
818 if(!(z=lz_enter_zone(zones, "127.in-addr.arpa.", "static",
819 LDNS_RR_CLASS_IN)) ||
820 !lz_enter_rr_into_zone(z,
821 "127.in-addr.arpa. 10800 IN NS localhost.") ||
822 !lz_enter_rr_into_zone(z,
823 "127.in-addr.arpa. 10800 IN SOA localhost. "
824 "nobody.invalid. 1 3600 1200 604800 10800") ||
825 !lz_enter_rr_into_zone(z,
826 "1.0.0.127.in-addr.arpa. 10800 IN PTR localhost.")) {
827 log_err("out of memory adding default zone");
828 if(z) { lock_rw_unlock(&z->lock); }
831 lock_rw_unlock(&z->lock);
833 /* reverse ip6 zone */
834 if(!lz_exists(zones, "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa.") &&
835 !lz_nodefault(cfg, "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa.")) {
836 if(!(z=lz_enter_zone(zones, "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa.", "static",
837 LDNS_RR_CLASS_IN)) ||
838 !lz_enter_rr_into_zone(z,
839 "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa. 10800 IN NS localhost.") ||
840 !lz_enter_rr_into_zone(z,
841 "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa. 10800 IN SOA localhost. "
842 "nobody.invalid. 1 3600 1200 604800 10800") ||
843 !lz_enter_rr_into_zone(z,
844 "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa. 10800 IN PTR localhost.")) {
845 log_err("out of memory adding default zone");
846 if(z) { lock_rw_unlock(&z->lock); }
849 lock_rw_unlock(&z->lock);
851 /* onion. zone (RFC 7686) */
852 if(!add_empty_default(zones, cfg, "onion.")) {
853 log_err("out of memory adding default zone");
856 /* test. zone (RFC 6761) */
857 if(!add_empty_default(zones, cfg, "test.")) {
858 log_err("out of memory adding default zone");
861 /* invalid. zone (RFC 6761) */
862 if(!add_empty_default(zones, cfg, "invalid.")) {
863 log_err("out of memory adding default zone");
866 /* block AS112 zones, unless asked not to */
867 if(!cfg->unblock_lan_zones) {
868 for(zstr = as112_zones; *zstr; zstr++) {
869 if(!add_empty_default(zones, cfg, *zstr)) {
870 log_err("out of memory adding default zone");
878 /** parse local-zone-override: statements */
880 lz_enter_overrides(struct local_zones* zones, struct config_file* cfg)
882 struct config_str3list* p;
883 for(p = cfg->local_zone_overrides; p; p = p->next) {
884 if(!lz_enter_override(zones, p->str, p->str2, p->str3,
891 /** setup parent pointers, so that a lookup can be done for closest match */
893 init_parents(struct local_zones* zones)
895 struct local_zone* node, *prev = NULL, *p;
897 lock_rw_wrlock(&zones->lock);
898 RBTREE_FOR(node, struct local_zone*, &zones->ztree) {
899 lock_rw_wrlock(&node->lock);
901 if(!prev || prev->dclass != node->dclass) {
903 lock_rw_unlock(&node->lock);
906 (void)dname_lab_cmp(prev->name, prev->namelabs, node->name,
907 node->namelabs, &m); /* we know prev is smaller */
908 /* sort order like: . com. bla.com. zwb.com. net. */
909 /* find the previous, or parent-parent-parent */
910 for(p = prev; p; p = p->parent)
911 /* looking for name with few labels, a parent */
912 if(p->namelabs <= m) {
913 /* ==: since prev matched m, this is closest*/
914 /* <: prev matches more, but is not a parent,
915 * this one is a (grand)parent */
921 if(node->override_tree)
922 addr_tree_init_parents(node->override_tree);
923 lock_rw_unlock(&node->lock);
925 lock_rw_unlock(&zones->lock);
928 /** enter implicit transparent zone for local-data: without local-zone: */
930 lz_setup_implicit(struct local_zones* zones, struct config_file* cfg)
932 /* walk over all items that have no parent zone and find
933 * the name that covers them all (could be the root) and
934 * add that as a transparent zone */
935 struct config_strlist* p;
937 int have_other_classes = 0;
942 int match = 0; /* number of labels match count */
944 init_parents(zones); /* to enable local_zones_lookup() */
945 for(p = cfg->local_data; p; p = p->next) {
947 uint16_t rr_class, rr_type;
950 if(!get_rr_nameclass(p->str, &rr_name, &rr_class, &rr_type)) {
951 log_err("Bad local-data RR %s", p->str);
954 labs = dname_count_size_labels(rr_name, &len);
955 lock_rw_rdlock(&zones->lock);
956 if(!local_zones_lookup(zones, rr_name, len, labs, rr_class,
967 if(rr_class != dclass) {
968 /* process other classes later */
970 have_other_classes = 1;
971 lock_rw_unlock(&zones->lock);
974 /* find smallest shared topdomain */
975 (void)dname_lab_cmp(nm, nmlabs,
981 } else free(rr_name);
982 lock_rw_unlock(&zones->lock);
986 struct local_zone* z;
987 /* allocate zone of smallest shared topdomain to contain em */
989 dname_remove_labels(&n2, &nmlen, nmlabs - match);
990 n2 = memdup(n2, nmlen);
993 log_err("out of memory");
996 log_nametypeclass(VERB_ALGO, "implicit transparent local-zone",
998 if(!(z=lz_enter_zone_dname(zones, n2, nmlen, match,
999 local_zone_transparent, dclass))) {
1002 lock_rw_unlock(&z->lock);
1004 if(have_other_classes) {
1005 /* restart to setup other class */
1006 return lz_setup_implicit(zones, cfg);
1011 /** enter local-zone-tag info */
1013 lz_enter_zone_tags(struct local_zones* zones, struct config_file* cfg)
1015 struct config_strbytelist* p;
1017 for(p = cfg->local_zone_tags; p; p = p->next) {
1018 if(!lz_enter_zone_tag(zones, p->str, p->str2, p->str2len,
1023 if(c) verbose(VERB_ALGO, "applied tags to %d local zones", c);
1027 /** enter auth data */
1029 lz_enter_data(struct local_zones* zones, struct config_file* cfg)
1031 struct config_strlist* p;
1032 for(p = cfg->local_data; p; p = p->next) {
1033 if(!lz_enter_rr_str(zones, p->str))
1039 /** free memory from config */
1041 lz_freeup_cfg(struct config_file* cfg)
1043 config_deldblstrlist(cfg->local_zones);
1044 cfg->local_zones = NULL;
1045 config_delstrlist(cfg->local_zones_nodefault);
1046 cfg->local_zones_nodefault = NULL;
1047 config_delstrlist(cfg->local_data);
1048 cfg->local_data = NULL;
1052 local_zones_apply_cfg(struct local_zones* zones, struct config_file* cfg)
1054 /* create zones from zone statements. */
1055 if(!lz_enter_zones(zones, cfg)) {
1058 /* apply default zones+content (unless disabled, or overridden) */
1059 if(!local_zone_enter_defaults(zones, cfg)) {
1062 /* enter local zone overrides */
1063 if(!lz_enter_overrides(zones, cfg)) {
1066 /* create implicit transparent zone from data. */
1067 if(!lz_setup_implicit(zones, cfg)) {
1071 /* setup parent ptrs for lookup during data entry */
1072 init_parents(zones);
1073 /* insert local zone tags */
1074 if(!lz_enter_zone_tags(zones, cfg)) {
1077 /* insert local data */
1078 if(!lz_enter_data(zones, cfg)) {
1081 /* freeup memory from cfg struct. */
1087 local_zones_lookup(struct local_zones* zones,
1088 uint8_t* name, size_t len, int labs, uint16_t dclass, uint16_t dtype)
1090 return local_zones_tags_lookup(zones, name, len, labs,
1091 dclass, dtype, NULL, 0, 1);
1095 local_zones_tags_lookup(struct local_zones* zones,
1096 uint8_t* name, size_t len, int labs, uint16_t dclass, uint16_t dtype,
1097 uint8_t* taglist, size_t taglen, int ignoretags)
1099 rbnode_type* res = NULL;
1100 struct local_zone *result;
1101 struct local_zone key;
1103 /* for type DS use a zone higher when on a zonecut */
1104 if(dtype == LDNS_RR_TYPE_DS && !dname_is_root(name)) {
1105 dname_remove_label(&name, &len);
1108 key.node.key = &key;
1109 key.dclass = dclass;
1112 key.namelabs = labs;
1113 rbtree_find_less_equal(&zones->ztree, &key, &res);
1114 result = (struct local_zone*)res;
1115 /* exact or smaller element (or no element) */
1116 if(!result || result->dclass != dclass)
1118 /* count number of labels matched */
1119 (void)dname_lab_cmp(result->name, result->namelabs, key.name,
1121 while(result) { /* go up until qname is zone or subdomain of zone */
1122 if(result->namelabs <= m)
1123 if(ignoretags || !result->taglist ||
1124 taglist_intersect(result->taglist,
1125 result->taglen, taglist, taglen))
1127 result = result->parent;
1133 local_zones_find(struct local_zones* zones,
1134 uint8_t* name, size_t len, int labs, uint16_t dclass)
1136 struct local_zone key;
1137 key.node.key = &key;
1138 key.dclass = dclass;
1141 key.namelabs = labs;
1143 return (struct local_zone*)rbtree_search(&zones->ztree, &key);
1147 local_zones_find_le(struct local_zones* zones,
1148 uint8_t* name, size_t len, int labs, uint16_t dclass,
1151 struct local_zone key;
1153 key.node.key = &key;
1154 key.dclass = dclass;
1157 key.namelabs = labs;
1158 *exact = rbtree_find_less_equal(&zones->ztree, &key, &node);
1159 return (struct local_zone*)node;
1162 /** print all RRsets in local zone */
1164 local_zone_out(struct local_zone* z)
1166 struct local_data* d;
1167 struct local_rrset* p;
1168 RBTREE_FOR(d, struct local_data*, &z->data) {
1169 for(p = d->rrsets; p; p = p->next) {
1170 log_nametypeclass(NO_VERBOSE, "rrset", d->name,
1171 ntohs(p->rrset->rk.type),
1172 ntohs(p->rrset->rk.rrset_class));
1177 void local_zones_print(struct local_zones* zones)
1179 struct local_zone* z;
1180 lock_rw_rdlock(&zones->lock);
1181 log_info("number of auth zones %u", (unsigned)zones->ztree.count);
1182 RBTREE_FOR(z, struct local_zone*, &zones->ztree) {
1184 lock_rw_rdlock(&z->lock);
1185 snprintf(buf, sizeof(buf), "%s zone",
1186 local_zone_type2str(z->type));
1187 log_nametypeclass(NO_VERBOSE, buf, z->name, 0, z->dclass);
1189 lock_rw_unlock(&z->lock);
1191 lock_rw_unlock(&zones->lock);
1194 /** encode answer consisting of 1 rrset */
1196 local_encode(struct query_info* qinfo, struct module_env* env,
1197 struct edns_data* edns, struct comm_reply* repinfo, sldns_buffer* buf,
1198 struct regional* temp, struct ub_packed_rrset_key* rrset, int ansec,
1201 struct reply_info rep;
1203 /* make answer with time=0 for fixed TTL values */
1204 memset(&rep, 0, sizeof(rep));
1205 rep.flags = (uint16_t)((BIT_QR | BIT_AA | BIT_RA) | rcode);
1208 rep.an_numrrsets = 1;
1209 else rep.ns_numrrsets = 1;
1210 rep.rrset_count = 1;
1211 rep.rrsets = &rrset;
1212 udpsize = edns->udp_size;
1213 edns->edns_version = EDNS_ADVERTISED_VERSION;
1214 edns->udp_size = EDNS_ADVERTISED_SIZE;
1215 edns->ext_rcode = 0;
1216 edns->bits &= EDNS_DO;
1217 if(!inplace_cb_reply_local_call(env, qinfo, NULL, &rep, rcode, edns,
1218 repinfo, temp) || !reply_info_answer_encode(qinfo, &rep,
1219 *(uint16_t*)sldns_buffer_begin(buf), sldns_buffer_read_u16_at(buf, 2),
1220 buf, 0, 0, temp, udpsize, edns, (int)(edns->bits&EDNS_DO), 0)) {
1221 error_encode(buf, (LDNS_RCODE_SERVFAIL|BIT_AA), qinfo,
1222 *(uint16_t*)sldns_buffer_begin(buf),
1223 sldns_buffer_read_u16_at(buf, 2), edns);
1228 /** encode local error answer */
1230 local_error_encode(struct query_info* qinfo, struct module_env* env,
1231 struct edns_data* edns, struct comm_reply* repinfo, sldns_buffer* buf,
1232 struct regional* temp, int rcode, int r)
1234 edns->edns_version = EDNS_ADVERTISED_VERSION;
1235 edns->udp_size = EDNS_ADVERTISED_SIZE;
1236 edns->ext_rcode = 0;
1237 edns->bits &= EDNS_DO;
1239 if(!inplace_cb_reply_local_call(env, qinfo, NULL, NULL,
1240 rcode, edns, repinfo, temp))
1241 edns->opt_list = NULL;
1242 error_encode(buf, r, qinfo, *(uint16_t*)sldns_buffer_begin(buf),
1243 sldns_buffer_read_u16_at(buf, 2), edns);
1246 /** find local data tag string match for the given type in the list */
1248 local_data_find_tag_datas(const struct query_info* qinfo,
1249 struct config_strlist* list, struct ub_packed_rrset_key* r,
1250 struct regional* temp)
1252 struct config_strlist* p;
1254 uint8_t rr[LDNS_RR_BUF_SIZE];
1257 struct packed_rrset_data* d;
1258 for(p=list; p; p=p->next) {
1262 /* does this element match the type? */
1263 snprintf(buf, sizeof(buf), ". %s", p->str);
1264 res = sldns_str2wire_rr_buf(buf, rr, &len, NULL, 3600,
1267 /* parse errors are already checked before, in
1268 * acllist check_data, skip this for robustness */
1270 if(len < 1 /* . */ + 8 /* typeclassttl*/ + 2 /*rdatalen*/)
1272 rdr_type = sldns_wirerr_get_type(rr, len, 1);
1273 if(rdr_type != qinfo->qtype && rdr_type != LDNS_RR_TYPE_CNAME)
1276 /* do we have entries already? if not setup key */
1277 if(r->rk.dname == NULL) {
1279 r->rk.dname = qinfo->qname;
1280 r->rk.dname_len = qinfo->qname_len;
1281 r->rk.type = htons(rdr_type);
1282 r->rk.rrset_class = htons(qinfo->qclass);
1284 d = (struct packed_rrset_data*)regional_alloc_zero(
1285 temp, sizeof(struct packed_rrset_data)
1286 + sizeof(size_t) + sizeof(uint8_t*) +
1288 if(!d) return 0; /* out of memory */
1290 d->ttl = sldns_wirerr_get_ttl(rr, len, 1);
1291 d->rr_len = (size_t*)((uint8_t*)d +
1292 sizeof(struct packed_rrset_data));
1293 d->rr_data = (uint8_t**)&(d->rr_len[1]);
1294 d->rr_ttl = (time_t*)&(d->rr_data[1]);
1296 d = (struct packed_rrset_data*)r->entry.data;
1297 /* add entry to the data */
1299 size_t* oldlen = d->rr_len;
1300 uint8_t** olddata = d->rr_data;
1301 time_t* oldttl = d->rr_ttl;
1302 /* increase arrays for lookup */
1303 /* this is of course slow for very many records,
1304 * but most redirects are expected with few records */
1305 d->rr_len = (size_t*)regional_alloc_zero(temp,
1306 (d->count+1)*sizeof(size_t));
1307 d->rr_data = (uint8_t**)regional_alloc_zero(temp,
1308 (d->count+1)*sizeof(uint8_t*));
1309 d->rr_ttl = (time_t*)regional_alloc_zero(temp,
1310 (d->count+1)*sizeof(time_t));
1311 if(!d->rr_len || !d->rr_data || !d->rr_ttl)
1312 return 0; /* out of memory */
1313 /* first one was allocated after struct d, but new
1314 * ones get their own array increment alloc, so
1315 * copy old content */
1316 memmove(d->rr_len, oldlen, d->count*sizeof(size_t));
1317 memmove(d->rr_data, olddata, d->count*sizeof(uint8_t*));
1318 memmove(d->rr_ttl, oldttl, d->count*sizeof(time_t));
1321 d->rr_len[d->count] = sldns_wirerr_get_rdatalen(rr, len, 1)+2;
1322 d->rr_ttl[d->count] = sldns_wirerr_get_ttl(rr, len, 1);
1323 d->rr_data[d->count] = regional_alloc_init(temp,
1324 sldns_wirerr_get_rdatawl(rr, len, 1),
1325 d->rr_len[d->count]);
1326 if(!d->rr_data[d->count])
1327 return 0; /* out of memory */
1336 find_tag_datas(struct query_info* qinfo, struct config_strlist* list,
1337 struct ub_packed_rrset_key* r, struct regional* temp)
1339 int result = local_data_find_tag_datas(qinfo, list, r, temp);
1341 /* If we've found a non-exact alias type of local data, make a shallow
1342 * copy of the RRset and remember it in qinfo to complete the alias
1344 if(result && qinfo->qtype != LDNS_RR_TYPE_CNAME &&
1345 r->rk.type == htons(LDNS_RR_TYPE_CNAME)) {
1346 qinfo->local_alias =
1347 regional_alloc_zero(temp, sizeof(struct local_rrset));
1348 if(!qinfo->local_alias)
1349 return 0; /* out of memory */
1350 qinfo->local_alias->rrset =
1351 regional_alloc_init(temp, r, sizeof(*r));
1352 if(!qinfo->local_alias->rrset)
1353 return 0; /* out of memory */
1359 local_data_answer(struct local_zone* z, struct module_env* env,
1360 struct query_info* qinfo, struct edns_data* edns,
1361 struct comm_reply* repinfo, sldns_buffer* buf,
1362 struct regional* temp, int labs, struct local_data** ldp,
1363 enum localzone_type lz_type, int tag, struct config_strlist** tag_datas,
1364 size_t tag_datas_size, char** tagname, int num_tags)
1366 struct local_data key;
1367 struct local_data* ld;
1368 struct local_rrset* lr;
1369 key.node.key = &key;
1370 key.name = qinfo->qname;
1371 key.namelen = qinfo->qname_len;
1372 key.namelabs = labs;
1373 if(lz_type == local_zone_redirect ||
1374 lz_type == local_zone_inform_redirect) {
1376 key.namelen = z->namelen;
1377 key.namelabs = z->namelabs;
1378 if(tag != -1 && (size_t)tag<tag_datas_size && tag_datas[tag]) {
1379 struct ub_packed_rrset_key r;
1380 memset(&r, 0, sizeof(r));
1381 if(find_tag_datas(qinfo, tag_datas[tag], &r, temp)) {
1382 verbose(VERB_ALGO, "redirect with tag data [%d] %s",
1383 tag, (tag<num_tags?tagname[tag]:"null"));
1385 /* If we found a matching alias, we should
1386 * use it as part of the answer, but we can't
1387 * encode it until we complete the alias
1389 if(qinfo->local_alias)
1391 return local_encode(qinfo, env, edns, repinfo, buf, temp,
1392 &r, 1, LDNS_RCODE_NOERROR);
1396 ld = (struct local_data*)rbtree_search(&z->data, &key.node);
1401 lr = local_data_find_type(ld, qinfo->qtype, 1);
1405 /* Special case for alias matching. See local_data_answer(). */
1406 if((lz_type == local_zone_redirect ||
1407 lz_type == local_zone_inform_redirect) &&
1408 qinfo->qtype != LDNS_RR_TYPE_CNAME &&
1409 lr->rrset->rk.type == htons(LDNS_RR_TYPE_CNAME)) {
1411 size_t ctargetlen = 0;
1413 qinfo->local_alias =
1414 regional_alloc_zero(temp, sizeof(struct local_rrset));
1415 if(!qinfo->local_alias)
1416 return 0; /* out of memory */
1417 qinfo->local_alias->rrset = regional_alloc_init(
1418 temp, lr->rrset, sizeof(*lr->rrset));
1419 if(!qinfo->local_alias->rrset)
1420 return 0; /* out of memory */
1421 qinfo->local_alias->rrset->rk.dname = qinfo->qname;
1422 qinfo->local_alias->rrset->rk.dname_len = qinfo->qname_len;
1423 get_cname_target(lr->rrset, &ctarget, &ctargetlen);
1425 return 0; /* invalid cname */
1426 if(dname_is_wild(ctarget)) {
1427 /* synthesize cname target */
1428 struct packed_rrset_data* d;
1429 /* -3 for wildcard label and root label from qname */
1430 size_t newtargetlen = qinfo->qname_len + ctargetlen - 3;
1432 log_assert(ctargetlen >= 3);
1433 log_assert(qinfo->qname_len >= 1);
1435 if(newtargetlen > LDNS_MAX_DOMAINLEN) {
1436 qinfo->local_alias = NULL;
1437 local_error_encode(qinfo, env, edns, repinfo,
1438 buf, temp, LDNS_RCODE_YXDOMAIN,
1439 (LDNS_RCODE_YXDOMAIN|BIT_AA));
1442 memset(&qinfo->local_alias->rrset->entry, 0,
1443 sizeof(qinfo->local_alias->rrset->entry));
1444 qinfo->local_alias->rrset->entry.key =
1445 qinfo->local_alias->rrset;
1446 qinfo->local_alias->rrset->entry.hash =
1447 rrset_key_hash(&qinfo->local_alias->rrset->rk);
1448 d = (struct packed_rrset_data*)regional_alloc_zero(temp,
1449 sizeof(struct packed_rrset_data) + sizeof(size_t) +
1450 sizeof(uint8_t*) + sizeof(time_t) + sizeof(uint16_t)
1453 return 0; /* out of memory */
1454 qinfo->local_alias->rrset->entry.data = d;
1455 d->ttl = 0; /* 0 for synthesized CNAME TTL */
1458 d->trust = rrset_trust_ans_noAA;
1459 d->rr_len = (size_t*)((uint8_t*)d +
1460 sizeof(struct packed_rrset_data));
1461 d->rr_len[0] = newtargetlen + sizeof(uint16_t);
1462 packed_rrset_ptr_fixup(d);
1463 d->rr_ttl[0] = d->ttl;
1464 sldns_write_uint16(d->rr_data[0], newtargetlen);
1466 memmove(d->rr_data[0] + sizeof(uint16_t), qinfo->qname,
1467 qinfo->qname_len - 1);
1468 /* write cname target wilcard wildcard label */
1469 memmove(d->rr_data[0] + sizeof(uint16_t) +
1470 qinfo->qname_len - 1, ctarget + 2,
1475 if(lz_type == local_zone_redirect ||
1476 lz_type == local_zone_inform_redirect) {
1477 /* convert rrset name to query name; like a wildcard */
1478 struct ub_packed_rrset_key r = *lr->rrset;
1479 r.rk.dname = qinfo->qname;
1480 r.rk.dname_len = qinfo->qname_len;
1481 return local_encode(qinfo, env, edns, repinfo, buf, temp, &r, 1,
1482 LDNS_RCODE_NOERROR);
1484 return local_encode(qinfo, env, edns, repinfo, buf, temp, lr->rrset, 1,
1485 LDNS_RCODE_NOERROR);
1489 * See if the local zone does not cover the name, eg. the name is not
1490 * in the zone and the zone is transparent */
1492 local_zone_does_not_cover(struct local_zone* z, struct query_info* qinfo,
1495 struct local_data key;
1496 struct local_data* ld = NULL;
1497 struct local_rrset* lr = NULL;
1498 if(z->type == local_zone_always_transparent)
1500 if(z->type != local_zone_transparent
1501 && z->type != local_zone_typetransparent
1502 && z->type != local_zone_inform)
1504 key.node.key = &key;
1505 key.name = qinfo->qname;
1506 key.namelen = qinfo->qname_len;
1507 key.namelabs = labs;
1508 ld = (struct local_data*)rbtree_search(&z->data, &key.node);
1509 if(z->type == local_zone_transparent || z->type == local_zone_inform)
1510 return (ld == NULL);
1512 lr = local_data_find_type(ld, qinfo->qtype, 1);
1513 /* local_zone_typetransparent */
1514 return (lr == NULL);
1518 local_zones_zone_answer(struct local_zone* z, struct module_env* env,
1519 struct query_info* qinfo, struct edns_data* edns,
1520 struct comm_reply* repinfo, sldns_buffer* buf, struct regional* temp,
1521 struct local_data* ld, enum localzone_type lz_type)
1523 if(lz_type == local_zone_deny ||
1524 lz_type == local_zone_always_deny ||
1525 lz_type == local_zone_inform_deny) {
1526 /** no reply at all, signal caller by clearing buffer. */
1527 sldns_buffer_clear(buf);
1528 sldns_buffer_flip(buf);
1530 } else if(lz_type == local_zone_refuse
1531 || lz_type == local_zone_always_refuse) {
1532 local_error_encode(qinfo, env, edns, repinfo, buf, temp,
1533 LDNS_RCODE_REFUSED, (LDNS_RCODE_REFUSED|BIT_AA));
1535 } else if(lz_type == local_zone_static ||
1536 lz_type == local_zone_redirect ||
1537 lz_type == local_zone_inform_redirect ||
1538 lz_type == local_zone_always_nxdomain ||
1539 lz_type == local_zone_always_nodata) {
1540 /* for static, reply nodata or nxdomain
1541 * for redirect, reply nodata */
1542 /* no additional section processing,
1543 * cname, dname or wildcard processing,
1544 * or using closest match for NSEC.
1545 * or using closest match for returning delegation downwards
1547 int rcode = (ld || lz_type == local_zone_redirect ||
1548 lz_type == local_zone_inform_redirect ||
1549 lz_type == local_zone_always_nodata)?
1550 LDNS_RCODE_NOERROR:LDNS_RCODE_NXDOMAIN;
1552 return local_encode(qinfo, env, edns, repinfo, buf, temp,
1554 local_error_encode(qinfo, env, edns, repinfo, buf, temp, rcode,
1557 } else if(lz_type == local_zone_typetransparent
1558 || lz_type == local_zone_always_transparent) {
1559 /* no NODATA or NXDOMAINS for this zone type */
1562 /* else lz_type == local_zone_transparent */
1564 /* if the zone is transparent and the name exists, but the type
1565 * does not, then we should make this noerror/nodata */
1566 if(ld && ld->rrsets) {
1567 int rcode = LDNS_RCODE_NOERROR;
1569 return local_encode(qinfo, env, edns, repinfo, buf, temp,
1571 local_error_encode(qinfo, env, edns, repinfo, buf, temp, rcode,
1576 /* stop here, and resolve further on */
1580 /** print log information for an inform zone query */
1582 lz_inform_print(struct local_zone* z, struct query_info* qinfo,
1583 struct comm_reply* repinfo)
1585 char ip[128], txt[512];
1586 char zname[LDNS_MAX_DOMAINLEN+1];
1587 uint16_t port = ntohs(((struct sockaddr_in*)&repinfo->addr)->sin_port);
1588 dname_str(z->name, zname);
1589 addr_to_str(&repinfo->addr, repinfo->addrlen, ip, sizeof(ip));
1590 snprintf(txt, sizeof(txt), "%s %s %s@%u", zname, local_zone_type2str(z->type), ip,
1592 log_nametypeclass(NO_VERBOSE, txt, qinfo->qname, qinfo->qtype, qinfo->qclass);
1595 static enum localzone_type
1596 lz_type(uint8_t *taglist, size_t taglen, uint8_t *taglist2, size_t taglen2,
1597 uint8_t *tagactions, size_t tagactionssize, enum localzone_type lzt,
1598 struct comm_reply* repinfo, struct rbtree_type* override_tree,
1599 int* tag, char** tagname, int num_tags)
1601 struct local_zone_override* lzo;
1602 if(repinfo && override_tree) {
1603 lzo = (struct local_zone_override*)addr_tree_lookup(
1604 override_tree, &repinfo->addr, repinfo->addrlen);
1605 if(lzo && lzo->type) {
1606 verbose(VERB_ALGO, "local zone override to type %s",
1607 local_zone_type2str(lzo->type));
1611 if(!taglist || !taglist2)
1613 return local_data_find_tag_action(taglist, taglen, taglist2, taglen2,
1614 tagactions, tagactionssize, lzt, tag, tagname, num_tags);
1618 local_data_find_tag_action(const uint8_t* taglist, size_t taglen,
1619 const uint8_t* taglist2, size_t taglen2, const uint8_t* tagactions,
1620 size_t tagactionssize, enum localzone_type lzt, int* tag,
1621 char* const* tagname, int num_tags)
1626 for(i=0; i<taglen && i<taglen2; i++) {
1627 tagmatch = (taglist[i] & taglist2[i]);
1628 for(j=0; j<8 && tagmatch>0; j++) {
1629 if((tagmatch & 0x1)) {
1630 *tag = (int)(i*8+j);
1631 verbose(VERB_ALGO, "matched tag [%d] %s",
1632 *tag, (*tag<num_tags?tagname[*tag]:"null"));
1633 /* does this tag have a tag action? */
1634 if(i*8+j < tagactionssize && tagactions
1635 && tagactions[i*8+j] != 0) {
1636 verbose(VERB_ALGO, "tag action [%d] %s to type %s",
1637 *tag, (*tag<num_tags?tagname[*tag]:"null"),
1638 local_zone_type2str(
1639 (enum localzone_type)
1640 tagactions[i*8+j]));
1641 return (enum localzone_type)tagactions[i*8+j];
1652 local_zones_answer(struct local_zones* zones, struct module_env* env,
1653 struct query_info* qinfo, struct edns_data* edns, sldns_buffer* buf,
1654 struct regional* temp, struct comm_reply* repinfo, uint8_t* taglist,
1655 size_t taglen, uint8_t* tagactions, size_t tagactionssize,
1656 struct config_strlist** tag_datas, size_t tag_datas_size,
1657 char** tagname, int num_tags, struct view* view)
1659 /* see if query is covered by a zone,
1660 * if so: - try to match (exact) local data
1661 * - look at zone type for negative response. */
1662 int labs = dname_count_labels(qinfo->qname);
1663 struct local_data* ld = NULL;
1664 struct local_zone* z = NULL;
1665 enum localzone_type lzt = local_zone_transparent;
1669 lock_rw_rdlock(&view->lock);
1670 if(view->local_zones &&
1671 (z = local_zones_lookup(view->local_zones,
1672 qinfo->qname, qinfo->qname_len, labs,
1673 qinfo->qclass, qinfo->qtype))) {
1674 lock_rw_rdlock(&z->lock);
1677 if(lzt == local_zone_noview) {
1678 lock_rw_unlock(&z->lock);
1681 if(z && (lzt == local_zone_transparent ||
1682 lzt == local_zone_typetransparent ||
1683 lzt == local_zone_inform ||
1684 lzt == local_zone_always_transparent) &&
1685 local_zone_does_not_cover(z, qinfo, labs)) {
1686 lock_rw_unlock(&z->lock);
1689 if(view->local_zones && !z && !view->isfirst){
1690 lock_rw_unlock(&view->lock);
1693 if(z && verbosity >= VERB_ALGO) {
1695 dname_str(z->name, zname);
1696 verbose(VERB_ALGO, "using localzone %s %s from view %s",
1697 zname, local_zone_type2str(lzt), view->name);
1699 lock_rw_unlock(&view->lock);
1702 /* try global local_zones tree */
1703 lock_rw_rdlock(&zones->lock);
1704 if(!(z = local_zones_tags_lookup(zones, qinfo->qname,
1705 qinfo->qname_len, labs, qinfo->qclass, qinfo->qtype,
1706 taglist, taglen, 0))) {
1707 lock_rw_unlock(&zones->lock);
1710 lock_rw_rdlock(&z->lock);
1711 lzt = lz_type(taglist, taglen, z->taglist, z->taglen,
1712 tagactions, tagactionssize, z->type, repinfo,
1713 z->override_tree, &tag, tagname, num_tags);
1714 lock_rw_unlock(&zones->lock);
1715 if(z && verbosity >= VERB_ALGO) {
1717 dname_str(z->name, zname);
1718 verbose(VERB_ALGO, "using localzone %s %s", zname,
1719 local_zone_type2str(lzt));
1722 if((env->cfg->log_local_actions ||
1723 lzt == local_zone_inform ||
1724 lzt == local_zone_inform_deny ||
1725 lzt == local_zone_inform_redirect)
1727 lz_inform_print(z, qinfo, repinfo);
1729 if(lzt != local_zone_always_refuse
1730 && lzt != local_zone_always_transparent
1731 && lzt != local_zone_always_nxdomain
1732 && lzt != local_zone_always_nodata
1733 && lzt != local_zone_always_deny
1734 && local_data_answer(z, env, qinfo, edns, repinfo, buf, temp, labs,
1735 &ld, lzt, tag, tag_datas, tag_datas_size, tagname, num_tags)) {
1736 lock_rw_unlock(&z->lock);
1737 /* We should tell the caller that encode is deferred if we found
1739 return !qinfo->local_alias;
1741 r = local_zones_zone_answer(z, env, qinfo, edns, repinfo, buf, temp, ld, lzt);
1742 lock_rw_unlock(&z->lock);
1743 return r && !qinfo->local_alias; /* see above */
1746 const char* local_zone_type2str(enum localzone_type t)
1749 case local_zone_unset: return "unset";
1750 case local_zone_deny: return "deny";
1751 case local_zone_refuse: return "refuse";
1752 case local_zone_redirect: return "redirect";
1753 case local_zone_transparent: return "transparent";
1754 case local_zone_typetransparent: return "typetransparent";
1755 case local_zone_static: return "static";
1756 case local_zone_nodefault: return "nodefault";
1757 case local_zone_inform: return "inform";
1758 case local_zone_inform_deny: return "inform_deny";
1759 case local_zone_inform_redirect: return "inform_redirect";
1760 case local_zone_always_transparent: return "always_transparent";
1761 case local_zone_always_refuse: return "always_refuse";
1762 case local_zone_always_nxdomain: return "always_nxdomain";
1763 case local_zone_always_nodata: return "always_nodata";
1764 case local_zone_always_deny: return "always_deny";
1765 case local_zone_noview: return "noview";
1766 case local_zone_invalid: return "invalid";
1771 int local_zone_str2type(const char* type, enum localzone_type* t)
1773 if(strcmp(type, "deny") == 0)
1774 *t = local_zone_deny;
1775 else if(strcmp(type, "refuse") == 0)
1776 *t = local_zone_refuse;
1777 else if(strcmp(type, "static") == 0)
1778 *t = local_zone_static;
1779 else if(strcmp(type, "transparent") == 0)
1780 *t = local_zone_transparent;
1781 else if(strcmp(type, "typetransparent") == 0)
1782 *t = local_zone_typetransparent;
1783 else if(strcmp(type, "redirect") == 0)
1784 *t = local_zone_redirect;
1785 else if(strcmp(type, "inform") == 0)
1786 *t = local_zone_inform;
1787 else if(strcmp(type, "inform_deny") == 0)
1788 *t = local_zone_inform_deny;
1789 else if(strcmp(type, "inform_redirect") == 0)
1790 *t = local_zone_inform_redirect;
1791 else if(strcmp(type, "always_transparent") == 0)
1792 *t = local_zone_always_transparent;
1793 else if(strcmp(type, "always_refuse") == 0)
1794 *t = local_zone_always_refuse;
1795 else if(strcmp(type, "always_nxdomain") == 0)
1796 *t = local_zone_always_nxdomain;
1797 else if(strcmp(type, "always_nodata") == 0)
1798 *t = local_zone_always_nodata;
1799 else if(strcmp(type, "always_deny") == 0)
1800 *t = local_zone_always_deny;
1801 else if(strcmp(type, "noview") == 0)
1802 *t = local_zone_noview;
1803 else if(strcmp(type, "nodefault") == 0)
1804 *t = local_zone_nodefault;
1809 /** iterate over the kiddies of the given name and set their parent ptr */
1811 set_kiddo_parents(struct local_zone* z, struct local_zone* match,
1812 struct local_zone* newp)
1814 /* both zones and z are locked already */
1815 /* in the sorted rbtree, the kiddies of z are located after z */
1816 /* z must be present in the tree */
1817 struct local_zone* p = z;
1818 p = (struct local_zone*)rbtree_next(&p->node);
1819 while(p!=(struct local_zone*)RBTREE_NULL &&
1820 p->dclass == z->dclass && dname_strict_subdomain(p->name,
1821 p->namelabs, z->name, z->namelabs)) {
1822 /* update parent ptr */
1823 /* only when matches with existing parent pointer, so that
1824 * deeper child structures are not touched, i.e.
1825 * update of x, and a.x, b.x, f.b.x, g.b.x, c.x, y
1826 * gets to update a.x, b.x and c.x */
1827 lock_rw_wrlock(&p->lock);
1828 if(p->parent == match)
1830 lock_rw_unlock(&p->lock);
1831 p = (struct local_zone*)rbtree_next(&p->node);
1835 struct local_zone* local_zones_add_zone(struct local_zones* zones,
1836 uint8_t* name, size_t len, int labs, uint16_t dclass,
1837 enum localzone_type tp)
1840 struct local_zone* z = local_zone_create(name, len, labs, tp, dclass);
1845 lock_rw_wrlock(&z->lock);
1847 /* find the closest parent */
1848 z->parent = local_zones_find(zones, name, len, labs, dclass);
1850 /* insert into the tree */
1851 if(!rbtree_insert(&zones->ztree, &z->node)) {
1852 /* duplicate entry! */
1853 lock_rw_unlock(&z->lock);
1854 local_zone_delete(z);
1855 log_err("internal: duplicate entry in local_zones_add_zone");
1859 /* set parent pointers right */
1860 set_kiddo_parents(z, z->parent, z);
1862 lock_rw_unlock(&z->lock);
1866 void local_zones_del_zone(struct local_zones* zones, struct local_zone* z)
1868 /* fix up parents in tree */
1869 lock_rw_wrlock(&z->lock);
1870 set_kiddo_parents(z, z, z->parent);
1872 /* remove from tree */
1873 (void)rbtree_delete(&zones->ztree, z);
1875 /* delete the zone */
1876 lock_rw_unlock(&z->lock);
1877 local_zone_delete(z);
1881 local_zones_add_RR(struct local_zones* zones, const char* rr)
1884 uint16_t rr_class, rr_type;
1887 struct local_zone* z;
1889 if(!get_rr_nameclass(rr, &rr_name, &rr_class, &rr_type)) {
1892 labs = dname_count_size_labels(rr_name, &len);
1893 /* could first try readlock then get writelock if zone does not exist,
1894 * but we do not add enough RRs (from multiple threads) to optimize */
1895 lock_rw_wrlock(&zones->lock);
1896 z = local_zones_lookup(zones, rr_name, len, labs, rr_class, rr_type);
1898 z = local_zones_add_zone(zones, rr_name, len, labs, rr_class,
1899 local_zone_transparent);
1901 lock_rw_unlock(&zones->lock);
1907 lock_rw_wrlock(&z->lock);
1908 lock_rw_unlock(&zones->lock);
1909 r = lz_enter_rr_into_zone(z, rr);
1910 lock_rw_unlock(&z->lock);
1914 /** returns true if the node is terminal so no deeper domain names exist */
1916 is_terminal(struct local_data* d)
1918 /* for empty nonterminals, the deeper domain names are sorted
1919 * right after them, so simply check the next name in the tree
1921 struct local_data* n = (struct local_data*)rbtree_next(&d->node);
1922 if(n == (struct local_data*)RBTREE_NULL)
1923 return 1; /* last in tree, no deeper node */
1924 if(dname_strict_subdomain(n->name, n->namelabs, d->name, d->namelabs))
1925 return 0; /* there is a deeper node */
1929 /** delete empty terminals from tree when final data is deleted */
1931 del_empty_term(struct local_zone* z, struct local_data* d,
1932 uint8_t* name, size_t len, int labs)
1934 while(d && d->rrsets == NULL && is_terminal(d)) {
1935 /* is this empty nonterminal? delete */
1936 /* note, no memory recycling in zone region */
1937 (void)rbtree_delete(&z->data, d);
1939 /* go up and to the next label */
1940 if(dname_is_root(name))
1942 dname_remove_label(&name, &len);
1944 d = local_zone_find_data(z, name, len, labs);
1948 /** find and remove type from list in domain struct */
1950 del_local_rrset(struct local_data* d, uint16_t dtype)
1952 struct local_rrset* prev=NULL, *p=d->rrsets;
1953 while(p && ntohs(p->rrset->rk.type) != dtype) {
1958 return; /* rrset type not found */
1960 if(prev) prev->next = p->next;
1961 else d->rrsets = p->next;
1962 /* no memory recycling for zone deletions ... */
1965 void local_zones_del_data(struct local_zones* zones,
1966 uint8_t* name, size_t len, int labs, uint16_t dclass)
1969 struct local_zone* z;
1970 struct local_data* d;
1973 lock_rw_rdlock(&zones->lock);
1974 z = local_zones_lookup(zones, name, len, labs, dclass, LDNS_RR_TYPE_DS);
1976 lock_rw_wrlock(&z->lock);
1977 d = local_zone_find_data(z, name, len, labs);
1979 del_local_rrset(d, LDNS_RR_TYPE_DS);
1980 del_empty_term(z, d, name, len, labs);
1982 lock_rw_unlock(&z->lock);
1984 lock_rw_unlock(&zones->lock);
1986 /* remove other types */
1987 lock_rw_rdlock(&zones->lock);
1988 z = local_zones_lookup(zones, name, len, labs, dclass, 0);
1990 /* no such zone, we're done */
1991 lock_rw_unlock(&zones->lock);
1994 lock_rw_wrlock(&z->lock);
1995 lock_rw_unlock(&zones->lock);
1997 /* find the domain */
1998 d = local_zone_find_data(z, name, len, labs);
2000 /* no memory recycling for zone deletions ... */
2002 /* did we delete the soa record ? */
2003 if(query_dname_compare(d->name, z->name) == 0)
2006 /* cleanup the empty nonterminals for this name */
2007 del_empty_term(z, d, name, len, labs);
2010 lock_rw_unlock(&z->lock);