contrib/unbound/services/localzone.c

   1 /*
   2  * services/localzone.c - local zones authority service.
   3  *
   4  * Copyright (c) 2007, NLnet Labs. All rights reserved.
   5  *
   6  * This software is open source.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * Redistributions of source code must retain the above copyright notice,
  13  * this list of conditions and the following disclaimer.
  14  *
  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.
  18  *
  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.
  22  *
  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.
  34  */
  35
  36 /**
  37  * \file
  38  *
  39  * This file contains functions to enable local zone authority service.
  40  */
  41 #include "config.h"
  42 #include "services/localzone.h"
  43 #include "sldns/str2wire.h"
  44 #include "sldns/sbuffer.h"
  45 #include "util/regional.h"
  46 #include "util/config_file.h"
  47 #include "util/data/dname.h"
  48 #include "util/data/packed_rrset.h"
  49 #include "util/data/msgencode.h"
  50 #include "util/net_help.h"
  51 #include "util/netevent.h"
  52 #include "util/data/msgreply.h"
  53 #include "util/data/msgparse.h"
  54 #include "util/as112.h"
  55 #include "util/config_file.h"
  56
  57 /* maximum RRs in an RRset, to cap possible 'endless' list RRs.
  58  * with 16 bytes for an A record, a 64K packet has about 4000 max */
  59 #define LOCALZONE_RRSET_COUNT_MAX 4096
  60
  61 struct local_zones*
  62 local_zones_create(void)
  63 {
  64         struct local_zones* zones = (struct local_zones*)calloc(1,
  65                 sizeof(*zones));
  66         if(!zones)
  67                 return NULL;
  68         rbtree_init(&zones->ztree, &local_zone_cmp);
  69         lock_rw_init(&zones->lock);
  70         lock_protect(&zones->lock, &zones->ztree, sizeof(zones->ztree));
  71         /* also lock protects the rbnode's in struct local_zone */
  72         return zones;
  73 }
  74
  75 /** helper traverse to delete zones */
  76 static void
  77 lzdel(rbnode_type* n, void* ATTR_UNUSED(arg))
  78 {
  79         struct local_zone* z = (struct local_zone*)n->key;
  80         local_zone_delete(z);
  81 }
  82
  83 void
  84 local_zones_delete(struct local_zones* zones)
  85 {
  86         if(!zones)
  87                 return;
  88         lock_rw_destroy(&zones->lock);
  89         /* walk through zones and delete them all */
  90         traverse_postorder(&zones->ztree, lzdel, NULL);
  91         free(zones);
  92 }
  93
  94 void
  95 local_zone_delete(struct local_zone* z)
  96 {
  97         if(!z)
  98                 return;
  99         lock_rw_destroy(&z->lock);
 100         regional_destroy(z->region);
 101         free(z->name);
 102         free(z->taglist);
 103         free(z);
 104 }
 105
 106 int
 107 local_zone_cmp(const void* z1, const void* z2)
 108 {
 109         /* first sort on class, so that hierarchy can be maintained within
 110          * a class */
 111         struct local_zone* a = (struct local_zone*)z1;
 112         struct local_zone* b = (struct local_zone*)z2;
 113         int m;
 114         if(a->dclass != b->dclass) {
 115                 if(a->dclass < b->dclass)
 116                         return -1;
 117                 return 1;
 118         }
 119         return dname_lab_cmp(a->name, a->namelabs, b->name, b->namelabs, &m);
 120 }
 121
 122 int
 123 local_data_cmp(const void* d1, const void* d2)
 124 {
 125         struct local_data* a = (struct local_data*)d1;
 126         struct local_data* b = (struct local_data*)d2;
 127         int m;
 128         return dname_canon_lab_cmp(a->name, a->namelabs, b->name,
 129                 b->namelabs, &m);
 130 }
 131
 132 /* form wireformat from text format domain name */
 133 int
 134 parse_dname(const char* str, uint8_t** res, size_t* len, int* labs)
 135 {
 136         *res = sldns_str2wire_dname(str, len);
 137         *labs = 0;
 138         if(!*res) {
 139                 log_err("cannot parse name %s", str);
 140                 return 0;
 141         }
 142         *labs = dname_count_size_labels(*res, len);
 143         return 1;
 144 }
 145
 146 /** create a new localzone */
 147 static struct local_zone*
 148 local_zone_create(uint8_t* nm, size_t len, int labs,
 149         enum localzone_type t, uint16_t dclass)
 150 {
 151         struct local_zone* z = (struct local_zone*)calloc(1, sizeof(*z));
 152         if(!z) {
 153                 return NULL;
 154         }
 155         z->node.key = z;
 156         z->dclass = dclass;
 157         z->type = t;
 158         z->name = nm;
 159         z->namelen = len;
 160         z->namelabs = labs;
 161         lock_rw_init(&z->lock);
 162         z->region = regional_create_custom(sizeof(struct regional));
 163         if(!z->region) {
 164                 free(z);
 165                 return NULL;
 166         }
 167         rbtree_init(&z->data, &local_data_cmp);
 168         lock_protect(&z->lock, &z->parent, sizeof(*z)-sizeof(rbnode_type));
 169         /* also the zones->lock protects node, parent, name*, class */
 170         return z;
 171 }
 172
 173 /** enter a new zone with allocated dname returns with WRlock */
 174 static struct local_zone*
 175 lz_enter_zone_dname(struct local_zones* zones, uint8_t* nm, size_t len,
 176         int labs, enum localzone_type t, uint16_t c)
 177 {
 178         struct local_zone* z = local_zone_create(nm, len, labs, t, c);
 179         if(!z) {
 180                 free(nm);
 181                 log_err("out of memory");
 182                 return NULL;
 183         }
 184
 185         /* add to rbtree */
 186         lock_rw_wrlock(&zones->lock);
 187         lock_rw_wrlock(&z->lock);
 188         if(!rbtree_insert(&zones->ztree, &z->node)) {
 189                 struct local_zone* oldz;
 190                 log_warn("duplicate local-zone");
 191                 lock_rw_unlock(&z->lock);
 192                 /* save zone name locally before deallocation,
 193                  * otherwise, nm is gone if we zone_delete now. */
 194                 oldz = z;
 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);
 200                 return z;
 201         }
 202         lock_rw_unlock(&zones->lock);
 203         return z;
 204 }
 205
 206 /** enter a new zone */
 207 static struct local_zone*
 208 lz_enter_zone(struct local_zones* zones, const char* name, const char* type,
 209         uint16_t dclass)
 210 {
 211         struct local_zone* z;
 212         enum localzone_type t;
 213         uint8_t* nm;
 214         size_t len;
 215         int labs;
 216         if(!parse_dname(name, &nm, &len, &labs)) {
 217                 log_err("bad zone name %s %s", name, type);
 218                 return NULL;
 219         }
 220         if(!local_zone_str2type(type, &t)) {
 221                 log_err("bad lz_enter_zone type %s %s", name, type);
 222                 free(nm);
 223                 return NULL;
 224         }
 225         if(!(z=lz_enter_zone_dname(zones, nm, len, labs, t, dclass))) {
 226                 log_err("could not enter zone %s %s", name, type);
 227                 return NULL;
 228         }
 229         return z;
 230 }
 231
 232 int
 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)
 236 {
 237         size_t dname_len = 0;
 238         int e = sldns_str2wire_rr_buf(str, rr, &len, &dname_len, 3600,
 239                 NULL, 0, NULL, 0);
 240         if(e) {
 241                 log_err("error parsing local-data at %d: '%s': %s",
 242                         LDNS_WIREPARSE_OFFSET(e), str,
 243                         sldns_get_errorstr_parse(e));
 244                 return 0;
 245         }
 246         *nm = memdup(rr, dname_len);
 247         if(!*nm) {
 248                 log_err("out of memory");
 249                 return 0;
 250         }
 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;
 256         return 1;
 257 }
 258
 259 /** return name and class of rr; parses string */
 260 static int
 261 get_rr_nameclass(const char* str, uint8_t** nm, uint16_t* dclass)
 262 {
 263         uint8_t rr[LDNS_RR_BUF_SIZE];
 264         size_t len = sizeof(rr), dname_len = 0;
 265         int s = sldns_str2wire_rr_buf(str, rr, &len, &dname_len, 3600,
 266                 NULL, 0, NULL, 0);
 267         if(s != 0) {
 268                 log_err("error parsing local-data at %d '%s': %s",
 269                         LDNS_WIREPARSE_OFFSET(s), str,
 270                         sldns_get_errorstr_parse(s));
 271                 return 0;
 272         }
 273         *nm = memdup(rr, dname_len);
 274         *dclass = sldns_wirerr_get_class(rr, len, dname_len);
 275         if(!*nm) {
 276                 log_err("out of memory");
 277                 return 0;
 278         }
 279         return 1;
 280 }
 281
 282 /**
 283  * Find an rrset in local data structure.
 284  * @param data: local data domain name structure.
 285  * @param type: type to look for (host order).
 286  * @param alias_ok: 1 if matching a non-exact, alias type such as CNAME is
 287  * allowed.  otherwise 0.
 288  * @return rrset pointer or NULL if not found.
 289  */
 290 static struct local_rrset*
 291 local_data_find_type(struct local_data* data, uint16_t type, int alias_ok)
 292 {
 293         struct local_rrset* p;
 294         type = htons(type);
 295         for(p = data->rrsets; p; p = p->next) {
 296                 if(p->rrset->rk.type == type)
 297                         return p;
 298                 if(alias_ok && p->rrset->rk.type == htons(LDNS_RR_TYPE_CNAME))
 299                         return p;
 300         }
 301         return NULL;
 302 }
 303
 304 /** check for RR duplicates */
 305 static int
 306 rr_is_duplicate(struct packed_rrset_data* pd, uint8_t* rdata, size_t rdata_len)
 307 {
 308         size_t i;
 309         for(i=0; i<pd->count; i++) {
 310                 if(pd->rr_len[i] == rdata_len &&
 311                         memcmp(pd->rr_data[i], rdata, rdata_len) == 0)
 312                         return 1;
 313         }
 314         return 0;
 315 }
 316
 317 /** new local_rrset */
 318 static struct local_rrset*
 319 new_local_rrset(struct regional* region, struct local_data* node,
 320         uint16_t rrtype, uint16_t rrclass)
 321 {
 322         struct packed_rrset_data* pd;
 323         struct local_rrset* rrset = (struct local_rrset*)
 324                 regional_alloc_zero(region, sizeof(*rrset));
 325         if(!rrset) {
 326                 log_err("out of memory");
 327                 return NULL;
 328         }
 329         rrset->next = node->rrsets;
 330         node->rrsets = rrset;
 331         rrset->rrset = (struct ub_packed_rrset_key*)
 332                 regional_alloc_zero(region, sizeof(*rrset->rrset));
 333         if(!rrset->rrset) {
 334                 log_err("out of memory");
 335                 return NULL;
 336         }
 337         rrset->rrset->entry.key = rrset->rrset;
 338         pd = (struct packed_rrset_data*)regional_alloc_zero(region,
 339                 sizeof(*pd));
 340         if(!pd) {
 341                 log_err("out of memory");
 342                 return NULL;
 343         }
 344         pd->trust = rrset_trust_prim_noglue;
 345         pd->security = sec_status_insecure;
 346         rrset->rrset->entry.data = pd;
 347         rrset->rrset->rk.dname = node->name;
 348         rrset->rrset->rk.dname_len = node->namelen;
 349         rrset->rrset->rk.type = htons(rrtype);
 350         rrset->rrset->rk.rrset_class = htons(rrclass);
 351         return rrset;
 352 }
 353
 354 /** insert RR into RRset data structure; Wastes a couple of bytes */
 355 int
 356 rrset_insert_rr(struct regional* region, struct packed_rrset_data* pd,
 357         uint8_t* rdata, size_t rdata_len, time_t ttl, const char* rrstr)
 358 {
 359         size_t* oldlen = pd->rr_len;
 360         time_t* oldttl = pd->rr_ttl;
 361         uint8_t** olddata = pd->rr_data;
 362
 363         /* add RR to rrset */
 364         if(pd->count > LOCALZONE_RRSET_COUNT_MAX) {
 365                 log_warn("RRset '%s' has more than %d records, record ignored",
 366                         rrstr, LOCALZONE_RRSET_COUNT_MAX);
 367                 return 1;
 368         }
 369         pd->count++;
 370         pd->rr_len = regional_alloc(region, sizeof(*pd->rr_len)*pd->count);
 371         pd->rr_ttl = regional_alloc(region, sizeof(*pd->rr_ttl)*pd->count);
 372         pd->rr_data = regional_alloc(region, sizeof(*pd->rr_data)*pd->count);
 373         if(!pd->rr_len || !pd->rr_ttl || !pd->rr_data) {
 374                 log_err("out of memory");
 375                 return 0;
 376         }
 377         if(pd->count > 1) {
 378                 memcpy(pd->rr_len+1, oldlen,
 379                         sizeof(*pd->rr_len)*(pd->count-1));
 380                 memcpy(pd->rr_ttl+1, oldttl,
 381                         sizeof(*pd->rr_ttl)*(pd->count-1));
 382                 memcpy(pd->rr_data+1, olddata,
 383                         sizeof(*pd->rr_data)*(pd->count-1));
 384         }
 385         pd->rr_len[0] = rdata_len;
 386         pd->rr_ttl[0] = ttl;
 387         pd->rr_data[0] = regional_alloc_init(region, rdata, rdata_len);
 388         if(!pd->rr_data[0]) {
 389                 log_err("out of memory");
 390                 return 0;
 391         }
 392         return 1;
 393 }
 394
 395 /** find a data node by exact name */
 396 static struct local_data*
 397 lz_find_node(struct local_zone* z, uint8_t* nm, size_t nmlen, int nmlabs)
 398 {
 399         struct local_data key;
 400         key.node.key = &key;
 401         key.name = nm;
 402         key.namelen = nmlen;
 403         key.namelabs = nmlabs;
 404         return (struct local_data*)rbtree_search(&z->data, &key.node);
 405 }
 406
 407 /** find a node, create it if not and all its empty nonterminal parents */
 408 static int
 409 lz_find_create_node(struct local_zone* z, uint8_t* nm, size_t nmlen,
 410         int nmlabs, struct local_data** res)
 411 {
 412         struct local_data* ld = lz_find_node(z, nm, nmlen, nmlabs);
 413         if(!ld) {
 414                 /* create a domain name to store rr. */
 415                 ld = (struct local_data*)regional_alloc_zero(z->region,
 416                         sizeof(*ld));
 417                 if(!ld) {
 418                         log_err("out of memory adding local data");
 419                         return 0;
 420                 }
 421                 ld->node.key = ld;
 422                 ld->name = regional_alloc_init(z->region, nm, nmlen);
 423                 if(!ld->name) {
 424                         log_err("out of memory");
 425                         return 0;
 426                 }
 427                 ld->namelen = nmlen;
 428                 ld->namelabs = nmlabs;
 429                 if(!rbtree_insert(&z->data, &ld->node)) {
 430                         log_assert(0); /* duplicate name */
 431                 }
 432                 /* see if empty nonterminals need to be created */
 433                 if(nmlabs > z->namelabs) {
 434                         dname_remove_label(&nm, &nmlen);
 435                         if(!lz_find_create_node(z, nm, nmlen, nmlabs-1, res))
 436                                 return 0;
 437                 }
 438         }
 439         *res = ld;
 440         return 1;
 441 }
 442
 443 /** enter data RR into auth zone */
 444 static int
 445 lz_enter_rr_into_zone(struct local_zone* z, const char* rrstr)
 446 {
 447         uint8_t* nm;
 448         size_t nmlen;
 449         int nmlabs;
 450         struct local_data* node;
 451         struct local_rrset* rrset;
 452         struct packed_rrset_data* pd;
 453         uint16_t rrtype = 0, rrclass = 0;
 454         time_t ttl = 0;
 455         uint8_t rr[LDNS_RR_BUF_SIZE];
 456         uint8_t* rdata;
 457         size_t rdata_len;
 458         if(!rrstr_get_rr_content(rrstr, &nm, &rrtype, &rrclass, &ttl, rr,
 459                 sizeof(rr), &rdata, &rdata_len)) {
 460                 log_err("bad local-data: %s", rrstr);
 461                 return 0;
 462         }
 463         log_assert(z->dclass == rrclass);
 464         if(z->type == local_zone_redirect &&
 465                 query_dname_compare(z->name, nm) != 0) {
 466                 log_err("local-data in redirect zone must reside at top of zone"
 467                         ", not at %s", rrstr);
 468                 free(nm);
 469                 return 0;
 470         }
 471         nmlabs = dname_count_size_labels(nm, &nmlen);
 472         if(!lz_find_create_node(z, nm, nmlen, nmlabs, &node)) {
 473                 free(nm);
 474                 return 0;
 475         }
 476         log_assert(node);
 477         free(nm);
 478
 479         /* Reject it if we would end up having CNAME and other data (including
 480          * another CNAME) for a redirect zone. */
 481         if(z->type == local_zone_redirect && node->rrsets) {
 482                 const char* othertype = NULL;
 483                 if (rrtype == LDNS_RR_TYPE_CNAME)
 484                         othertype = "other";
 485                 else if (node->rrsets->rrset->rk.type ==
 486                          htons(LDNS_RR_TYPE_CNAME)) {
 487                         othertype = "CNAME";
 488                 }
 489                 if(othertype) {
 490                         log_err("local-data '%s' in redirect zone must not "
 491                                 "coexist with %s local-data", rrstr, othertype);
 492                         return 0;
 493                 }
 494         }
 495         rrset = local_data_find_type(node, rrtype, 0);
 496         if(!rrset) {
 497                 rrset = new_local_rrset(z->region, node, rrtype, rrclass);
 498                 if(!rrset)
 499                         return 0;
 500                 if(query_dname_compare(node->name, z->name) == 0) {
 501                         if(rrtype == LDNS_RR_TYPE_NSEC)
 502                           rrset->rrset->rk.flags = PACKED_RRSET_NSEC_AT_APEX;
 503                         if(rrtype == LDNS_RR_TYPE_SOA)
 504                                 z->soa = rrset->rrset;
 505                 }
 506         }
 507         pd = (struct packed_rrset_data*)rrset->rrset->entry.data;
 508         log_assert(rrset && pd);
 509
 510         /* check for duplicate RR */
 511         if(rr_is_duplicate(pd, rdata, rdata_len)) {
 512                 verbose(VERB_ALGO, "ignoring duplicate RR: %s", rrstr);
 513                 return 1;
 514         }
 515         return rrset_insert_rr(z->region, pd, rdata, rdata_len, ttl, rrstr);
 516 }
 517
 518 /** enter a data RR into auth data; a zone for it must exist */
 519 static int
 520 lz_enter_rr_str(struct local_zones* zones, const char* rr)
 521 {
 522         uint8_t* rr_name;
 523         uint16_t rr_class;
 524         size_t len;
 525         int labs;
 526         struct local_zone* z;
 527         int r;
 528         if(!get_rr_nameclass(rr, &rr_name, &rr_class)) {
 529                 log_err("bad rr %s", rr);
 530                 return 0;
 531         }
 532         labs = dname_count_size_labels(rr_name, &len);
 533         lock_rw_rdlock(&zones->lock);
 534         z = local_zones_lookup(zones, rr_name, len, labs, rr_class);
 535         if(!z) {
 536                 lock_rw_unlock(&zones->lock);
 537                 fatal_exit("internal error: no zone for rr %s", rr);
 538         }
 539         lock_rw_wrlock(&z->lock);
 540         lock_rw_unlock(&zones->lock);
 541         free(rr_name);
 542         r = lz_enter_rr_into_zone(z, rr);
 543         lock_rw_unlock(&z->lock);
 544         return r;
 545 }
 546
 547 /** enter tagstring into zone */
 548 static int
 549 lz_enter_zone_tag(struct local_zones* zones, char* zname, uint8_t* list,
 550         size_t len, uint16_t rr_class)
 551 {
 552         uint8_t dname[LDNS_MAX_DOMAINLEN+1];
 553         size_t dname_len = sizeof(dname);
 554         int dname_labs, r = 0;
 555         struct local_zone* z;
 556
 557         if(sldns_str2wire_dname_buf(zname, dname, &dname_len) != 0) {
 558                 log_err("cannot parse zone name in local-zone-tag: %s", zname);
 559                 return 0;
 560         }
 561         dname_labs = dname_count_labels(dname);
 562
 563         lock_rw_rdlock(&zones->lock);
 564         z = local_zones_find(zones, dname, dname_len, dname_labs, rr_class);
 565         if(!z) {
 566                 lock_rw_unlock(&zones->lock);
 567                 log_err("no local-zone for tag %s", zname);
 568                 return 0;
 569         }
 570         lock_rw_wrlock(&z->lock);
 571         lock_rw_unlock(&zones->lock);
 572         free(z->taglist);
 573         z->taglist = memdup(list, len);
 574         z->taglen = len;
 575         if(z->taglist)
 576                 r = 1;
 577         lock_rw_unlock(&z->lock);
 578         return r;
 579 }
 580
 581 /** enter override into zone */
 582 static int
 583 lz_enter_override(struct local_zones* zones, char* zname, char* netblock,
 584         char* type, uint16_t rr_class)
 585 {
 586         uint8_t dname[LDNS_MAX_DOMAINLEN+1];
 587         size_t dname_len = sizeof(dname);
 588         int dname_labs;
 589         struct sockaddr_storage addr;
 590         int net;
 591         socklen_t addrlen;
 592         struct local_zone* z;
 593         enum localzone_type t;
 594
 595         /* parse zone name */
 596         if(sldns_str2wire_dname_buf(zname, dname, &dname_len) != 0) {
 597                 log_err("cannot parse zone name in local-zone-override: %s %s",
 598                         zname, netblock);
 599                 return 0;
 600         }
 601         dname_labs = dname_count_labels(dname);
 602
 603         /* parse netblock */
 604         if(!netblockstrtoaddr(netblock, UNBOUND_DNS_PORT, &addr, &addrlen,
 605                 &net)) {
 606                 log_err("cannot parse netblock in local-zone-override: %s %s",
 607                         zname, netblock);
 608                 return 0;
 609         }
 610
 611         /* parse zone type */
 612         if(!local_zone_str2type(type, &t)) {
 613                 log_err("cannot parse type in local-zone-override: %s %s %s",
 614                         zname, netblock, type);
 615                 return 0;
 616         }
 617
 618         /* find localzone entry */
 619         lock_rw_rdlock(&zones->lock);
 620         z = local_zones_find(zones, dname, dname_len, dname_labs, rr_class);
 621         if(!z) {
 622                 lock_rw_unlock(&zones->lock);
 623                 log_err("no local-zone for local-zone-override %s", zname);
 624                 return 0;
 625         }
 626         lock_rw_wrlock(&z->lock);
 627         lock_rw_unlock(&zones->lock);
 628
 629         /* create netblock addr_tree if not present yet */
 630         if(!z->override_tree) {
 631                 z->override_tree = (struct rbtree_type*)regional_alloc_zero(
 632                         z->region, sizeof(*z->override_tree));
 633                 if(!z->override_tree) {
 634                         lock_rw_unlock(&z->lock);
 635                         log_err("out of memory");
 636                         return 0;
 637                 }
 638                 addr_tree_init(z->override_tree);
 639         }
 640         /* add new elem to tree */
 641         if(z->override_tree) {
 642                 struct local_zone_override* n;
 643                 n = (struct local_zone_override*)regional_alloc_zero(
 644                         z->region, sizeof(*n));
 645                 if(!n) {
 646                         lock_rw_unlock(&z->lock);
 647                         log_err("out of memory");
 648                         return 0;
 649                 }
 650                 n->type = t;
 651                 if(!addr_tree_insert(z->override_tree,
 652                         (struct addr_tree_node*)n, &addr, addrlen, net)) {
 653                         lock_rw_unlock(&z->lock);
 654                         log_err("duplicate local-zone-override %s %s",
 655                                 zname, netblock);
 656                         return 1;
 657                 }
 658         }
 659
 660         lock_rw_unlock(&z->lock);
 661         return 1;
 662 }
 663
 664 /** parse local-zone: statements */
 665 static int
 666 lz_enter_zones(struct local_zones* zones, struct config_file* cfg)
 667 {
 668         struct config_str2list* p;
 669         struct local_zone* z;
 670         for(p = cfg->local_zones; p; p = p->next) {
 671                 if(!(z=lz_enter_zone(zones, p->str, p->str2,
 672                         LDNS_RR_CLASS_IN)))
 673                         return 0;
 674                 lock_rw_unlock(&z->lock);
 675         }
 676         return 1;
 677 }
 678
 679 /** lookup a zone in rbtree; exact match only; SLOW due to parse */
 680 static int
 681 lz_exists(struct local_zones* zones, const char* name)
 682 {
 683         struct local_zone z;
 684         z.node.key = &z;
 685         z.dclass = LDNS_RR_CLASS_IN;
 686         if(!parse_dname(name, &z.name, &z.namelen, &z.namelabs)) {
 687                 log_err("bad name %s", name);
 688                 return 0;
 689         }
 690         lock_rw_rdlock(&zones->lock);
 691         if(rbtree_search(&zones->ztree, &z.node)) {
 692                 lock_rw_unlock(&zones->lock);
 693                 free(z.name);
 694                 return 1;
 695         }
 696         lock_rw_unlock(&zones->lock);
 697         free(z.name);
 698         return 0;
 699 }
 700
 701 /** lookup a zone in cfg->nodefault list */
 702 static int
 703 lz_nodefault(struct config_file* cfg, const char* name)
 704 {
 705         struct config_strlist* p;
 706         size_t len = strlen(name);
 707         if(len == 0) return 0;
 708         if(name[len-1] == '.') len--;
 709
 710         for(p = cfg->local_zones_nodefault; p; p = p->next) {
 711                 /* compare zone name, lowercase, compare without ending . */
 712                 if(strncasecmp(p->str, name, len) == 0 &&
 713                         (strlen(p->str) == len || (strlen(p->str)==len+1 &&
 714                         p->str[len] == '.')))
 715                         return 1;
 716         }
 717         return 0;
 718 }
 719
 720 /** enter AS112 default zone */
 721 static int
 722 add_as112_default(struct local_zones* zones, struct config_file* cfg,
 723         const char* name)
 724 {
 725         struct local_zone* z;
 726         char str[1024]; /* known long enough */
 727         if(lz_exists(zones, name) || lz_nodefault(cfg, name))
 728                 return 1; /* do not enter default content */
 729         if(!(z=lz_enter_zone(zones, name, "static", LDNS_RR_CLASS_IN)))
 730                 return 0;
 731         snprintf(str, sizeof(str), "%s 10800 IN SOA localhost. "
 732                 "nobody.invalid. 1 3600 1200 604800 10800", name);
 733         if(!lz_enter_rr_into_zone(z, str)) {
 734                 lock_rw_unlock(&z->lock);
 735                 return 0;
 736         }
 737         snprintf(str, sizeof(str), "%s 10800 IN NS localhost. ", name);
 738         if(!lz_enter_rr_into_zone(z, str)) {
 739                 lock_rw_unlock(&z->lock);
 740                 return 0;
 741         }
 742         lock_rw_unlock(&z->lock);
 743         return 1;
 744 }
 745
 746 /** enter default zones */
 747 static int
 748 lz_enter_defaults(struct local_zones* zones, struct config_file* cfg)
 749 {
 750         struct local_zone* z;
 751         const char** zstr;
 752
 753         /* this list of zones is from RFC 6303 and RFC 7686 */
 754
 755         /* block localhost level zones first, then onion and later the LAN zones */
 756
 757         /* localhost. zone */
 758         if(!lz_exists(zones, "localhost.") &&
 759                 !lz_nodefault(cfg, "localhost.")) {
 760                 if(!(z=lz_enter_zone(zones, "localhost.", "static",
 761                         LDNS_RR_CLASS_IN)) ||
 762                    !lz_enter_rr_into_zone(z,
 763                         "localhost. 10800 IN NS localhost.") ||
 764                    !lz_enter_rr_into_zone(z,
 765                         "localhost. 10800 IN SOA localhost. nobody.invalid. "
 766                         "1 3600 1200 604800 10800") ||
 767                    !lz_enter_rr_into_zone(z,
 768                         "localhost. 10800 IN A 127.0.0.1") ||
 769                    !lz_enter_rr_into_zone(z,
 770                         "localhost. 10800 IN AAAA ::1")) {
 771                         log_err("out of memory adding default zone");
 772                         if(z) { lock_rw_unlock(&z->lock); }
 773                         return 0;
 774                 }
 775                 lock_rw_unlock(&z->lock);
 776         }
 777         /* reverse ip4 zone */
 778         if(!lz_exists(zones, "127.in-addr.arpa.") &&
 779                 !lz_nodefault(cfg, "127.in-addr.arpa.")) {
 780                 if(!(z=lz_enter_zone(zones, "127.in-addr.arpa.", "static",
 781                         LDNS_RR_CLASS_IN)) ||
 782                    !lz_enter_rr_into_zone(z,
 783                         "127.in-addr.arpa. 10800 IN NS localhost.") ||
 784                    !lz_enter_rr_into_zone(z,
 785                         "127.in-addr.arpa. 10800 IN SOA localhost. "
 786                         "nobody.invalid. 1 3600 1200 604800 10800") ||
 787                    !lz_enter_rr_into_zone(z,
 788                         "1.0.0.127.in-addr.arpa. 10800 IN PTR localhost.")) {
 789                         log_err("out of memory adding default zone");
 790                         if(z) { lock_rw_unlock(&z->lock); }
 791                         return 0;
 792                 }
 793                 lock_rw_unlock(&z->lock);
 794         }
 795         /* reverse ip6 zone */
 796         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.") &&
 797                 !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.")) {
 798                 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",
 799                         LDNS_RR_CLASS_IN)) ||
 800                    !lz_enter_rr_into_zone(z,
 801                         "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.") ||
 802                    !lz_enter_rr_into_zone(z,
 803                         "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. "
 804                         "nobody.invalid. 1 3600 1200 604800 10800") ||
 805                    !lz_enter_rr_into_zone(z,
 806                         "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.")) {
 807                         log_err("out of memory adding default zone");
 808                         if(z) { lock_rw_unlock(&z->lock); }
 809                         return 0;
 810                 }
 811                 lock_rw_unlock(&z->lock);
 812         }
 813         /* onion. zone (RFC 7686) */
 814         if(!lz_exists(zones, "onion.") &&
 815                 !lz_nodefault(cfg, "onion.")) {
 816                 if(!(z=lz_enter_zone(zones, "onion.", "static",
 817                         LDNS_RR_CLASS_IN)) ||
 818                    !lz_enter_rr_into_zone(z,
 819                         "onion. 10800 IN NS localhost.") ||
 820                    !lz_enter_rr_into_zone(z,
 821                         "onion. 10800 IN SOA localhost. nobody.invalid. "
 822                         "1 3600 1200 604800 10800")) {
 823                         log_err("out of memory adding default zone");
 824                         if(z) { lock_rw_unlock(&z->lock); }
 825                         return 0;
 826                 }
 827                 lock_rw_unlock(&z->lock);
 828         }
 829
 830         /* block AS112 zones, unless asked not to */
 831         if(!cfg->unblock_lan_zones) {
 832                 for(zstr = as112_zones; *zstr; zstr++) {
 833                         if(!add_as112_default(zones, cfg, *zstr)) {
 834                                 log_err("out of memory adding default zone");
 835                                 return 0;
 836                         }
 837                 }
 838         }
 839         return 1;
 840 }
 841
 842 /** parse local-zone-override: statements */
 843 static int
 844 lz_enter_overrides(struct local_zones* zones, struct config_file* cfg)
 845 {
 846         struct config_str3list* p;
 847         for(p = cfg->local_zone_overrides; p; p = p->next) {
 848                 if(!lz_enter_override(zones, p->str, p->str2, p->str3,
 849                         LDNS_RR_CLASS_IN))
 850                         return 0;
 851         }
 852         return 1;
 853 }
 854
 855 /** setup parent pointers, so that a lookup can be done for closest match */
 856 static void
 857 init_parents(struct local_zones* zones)
 858 {
 859         struct local_zone* node, *prev = NULL, *p;
 860         int m;
 861         lock_rw_wrlock(&zones->lock);
 862         RBTREE_FOR(node, struct local_zone*, &zones->ztree) {
 863                 lock_rw_wrlock(&node->lock);
 864                 node->parent = NULL;
 865                 if(!prev || prev->dclass != node->dclass) {
 866                         prev = node;
 867                         lock_rw_unlock(&node->lock);
 868                         continue;
 869                 }
 870                 (void)dname_lab_cmp(prev->name, prev->namelabs, node->name,
 871                         node->namelabs, &m); /* we know prev is smaller */
 872                 /* sort order like: . com. bla.com. zwb.com. net. */
 873                 /* find the previous, or parent-parent-parent */
 874                 for(p = prev; p; p = p->parent)
 875                         /* looking for name with few labels, a parent */
 876                         if(p->namelabs <= m) {
 877                                 /* ==: since prev matched m, this is closest*/
 878                                 /* <: prev matches more, but is not a parent,
 879                                  * this one is a (grand)parent */
 880                                 node->parent = p;
 881                                 break;
 882                         }
 883                 prev = node;
 884
 885                 if(node->override_tree)
 886                         addr_tree_init_parents(node->override_tree);
 887                 lock_rw_unlock(&node->lock);
 888         }
 889         lock_rw_unlock(&zones->lock);
 890 }
 891
 892 /** enter implicit transparent zone for local-data: without local-zone: */
 893 static int
 894 lz_setup_implicit(struct local_zones* zones, struct config_file* cfg)
 895 {
 896         /* walk over all items that have no parent zone and find
 897          * the name that covers them all (could be the root) and
 898          * add that as a transparent zone */
 899         struct config_strlist* p;
 900         int have_name = 0;
 901         int have_other_classes = 0;
 902         uint16_t dclass = 0;
 903         uint8_t* nm = 0;
 904         size_t nmlen = 0;
 905         int nmlabs = 0;
 906         int match = 0; /* number of labels match count */
 907
 908         init_parents(zones); /* to enable local_zones_lookup() */
 909         for(p = cfg->local_data; p; p = p->next) {
 910                 uint8_t* rr_name;
 911                 uint16_t rr_class;
 912                 size_t len;
 913                 int labs;
 914                 if(!get_rr_nameclass(p->str, &rr_name, &rr_class)) {
 915                         log_err("Bad local-data RR %s", p->str);
 916                         return 0;
 917                 }
 918                 labs = dname_count_size_labels(rr_name, &len);
 919                 lock_rw_rdlock(&zones->lock);
 920                 if(!local_zones_lookup(zones, rr_name, len, labs, rr_class)) {
 921                         if(!have_name) {
 922                                 dclass = rr_class;
 923                                 nm = rr_name;
 924                                 nmlen = len;
 925                                 nmlabs = labs;
 926                                 match = labs;
 927                                 have_name = 1;
 928                         } else {
 929                                 int m;
 930                                 if(rr_class != dclass) {
 931                                         /* process other classes later */
 932                                         free(rr_name);
 933                                         have_other_classes = 1;
 934                                         lock_rw_unlock(&zones->lock);
 935                                         continue;
 936                                 }
 937                                 /* find smallest shared topdomain */
 938                                 (void)dname_lab_cmp(nm, nmlabs,
 939                                         rr_name, labs, &m);
 940                                 free(rr_name);
 941                                 if(m < match)
 942                                         match = m;
 943                         }
 944                 } else free(rr_name);
 945                 lock_rw_unlock(&zones->lock);
 946         }
 947         if(have_name) {
 948                 uint8_t* n2;
 949                 struct local_zone* z;
 950                 /* allocate zone of smallest shared topdomain to contain em */
 951                 n2 = nm;
 952                 dname_remove_labels(&n2, &nmlen, nmlabs - match);
 953                 n2 = memdup(n2, nmlen);
 954                 free(nm);
 955                 if(!n2) {
 956                         log_err("out of memory");
 957                         return 0;
 958                 }
 959                 log_nametypeclass(VERB_ALGO, "implicit transparent local-zone",
 960                         n2, 0, dclass);
 961                 if(!(z=lz_enter_zone_dname(zones, n2, nmlen, match,
 962                         local_zone_transparent, dclass))) {
 963                         return 0;
 964                 }
 965                 lock_rw_unlock(&z->lock);
 966         }
 967         if(have_other_classes) {
 968                 /* restart to setup other class */
 969                 return lz_setup_implicit(zones, cfg);
 970         }
 971         return 1;
 972 }
 973
 974 /** enter local-zone-tag info */
 975 static int
 976 lz_enter_zone_tags(struct local_zones* zones, struct config_file* cfg)
 977 {
 978         struct config_strbytelist* p;
 979         int c = 0;
 980         for(p = cfg->local_zone_tags; p; p = p->next) {
 981                 if(!lz_enter_zone_tag(zones, p->str, p->str2, p->str2len,
 982                         LDNS_RR_CLASS_IN))
 983                         return 0;
 984                 c++;
 985         }
 986         if(c) verbose(VERB_ALGO, "applied tags to %d local zones", c);
 987         return 1;
 988 }
 989
 990 /** enter auth data */
 991 static int
 992 lz_enter_data(struct local_zones* zones, struct config_file* cfg)
 993 {
 994         struct config_strlist* p;
 995         for(p = cfg->local_data; p; p = p->next) {
 996                 if(!lz_enter_rr_str(zones, p->str))
 997                         return 0;
 998         }
 999         return 1;
1000 }
1001
1002 /** free memory from config */
1003 static void
1004 lz_freeup_cfg(struct config_file* cfg)
1005 {
1006         config_deldblstrlist(cfg->local_zones);
1007         cfg->local_zones = NULL;
1008         config_delstrlist(cfg->local_zones_nodefault);
1009         cfg->local_zones_nodefault = NULL;
1010         config_delstrlist(cfg->local_data);
1011         cfg->local_data = NULL;
1012 }
1013
1014 int
1015 local_zones_apply_cfg(struct local_zones* zones, struct config_file* cfg)
1016 {
1017         /* create zones from zone statements. */
1018         if(!lz_enter_zones(zones, cfg)) {
1019                 return 0;
1020         }
1021         /* apply default zones+content (unless disabled, or overridden) */
1022         if(!lz_enter_defaults(zones, cfg)) {
1023                 return 0;
1024         }
1025         /* enter local zone overrides */
1026         if(!lz_enter_overrides(zones, cfg)) {
1027                 return 0;
1028         }
1029         /* create implicit transparent zone from data. */
1030         if(!lz_setup_implicit(zones, cfg)) {
1031                 return 0;
1032         }
1033
1034         /* setup parent ptrs for lookup during data entry */
1035         init_parents(zones);
1036         /* insert local zone tags */
1037         if(!lz_enter_zone_tags(zones, cfg)) {
1038                 return 0;
1039         }
1040         /* insert local data */
1041         if(!lz_enter_data(zones, cfg)) {
1042                 return 0;
1043         }
1044         /* freeup memory from cfg struct. */
1045         lz_freeup_cfg(cfg);
1046         return 1;
1047 }
1048
1049 struct local_zone*
1050 local_zones_lookup(struct local_zones* zones,
1051         uint8_t* name, size_t len, int labs, uint16_t dclass)
1052 {
1053         return local_zones_tags_lookup(zones, name, len, labs,
1054                 dclass, NULL, 0, 1);
1055 }
1056
1057 struct local_zone*
1058 local_zones_tags_lookup(struct local_zones* zones,
1059         uint8_t* name, size_t len, int labs, uint16_t dclass,
1060         uint8_t* taglist, size_t taglen, int ignoretags)
1061 {
1062         rbnode_type* res = NULL;
1063         struct local_zone *result;
1064         struct local_zone key;
1065         int m;
1066         key.node.key = &key;
1067         key.dclass = dclass;
1068         key.name = name;
1069         key.namelen = len;
1070         key.namelabs = labs;
1071         rbtree_find_less_equal(&zones->ztree, &key, &res);
1072         result = (struct local_zone*)res;
1073         /* exact or smaller element (or no element) */
1074         if(!result || result->dclass != dclass)
1075                 return NULL;
1076         /* count number of labels matched */
1077         (void)dname_lab_cmp(result->name, result->namelabs, key.name,
1078                 key.namelabs, &m);
1079         while(result) { /* go up until qname is zone or subdomain of zone */
1080                 if(result->namelabs <= m)
1081                         if(ignoretags || !result->taglist ||
1082                                 taglist_intersect(result->taglist,
1083                                 result->taglen, taglist, taglen))
1084                                 break;
1085                 result = result->parent;
1086         }
1087         return result;
1088 }
1089
1090 struct local_zone*
1091 local_zones_find(struct local_zones* zones,
1092         uint8_t* name, size_t len, int labs, uint16_t dclass)
1093 {
1094         struct local_zone key;
1095         key.node.key = &key;
1096         key.dclass = dclass;
1097         key.name = name;
1098         key.namelen = len;
1099         key.namelabs = labs;
1100         /* exact */
1101         return (struct local_zone*)rbtree_search(&zones->ztree, &key);
1102 }
1103
1104 /** print all RRsets in local zone */
1105 static void
1106 local_zone_out(struct local_zone* z)
1107 {
1108         struct local_data* d;
1109         struct local_rrset* p;
1110         RBTREE_FOR(d, struct local_data*, &z->data) {
1111                 for(p = d->rrsets; p; p = p->next) {
1112                         log_nametypeclass(0, "rrset", d->name,
1113                                 ntohs(p->rrset->rk.type),
1114                                 ntohs(p->rrset->rk.rrset_class));
1115                 }
1116         }
1117 }
1118
1119 void local_zones_print(struct local_zones* zones)
1120 {
1121         struct local_zone* z;
1122         lock_rw_rdlock(&zones->lock);
1123         log_info("number of auth zones %u", (unsigned)zones->ztree.count);
1124         RBTREE_FOR(z, struct local_zone*, &zones->ztree) {
1125                 lock_rw_rdlock(&z->lock);
1126                 switch(z->type) {
1127                 case local_zone_deny:
1128                         log_nametypeclass(0, "deny zone",
1129                                 z->name, 0, z->dclass);
1130                         break;
1131                 case local_zone_refuse:
1132                         log_nametypeclass(0, "refuse zone",
1133                                 z->name, 0, z->dclass);
1134                         break;
1135                 case local_zone_redirect:
1136                         log_nametypeclass(0, "redirect zone",
1137                                 z->name, 0, z->dclass);
1138                         break;
1139                 case local_zone_transparent:
1140                         log_nametypeclass(0, "transparent zone",
1141                                 z->name, 0, z->dclass);
1142                         break;
1143                 case local_zone_typetransparent:
1144                         log_nametypeclass(0, "typetransparent zone",
1145                                 z->name, 0, z->dclass);
1146                         break;
1147                 case local_zone_static:
1148                         log_nametypeclass(0, "static zone",
1149                                 z->name, 0, z->dclass);
1150                         break;
1151                 case local_zone_inform:
1152                         log_nametypeclass(0, "inform zone",
1153                                 z->name, 0, z->dclass);
1154                         break;
1155                 case local_zone_inform_deny:
1156                         log_nametypeclass(0, "inform_deny zone",
1157                                 z->name, 0, z->dclass);
1158                         break;
1159                 case local_zone_always_transparent:
1160                         log_nametypeclass(0, "always_transparent zone",
1161                                 z->name, 0, z->dclass);
1162                         break;
1163                 case local_zone_always_refuse:
1164                         log_nametypeclass(0, "always_refuse zone",
1165                                 z->name, 0, z->dclass);
1166                         break;
1167                 case local_zone_always_nxdomain:
1168                         log_nametypeclass(0, "always_nxdomain zone",
1169                                 z->name, 0, z->dclass);
1170                         break;
1171                 default:
1172                         log_nametypeclass(0, "badtyped zone",
1173                                 z->name, 0, z->dclass);
1174                         break;
1175                 }
1176                 local_zone_out(z);
1177                 lock_rw_unlock(&z->lock);
1178         }
1179         lock_rw_unlock(&zones->lock);
1180 }
1181
1182 /** encode answer consisting of 1 rrset */
1183 static int
1184 local_encode(struct query_info* qinfo, struct module_env* env,
1185         struct edns_data* edns, sldns_buffer* buf, struct regional* temp,
1186         struct ub_packed_rrset_key* rrset, int ansec, int rcode)
1187 {
1188         struct reply_info rep;
1189         uint16_t udpsize;
1190         /* make answer with time=0 for fixed TTL values */
1191         memset(&rep, 0, sizeof(rep));
1192         rep.flags = (uint16_t)((BIT_QR | BIT_AA | BIT_RA) | rcode);
1193         rep.qdcount = 1;
1194         if(ansec)
1195                 rep.an_numrrsets = 1;
1196         else    rep.ns_numrrsets = 1;
1197         rep.rrset_count = 1;
1198         rep.rrsets = &rrset;
1199         udpsize = edns->udp_size;
1200         edns->edns_version = EDNS_ADVERTISED_VERSION;
1201         edns->udp_size = EDNS_ADVERTISED_SIZE;
1202         edns->ext_rcode = 0;
1203         edns->bits &= EDNS_DO;
1204         if(!inplace_cb_reply_local_call(env, qinfo, NULL, &rep, rcode, edns, temp)
1205                 || !reply_info_answer_encode(qinfo, &rep,
1206                 *(uint16_t*)sldns_buffer_begin(buf),
1207                 sldns_buffer_read_u16_at(buf, 2),
1208                 buf, 0, 0, temp, udpsize, edns,
1209                 (int)(edns->bits&EDNS_DO), 0))
1210                 error_encode(buf, (LDNS_RCODE_SERVFAIL|BIT_AA), qinfo,
1211                         *(uint16_t*)sldns_buffer_begin(buf),
1212                         sldns_buffer_read_u16_at(buf, 2), edns);
1213         return 1;
1214 }
1215
1216 /** encode local error answer */
1217 static void
1218 local_error_encode(struct query_info* qinfo, struct module_env* env,
1219         struct edns_data* edns, sldns_buffer* buf, struct regional* temp,
1220         int rcode, int r)
1221 {
1222         edns->edns_version = EDNS_ADVERTISED_VERSION;
1223         edns->udp_size = EDNS_ADVERTISED_SIZE;
1224         edns->ext_rcode = 0;
1225         edns->bits &= EDNS_DO;
1226
1227         if(!inplace_cb_reply_local_call(env, qinfo, NULL, NULL,
1228                 rcode, edns, temp))
1229                 edns->opt_list = NULL;
1230         error_encode(buf, r, qinfo, *(uint16_t*)sldns_buffer_begin(buf),
1231                 sldns_buffer_read_u16_at(buf, 2), edns);
1232 }
1233
1234 /** find local data tag string match for the given type in the list */
1235 int
1236 local_data_find_tag_datas(const struct query_info* qinfo,
1237         struct config_strlist* list, struct ub_packed_rrset_key* r,
1238         struct regional* temp)
1239 {
1240         struct config_strlist* p;
1241         char buf[65536];
1242         uint8_t rr[LDNS_RR_BUF_SIZE];
1243         size_t len;
1244         int res;
1245         struct packed_rrset_data* d;
1246         for(p=list; p; p=p->next) {
1247                 uint16_t rdr_type;
1248
1249                 len = sizeof(rr);
1250                 /* does this element match the type? */
1251                 snprintf(buf, sizeof(buf), ". %s", p->str);
1252                 res = sldns_str2wire_rr_buf(buf, rr, &len, NULL, 3600,
1253                         NULL, 0, NULL, 0);
1254                 if(res != 0)
1255                         /* parse errors are already checked before, in
1256                          * acllist check_data, skip this for robustness */
1257                         continue;
1258                 if(len < 1 /* . */ + 8 /* typeclassttl*/ + 2 /*rdatalen*/)
1259                         continue;
1260                 rdr_type = sldns_wirerr_get_type(rr, len, 1);
1261                 if(rdr_type != qinfo->qtype && rdr_type != LDNS_RR_TYPE_CNAME)
1262                         continue;
1263
1264                 /* do we have entries already? if not setup key */
1265                 if(r->rk.dname == NULL) {
1266                         r->entry.key = r;
1267                         r->rk.dname = qinfo->qname;
1268                         r->rk.dname_len = qinfo->qname_len;
1269                         r->rk.type = htons(rdr_type);
1270                         r->rk.rrset_class = htons(qinfo->qclass);
1271                         r->rk.flags = 0;
1272                         d = (struct packed_rrset_data*)regional_alloc_zero(
1273                                 temp, sizeof(struct packed_rrset_data)
1274                                 + sizeof(size_t) + sizeof(uint8_t*) +
1275                                 sizeof(time_t));
1276                         if(!d) return 0; /* out of memory */
1277                         r->entry.data = d;
1278                         d->ttl = sldns_wirerr_get_ttl(rr, len, 1);
1279                         d->rr_len = (size_t*)((uint8_t*)d +
1280                                 sizeof(struct packed_rrset_data));
1281                         d->rr_data = (uint8_t**)&(d->rr_len[1]);
1282                         d->rr_ttl = (time_t*)&(d->rr_data[1]);
1283                 }
1284                 d = (struct packed_rrset_data*)r->entry.data;
1285                 /* add entry to the data */
1286                 if(d->count != 0) {
1287                         size_t* oldlen = d->rr_len;
1288                         uint8_t** olddata = d->rr_data;
1289                         time_t* oldttl = d->rr_ttl;
1290                         /* increase arrays for lookup */
1291                         /* this is of course slow for very many records,
1292                          * but most redirects are expected with few records */
1293                         d->rr_len = (size_t*)regional_alloc_zero(temp,
1294                                 (d->count+1)*sizeof(size_t));
1295                         d->rr_data = (uint8_t**)regional_alloc_zero(temp,
1296                                 (d->count+1)*sizeof(uint8_t*));
1297                         d->rr_ttl = (time_t*)regional_alloc_zero(temp,
1298                                 (d->count+1)*sizeof(time_t));
1299                         if(!d->rr_len || !d->rr_data || !d->rr_ttl)
1300                                 return 0; /* out of memory */
1301                         /* first one was allocated after struct d, but new
1302                          * ones get their own array increment alloc, so
1303                          * copy old content */
1304                         memmove(d->rr_len, oldlen, d->count*sizeof(size_t));
1305                         memmove(d->rr_data, olddata, d->count*sizeof(uint8_t*));
1306                         memmove(d->rr_ttl, oldttl, d->count*sizeof(time_t));
1307                 }
1308
1309                 d->rr_len[d->count] = sldns_wirerr_get_rdatalen(rr, len, 1)+2;
1310                 d->rr_ttl[d->count] = sldns_wirerr_get_ttl(rr, len, 1);
1311                 d->rr_data[d->count] = regional_alloc_init(temp,
1312                         sldns_wirerr_get_rdatawl(rr, len, 1),
1313                         d->rr_len[d->count]);
1314                 if(!d->rr_data[d->count])
1315                         return 0; /* out of memory */
1316                 d->count++;
1317         }
1318         if(r->rk.dname)
1319                 return 1;
1320         return 0;
1321 }
1322
1323 static int
1324 find_tag_datas(struct query_info* qinfo, struct config_strlist* list,
1325         struct ub_packed_rrset_key* r, struct regional* temp)
1326 {
1327         int result = local_data_find_tag_datas(qinfo, list, r, temp);
1328
1329         /* If we've found a non-exact alias type of local data, make a shallow
1330          * copy of the RRset and remember it in qinfo to complete the alias
1331          * chain later. */
1332         if(result && qinfo->qtype != LDNS_RR_TYPE_CNAME &&
1333                 r->rk.type == htons(LDNS_RR_TYPE_CNAME)) {
1334                 qinfo->local_alias =
1335                         regional_alloc_zero(temp, sizeof(struct local_rrset));
1336                 if(!qinfo->local_alias)
1337                         return 0; /* out of memory */
1338                 qinfo->local_alias->rrset =
1339                         regional_alloc_init(temp, r, sizeof(*r));
1340                 if(!qinfo->local_alias->rrset)
1341                         return 0; /* out of memory */
1342         }
1343         return result;
1344 }
1345
1346 /** answer local data match */
1347 static int
1348 local_data_answer(struct local_zone* z, struct module_env* env,
1349         struct query_info* qinfo, struct edns_data* edns, sldns_buffer* buf,
1350         struct regional* temp, int labs, struct local_data** ldp,
1351         enum localzone_type lz_type, int tag, struct config_strlist** tag_datas,
1352         size_t tag_datas_size, char** tagname, int num_tags)
1353 {
1354         struct local_data key;
1355         struct local_data* ld;
1356         struct local_rrset* lr;
1357         key.node.key = &key;
1358         key.name = qinfo->qname;
1359         key.namelen = qinfo->qname_len;
1360         key.namelabs = labs;
1361         if(lz_type == local_zone_redirect) {
1362                 key.name = z->name;
1363                 key.namelen = z->namelen;
1364                 key.namelabs = z->namelabs;
1365                 if(tag != -1 && (size_t)tag<tag_datas_size && tag_datas[tag]) {
1366                         struct ub_packed_rrset_key r;
1367                         memset(&r, 0, sizeof(r));
1368                         if(find_tag_datas(qinfo, tag_datas[tag], &r, temp)) {
1369                                 verbose(VERB_ALGO, "redirect with tag data [%d] %s",
1370                                         tag, (tag<num_tags?tagname[tag]:"null"));
1371
1372                                 /* If we found a matching alias, we should
1373                                  * use it as part of the answer, but we can't
1374                                  * encode it until we complete the alias
1375                                  * chain. */
1376                                 if(qinfo->local_alias)
1377                                         return 1;
1378                                 return local_encode(qinfo, env, edns, buf, temp,
1379                                         &r, 1, LDNS_RCODE_NOERROR);
1380                         }
1381                 }
1382         }
1383         ld = (struct local_data*)rbtree_search(&z->data, &key.node);
1384         *ldp = ld;
1385         if(!ld) {
1386                 return 0;
1387         }
1388         lr = local_data_find_type(ld, qinfo->qtype, 1);
1389         if(!lr)
1390                 return 0;
1391
1392         /* Special case for alias matching.  See local_data_answer(). */
1393         if(lz_type == local_zone_redirect &&
1394                 qinfo->qtype != LDNS_RR_TYPE_CNAME &&
1395                 lr->rrset->rk.type == htons(LDNS_RR_TYPE_CNAME)) {
1396                 qinfo->local_alias =
1397                         regional_alloc_zero(temp, sizeof(struct local_rrset));
1398                 if(!qinfo->local_alias)
1399                         return 0; /* out of memory */
1400                 qinfo->local_alias->rrset =
1401                         regional_alloc_init(temp, lr->rrset, sizeof(*lr->rrset));
1402                 if(!qinfo->local_alias->rrset)
1403                         return 0; /* out of memory */
1404                 qinfo->local_alias->rrset->rk.dname = qinfo->qname;
1405                 qinfo->local_alias->rrset->rk.dname_len = qinfo->qname_len;
1406                 return 1;
1407         }
1408         if(lz_type == local_zone_redirect) {
1409                 /* convert rrset name to query name; like a wildcard */
1410                 struct ub_packed_rrset_key r = *lr->rrset;
1411                 r.rk.dname = qinfo->qname;
1412                 r.rk.dname_len = qinfo->qname_len;
1413                 return local_encode(qinfo, env, edns, buf, temp, &r, 1,
1414                         LDNS_RCODE_NOERROR);
1415         }
1416         return local_encode(qinfo, env, edns, buf, temp, lr->rrset, 1,
1417                 LDNS_RCODE_NOERROR);
1418 }
1419
1420 /**
1421  * answer in case where no exact match is found
1422  * @param z: zone for query
1423  * @param env: module environment
1424  * @param qinfo: query
1425  * @param edns: edns from query
1426  * @param buf: buffer for answer.
1427  * @param temp: temp region for encoding
1428  * @param ld: local data, if NULL, no such name exists in localdata.
1429  * @param lz_type: type of the local zone
1430  * @return 1 if a reply is to be sent, 0 if not.
1431  */
1432 static int
1433 lz_zone_answer(struct local_zone* z, struct module_env* env,
1434         struct query_info* qinfo, struct edns_data* edns, sldns_buffer* buf,
1435         struct regional* temp, struct local_data* ld, enum localzone_type lz_type)
1436 {
1437         if(lz_type == local_zone_deny || lz_type == local_zone_inform_deny) {
1438                 /** no reply at all, signal caller by clearing buffer. */
1439                 sldns_buffer_clear(buf);
1440                 sldns_buffer_flip(buf);
1441                 return 1;
1442         } else if(lz_type == local_zone_refuse
1443                 || lz_type == local_zone_always_refuse) {
1444                 local_error_encode(qinfo, env, edns, buf, temp,
1445                         LDNS_RCODE_REFUSED, (LDNS_RCODE_REFUSED|BIT_AA));
1446                 return 1;
1447         } else if(lz_type == local_zone_static ||
1448                 lz_type == local_zone_redirect ||
1449                 lz_type == local_zone_always_nxdomain) {
1450                 /* for static, reply nodata or nxdomain
1451                  * for redirect, reply nodata */
1452                 /* no additional section processing,
1453                  * cname, dname or wildcard processing,
1454                  * or using closest match for NSEC.
1455                  * or using closest match for returning delegation downwards
1456                  */
1457                 int rcode = (ld || lz_type == local_zone_redirect)?
1458                         LDNS_RCODE_NOERROR:LDNS_RCODE_NXDOMAIN;
1459                 if(z->soa)
1460                         return local_encode(qinfo, env, edns, buf, temp,
1461                                 z->soa, 0, rcode);
1462                 local_error_encode(qinfo, env, edns, buf, temp, rcode,
1463                         (rcode|BIT_AA));
1464                 return 1;
1465         } else if(lz_type == local_zone_typetransparent
1466                 || lz_type == local_zone_always_transparent) {
1467                 /* no NODATA or NXDOMAINS for this zone type */
1468                 return 0;
1469         }
1470         /* else lz_type == local_zone_transparent */
1471
1472         /* if the zone is transparent and the name exists, but the type
1473          * does not, then we should make this noerror/nodata */
1474         if(ld && ld->rrsets) {
1475                 int rcode = LDNS_RCODE_NOERROR;
1476                 if(z->soa)
1477                         return local_encode(qinfo, env, edns, buf, temp,
1478                                 z->soa, 0, rcode);
1479                 local_error_encode(qinfo, env, edns, buf, temp, rcode,
1480                         (rcode|BIT_AA));
1481                 return 1;
1482         }
1483
1484         /* stop here, and resolve further on */
1485         return 0;
1486 }
1487
1488 /** print log information for an inform zone query */
1489 static void
1490 lz_inform_print(struct local_zone* z, struct query_info* qinfo,
1491         struct comm_reply* repinfo)
1492 {
1493         char ip[128], txt[512];
1494         char zname[LDNS_MAX_DOMAINLEN+1];
1495         uint16_t port = ntohs(((struct sockaddr_in*)&repinfo->addr)->sin_port);
1496         dname_str(z->name, zname);
1497         addr_to_str(&repinfo->addr, repinfo->addrlen, ip, sizeof(ip));
1498         snprintf(txt, sizeof(txt), "%s inform %s@%u", zname, ip,
1499                 (unsigned)port);
1500         log_nametypeclass(0, txt, qinfo->qname, qinfo->qtype, qinfo->qclass);
1501 }
1502
1503 static enum localzone_type
1504 lz_type(uint8_t *taglist, size_t taglen, uint8_t *taglist2, size_t taglen2,
1505         uint8_t *tagactions, size_t tagactionssize, enum localzone_type lzt,
1506         struct comm_reply* repinfo, struct rbtree_type* override_tree,
1507         int* tag, char** tagname, int num_tags)
1508 {
1509         struct local_zone_override* lzo;
1510         if(repinfo && override_tree) {
1511                 lzo = (struct local_zone_override*)addr_tree_lookup(
1512                         override_tree, &repinfo->addr, repinfo->addrlen);
1513                 if(lzo && lzo->type) {
1514                         verbose(VERB_ALGO, "local zone override to type %s",
1515                                 local_zone_type2str(lzo->type));
1516                         return lzo->type;
1517                 }
1518         }
1519         if(!taglist || !taglist2)
1520                 return lzt;
1521         return local_data_find_tag_action(taglist, taglen, taglist2, taglen2,
1522                 tagactions, tagactionssize, lzt, tag, tagname, num_tags);
1523 }
1524
1525 enum localzone_type
1526 local_data_find_tag_action(const uint8_t* taglist, size_t taglen,
1527         const uint8_t* taglist2, size_t taglen2, const uint8_t* tagactions,
1528         size_t tagactionssize, enum localzone_type lzt, int* tag,
1529         char* const* tagname, int num_tags)
1530 {
1531         size_t i, j;
1532         uint8_t tagmatch;
1533
1534         for(i=0; i<taglen && i<taglen2; i++) {
1535                 tagmatch = (taglist[i] & taglist2[i]);
1536                 for(j=0; j<8 && tagmatch>0; j++) {
1537                         if((tagmatch & 0x1)) {
1538                                 *tag = (int)(i*8+j);
1539                                 verbose(VERB_ALGO, "matched tag [%d] %s",
1540                                         *tag, (*tag<num_tags?tagname[*tag]:"null"));
1541                                 /* does this tag have a tag action? */
1542                                 if(i*8+j < tagactionssize && tagactions
1543                                    && tagactions[i*8+j] != 0) {
1544                                   verbose(VERB_ALGO, "tag action [%d] %s to type %s",
1545                                         *tag, (*tag<num_tags?tagname[*tag]:"null"),
1546                                         local_zone_type2str(
1547                                         (enum localzone_type)
1548                                         tagactions[i*8+j]));
1549                                   return (enum localzone_type)tagactions[i*8+j];
1550                                 }
1551                                 return lzt;
1552                         }
1553                         tagmatch >>= 1;
1554                 }
1555         }
1556         return lzt;
1557 }
1558
1559 int
1560 local_zones_answer(struct local_zones* zones, struct module_env* env,
1561         struct query_info* qinfo, struct edns_data* edns, sldns_buffer* buf,
1562         struct regional* temp, struct comm_reply* repinfo, uint8_t* taglist,
1563         size_t taglen, uint8_t* tagactions, size_t tagactionssize,
1564         struct config_strlist** tag_datas, size_t tag_datas_size,
1565         char** tagname, int num_tags, struct view* view)
1566 {
1567         /* see if query is covered by a zone,
1568          *      if so:  - try to match (exact) local data
1569          *              - look at zone type for negative response. */
1570         int labs = dname_count_labels(qinfo->qname);
1571         struct local_data* ld = NULL;
1572         struct local_zone* z = NULL;
1573         enum localzone_type lzt = local_zone_transparent;
1574         int r, tag = -1;
1575
1576         if(view) {
1577                 lock_rw_rdlock(&view->lock);
1578                 if(view->local_zones &&
1579                         (z = local_zones_lookup(view->local_zones,
1580                         qinfo->qname, qinfo->qname_len, labs,
1581                         qinfo->qclass))) {
1582                         verbose(VERB_ALGO,
1583                                 "using localzone from view: %s",
1584                                 view->name);
1585                         lock_rw_rdlock(&z->lock);
1586                         lzt = z->type;
1587                 }
1588                 if(!z && !view->isfirst){
1589                         lock_rw_unlock(&view->lock);
1590                         return 0;
1591                 }
1592                 lock_rw_unlock(&view->lock);
1593         }
1594         if(!z) {
1595                 /* try global local_zones tree */
1596                 lock_rw_rdlock(&zones->lock);
1597                 if(!(z = local_zones_tags_lookup(zones, qinfo->qname,
1598                         qinfo->qname_len, labs, qinfo->qclass, taglist,
1599                         taglen, 0))) {
1600                         lock_rw_unlock(&zones->lock);
1601                         return 0;
1602                 }
1603                 lock_rw_rdlock(&z->lock);
1604
1605                 lzt = lz_type(taglist, taglen, z->taglist, z->taglen,
1606                         tagactions, tagactionssize, z->type, repinfo,
1607                         z->override_tree, &tag, tagname, num_tags);
1608                 lock_rw_unlock(&zones->lock);
1609         }
1610         if((lzt == local_zone_inform || lzt == local_zone_inform_deny)
1611                 && repinfo)
1612                 lz_inform_print(z, qinfo, repinfo);
1613
1614         if(lzt != local_zone_always_refuse
1615                 && lzt != local_zone_always_transparent
1616                 && lzt != local_zone_always_nxdomain
1617                 && local_data_answer(z, env, qinfo, edns, buf, temp, labs, &ld, lzt,
1618                         tag, tag_datas, tag_datas_size, tagname, num_tags)) {
1619                 lock_rw_unlock(&z->lock);
1620                 /* We should tell the caller that encode is deferred if we found
1621                  * a local alias. */
1622                 return !qinfo->local_alias;
1623         }
1624         r = lz_zone_answer(z, env, qinfo, edns, buf, temp, ld, lzt);
1625         lock_rw_unlock(&z->lock);
1626         return r && !qinfo->local_alias; /* see above */
1627 }
1628
1629 const char* local_zone_type2str(enum localzone_type t)
1630 {
1631         switch(t) {
1632                 case local_zone_unset: return "unset";
1633                 case local_zone_deny: return "deny";
1634                 case local_zone_refuse: return "refuse";
1635                 case local_zone_redirect: return "redirect";
1636                 case local_zone_transparent: return "transparent";
1637                 case local_zone_typetransparent: return "typetransparent";
1638                 case local_zone_static: return "static";
1639                 case local_zone_nodefault: return "nodefault";
1640                 case local_zone_inform: return "inform";
1641                 case local_zone_inform_deny: return "inform_deny";
1642                 case local_zone_always_transparent: return "always_transparent";
1643                 case local_zone_always_refuse: return "always_refuse";
1644                 case local_zone_always_nxdomain: return "always_nxdomain";
1645         }
1646         return "badtyped";
1647 }
1648
1649 int local_zone_str2type(const char* type, enum localzone_type* t)
1650 {
1651         if(strcmp(type, "deny") == 0)
1652                 *t = local_zone_deny;
1653         else if(strcmp(type, "refuse") == 0)
1654                 *t = local_zone_refuse;
1655         else if(strcmp(type, "static") == 0)
1656                 *t = local_zone_static;
1657         else if(strcmp(type, "transparent") == 0)
1658                 *t = local_zone_transparent;
1659         else if(strcmp(type, "typetransparent") == 0)
1660                 *t = local_zone_typetransparent;
1661         else if(strcmp(type, "redirect") == 0)
1662                 *t = local_zone_redirect;
1663         else if(strcmp(type, "inform") == 0)
1664                 *t = local_zone_inform;
1665         else if(strcmp(type, "inform_deny") == 0)
1666                 *t = local_zone_inform_deny;
1667         else if(strcmp(type, "always_transparent") == 0)
1668                 *t = local_zone_always_transparent;
1669         else if(strcmp(type, "always_refuse") == 0)
1670                 *t = local_zone_always_refuse;
1671         else if(strcmp(type, "always_nxdomain") == 0)
1672                 *t = local_zone_always_nxdomain;
1673         else return 0;
1674         return 1;
1675 }
1676
1677 /** iterate over the kiddies of the given name and set their parent ptr */
1678 static void
1679 set_kiddo_parents(struct local_zone* z, struct local_zone* match,
1680         struct local_zone* newp)
1681 {
1682         /* both zones and z are locked already */
1683         /* in the sorted rbtree, the kiddies of z are located after z */
1684         /* z must be present in the tree */
1685         struct local_zone* p = z;
1686         p = (struct local_zone*)rbtree_next(&p->node);
1687         while(p!=(struct local_zone*)RBTREE_NULL &&
1688                 p->dclass == z->dclass && dname_strict_subdomain(p->name,
1689                 p->namelabs, z->name, z->namelabs)) {
1690                 /* update parent ptr */
1691                 /* only when matches with existing parent pointer, so that
1692                  * deeper child structures are not touched, i.e.
1693                  * update of x, and a.x, b.x, f.b.x, g.b.x, c.x, y
1694                  * gets to update a.x, b.x and c.x */
1695                 lock_rw_wrlock(&p->lock);
1696                 if(p->parent == match)
1697                         p->parent = newp;
1698                 lock_rw_unlock(&p->lock);
1699                 p = (struct local_zone*)rbtree_next(&p->node);
1700         }
1701 }
1702
1703 struct local_zone* local_zones_add_zone(struct local_zones* zones,
1704         uint8_t* name, size_t len, int labs, uint16_t dclass,
1705         enum localzone_type tp)
1706 {
1707         /* create */
1708         struct local_zone* z = local_zone_create(name, len, labs, tp, dclass);
1709         if(!z) {
1710                 free(name);
1711                 return NULL;
1712         }
1713         lock_rw_wrlock(&z->lock);
1714
1715         /* find the closest parent */
1716         z->parent = local_zones_find(zones, name, len, labs, dclass);
1717
1718         /* insert into the tree */
1719         if(!rbtree_insert(&zones->ztree, &z->node)) {
1720                 /* duplicate entry! */
1721                 lock_rw_unlock(&z->lock);
1722                 local_zone_delete(z);
1723                 log_err("internal: duplicate entry in local_zones_add_zone");
1724                 return NULL;
1725         }
1726
1727         /* set parent pointers right */
1728         set_kiddo_parents(z, z->parent, z);
1729
1730         lock_rw_unlock(&z->lock);
1731         return z;
1732 }
1733
1734 void local_zones_del_zone(struct local_zones* zones, struct local_zone* z)
1735 {
1736         /* fix up parents in tree */
1737         lock_rw_wrlock(&z->lock);
1738         set_kiddo_parents(z, z, z->parent);
1739
1740         /* remove from tree */
1741         (void)rbtree_delete(&zones->ztree, z);
1742
1743         /* delete the zone */
1744         lock_rw_unlock(&z->lock);
1745         local_zone_delete(z);
1746 }
1747
1748 int
1749 local_zones_add_RR(struct local_zones* zones, const char* rr)
1750 {
1751         uint8_t* rr_name;
1752         uint16_t rr_class;
1753         size_t len;
1754         int labs;
1755         struct local_zone* z;
1756         int r;
1757         if(!get_rr_nameclass(rr, &rr_name, &rr_class)) {
1758                 return 0;
1759         }
1760         labs = dname_count_size_labels(rr_name, &len);
1761         /* could first try readlock then get writelock if zone does not exist,
1762          * but we do not add enough RRs (from multiple threads) to optimize */
1763         lock_rw_wrlock(&zones->lock);
1764         z = local_zones_lookup(zones, rr_name, len, labs, rr_class);
1765         if(!z) {
1766                 z = local_zones_add_zone(zones, rr_name, len, labs, rr_class,
1767                         local_zone_transparent);
1768                 if(!z) {
1769                         lock_rw_unlock(&zones->lock);
1770                         return 0;
1771                 }
1772         } else {
1773                 free(rr_name);
1774         }
1775         lock_rw_wrlock(&z->lock);
1776         lock_rw_unlock(&zones->lock);
1777         r = lz_enter_rr_into_zone(z, rr);
1778         lock_rw_unlock(&z->lock);
1779         return r;
1780 }
1781
1782 /** returns true if the node is terminal so no deeper domain names exist */
1783 static int
1784 is_terminal(struct local_data* d)
1785 {
1786         /* for empty nonterminals, the deeper domain names are sorted
1787          * right after them, so simply check the next name in the tree
1788          */
1789         struct local_data* n = (struct local_data*)rbtree_next(&d->node);
1790         if(n == (struct local_data*)RBTREE_NULL)
1791                 return 1; /* last in tree, no deeper node */
1792         if(dname_strict_subdomain(n->name, n->namelabs, d->name, d->namelabs))
1793                 return 0; /* there is a deeper node */
1794         return 1;
1795 }
1796
1797 /** delete empty terminals from tree when final data is deleted */
1798 static void
1799 del_empty_term(struct local_zone* z, struct local_data* d,
1800         uint8_t* name, size_t len, int labs)
1801 {
1802         while(d && d->rrsets == NULL && is_terminal(d)) {
1803                 /* is this empty nonterminal? delete */
1804                 /* note, no memory recycling in zone region */
1805                 (void)rbtree_delete(&z->data, d);
1806
1807                 /* go up and to the next label */
1808                 if(dname_is_root(name))
1809                         return;
1810                 dname_remove_label(&name, &len);
1811                 labs--;
1812                 d = lz_find_node(z, name, len, labs);
1813         }
1814 }
1815
1816 void local_zones_del_data(struct local_zones* zones,
1817         uint8_t* name, size_t len, int labs, uint16_t dclass)
1818 {
1819         /* find zone */
1820         struct local_zone* z;
1821         struct local_data* d;
1822         lock_rw_rdlock(&zones->lock);
1823         z = local_zones_lookup(zones, name, len, labs, dclass);
1824         if(!z) {
1825                 /* no such zone, we're done */
1826                 lock_rw_unlock(&zones->lock);
1827                 return;
1828         }
1829         lock_rw_wrlock(&z->lock);
1830         lock_rw_unlock(&zones->lock);
1831
1832         /* find the domain */
1833         d = lz_find_node(z, name, len, labs);
1834         if(d) {
1835                 /* no memory recycling for zone deletions ... */
1836                 d->rrsets = NULL;
1837                 /* did we delete the soa record ? */
1838                 if(query_dname_compare(d->name, z->name) == 0)
1839                         z->soa = NULL;
1840
1841                 /* cleanup the empty nonterminals for this name */
1842                 del_empty_term(z, d, name, len, labs);
1843         }
1844
1845         lock_rw_unlock(&z->lock);
1846 }