localzone.c revision 366095
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 "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" 54 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 58 59struct local_zones* 60local_zones_create(void) 61{ 62 struct local_zones* zones = (struct local_zones*)calloc(1, 63 sizeof(*zones)); 64 if(!zones) 65 return NULL; 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 */ 70 return zones; 71} 72 73/** helper traverse to delete zones */ 74static void 75lzdel(rbnode_type* n, void* ATTR_UNUSED(arg)) 76{ 77 struct local_zone* z = (struct local_zone*)n->key; 78 local_zone_delete(z); 79} 80 81void 82local_zones_delete(struct local_zones* zones) 83{ 84 if(!zones) 85 return; 86 lock_rw_destroy(&zones->lock); 87 /* walk through zones and delete them all */ 88 traverse_postorder(&zones->ztree, lzdel, NULL); 89 free(zones); 90} 91 92void 93local_zone_delete(struct local_zone* z) 94{ 95 if(!z) 96 return; 97 lock_rw_destroy(&z->lock); 98 regional_destroy(z->region); 99 free(z->name); 100 free(z->taglist); 101 free(z); 102} 103 104int 105local_zone_cmp(const void* z1, const void* z2) 106{ 107 /* first sort on class, so that hierarchy can be maintained within 108 * a class */ 109 struct local_zone* a = (struct local_zone*)z1; 110 struct local_zone* b = (struct local_zone*)z2; 111 int m; 112 if(a->dclass != b->dclass) { 113 if(a->dclass < b->dclass) 114 return -1; 115 return 1; 116 } 117 return dname_lab_cmp(a->name, a->namelabs, b->name, b->namelabs, &m); 118} 119 120int 121local_data_cmp(const void* d1, const void* d2) 122{ 123 struct local_data* a = (struct local_data*)d1; 124 struct local_data* b = (struct local_data*)d2; 125 int m; 126 return dname_canon_lab_cmp(a->name, a->namelabs, b->name, 127 b->namelabs, &m); 128} 129 130/* form wireformat from text format domain name */ 131int 132parse_dname(const char* str, uint8_t** res, size_t* len, int* labs) 133{ 134 *res = sldns_str2wire_dname(str, len); 135 *labs = 0; 136 if(!*res) { 137 log_err("cannot parse name %s", str); 138 return 0; 139 } 140 *labs = dname_count_size_labels(*res, len); 141 return 1; 142} 143 144/** create a new localzone */ 145static struct local_zone* 146local_zone_create(uint8_t* nm, size_t len, int labs, 147 enum localzone_type t, uint16_t dclass) 148{ 149 struct local_zone* z = (struct local_zone*)calloc(1, sizeof(*z)); 150 if(!z) { 151 return NULL; 152 } 153 z->node.key = z; 154 z->dclass = dclass; 155 z->type = t; 156 z->name = nm; 157 z->namelen = len; 158 z->namelabs = labs; 159 lock_rw_init(&z->lock); 160 z->region = regional_create_custom(sizeof(struct regional)); 161 if(!z->region) { 162 free(z); 163 return NULL; 164 } 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 */ 168 return z; 169} 170 171/** enter a new zone with allocated dname returns with WRlock */ 172static struct local_zone* 173lz_enter_zone_dname(struct local_zones* zones, uint8_t* nm, size_t len, 174 int labs, enum localzone_type t, uint16_t c) 175{ 176 struct local_zone* z = local_zone_create(nm, len, labs, t, c); 177 if(!z) { 178 free(nm); 179 log_err("out of memory"); 180 return NULL; 181 } 182 183 /* add to rbtree */ 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; 188 char str[256]; 189 dname_str(nm, str); 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. */ 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 */ 207static struct local_zone* 208lz_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 232int 233rrstr_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 */ 260static int 261get_rr_nameclass(const char* str, uint8_t** nm, uint16_t* dclass, 262 uint16_t* dtype) 263{ 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, 267 NULL, 0, NULL, 0); 268 if(s != 0) { 269 log_err("error parsing local-data at %d '%s': %s", 270 LDNS_WIREPARSE_OFFSET(s), str, 271 sldns_get_errorstr_parse(s)); 272 return 0; 273 } 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); 277 if(!*nm) { 278 log_err("out of memory"); 279 return 0; 280 } 281 return 1; 282} 283 284/** 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. 291 */ 292static struct local_rrset* 293local_data_find_type(struct local_data* data, uint16_t type, int alias_ok) 294{ 295 struct local_rrset* p; 296 type = htons(type); 297 for(p = data->rrsets; p; p = p->next) { 298 if(p->rrset->rk.type == type) 299 return p; 300 if(alias_ok && p->rrset->rk.type == htons(LDNS_RR_TYPE_CNAME)) 301 return p; 302 } 303 return NULL; 304} 305 306/** check for RR duplicates */ 307static int 308rr_is_duplicate(struct packed_rrset_data* pd, uint8_t* rdata, size_t rdata_len) 309{ 310 size_t i; 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) 314 return 1; 315 } 316 return 0; 317} 318 319/** new local_rrset */ 320static struct local_rrset* 321new_local_rrset(struct regional* region, struct local_data* node, 322 uint16_t rrtype, uint16_t rrclass) 323{ 324 struct packed_rrset_data* pd; 325 struct local_rrset* rrset = (struct local_rrset*) 326 regional_alloc_zero(region, sizeof(*rrset)); 327 if(!rrset) { 328 log_err("out of memory"); 329 return NULL; 330 } 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)); 335 if(!rrset->rrset) { 336 log_err("out of memory"); 337 return NULL; 338 } 339 rrset->rrset->entry.key = rrset->rrset; 340 pd = (struct packed_rrset_data*)regional_alloc_zero(region, 341 sizeof(*pd)); 342 if(!pd) { 343 log_err("out of memory"); 344 return NULL; 345 } 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); 353 return rrset; 354} 355 356/** insert RR into RRset data structure; Wastes a couple of bytes */ 357int 358rrset_insert_rr(struct regional* region, struct packed_rrset_data* pd, 359 uint8_t* rdata, size_t rdata_len, time_t ttl, const char* rrstr) 360{ 361 size_t* oldlen = pd->rr_len; 362 time_t* oldttl = pd->rr_ttl; 363 uint8_t** olddata = pd->rr_data; 364 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); 369 return 1; 370 } 371 pd->count++; 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"); 377 return 0; 378 } 379 if(pd->count > 1) { 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)); 386 } 387 pd->rr_len[0] = rdata_len; 388 pd->rr_ttl[0] = ttl; 389 pd->rr_data[0] = regional_alloc_init(region, rdata, rdata_len); 390 if(!pd->rr_data[0]) { 391 log_err("out of memory"); 392 return 0; 393 } 394 return 1; 395} 396 397/** Delete RR from local-zone RRset, wastes memory as the deleted RRs cannot be 398 * free'd (regionally alloc'd) */ 399int 400local_rrset_remove_rr(struct packed_rrset_data* pd, size_t index) 401{ 402 log_assert(pd->count > 0); 403 if(index >= pd->count) { 404 log_warn("Trying to remove RR with out of bound index"); 405 return 0; 406 } 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); 414 } 415 pd->count--; 416 return 1; 417} 418 419struct local_data* 420local_zone_find_data(struct local_zone* z, uint8_t* nm, size_t nmlen, int nmlabs) 421{ 422 struct local_data key; 423 key.node.key = &key; 424 key.name = nm; 425 key.namelen = nmlen; 426 key.namelabs = nmlabs; 427 return (struct local_data*)rbtree_search(&z->data, &key.node); 428} 429 430/** find a node, create it if not and all its empty nonterminal parents */ 431static int 432lz_find_create_node(struct local_zone* z, uint8_t* nm, size_t nmlen, 433 int nmlabs, struct local_data** res) 434{ 435 struct local_data* ld = local_zone_find_data(z, nm, nmlen, nmlabs); 436 if(!ld) { 437 /* create a domain name to store rr. */ 438 ld = (struct local_data*)regional_alloc_zero(z->region, 439 sizeof(*ld)); 440 if(!ld) { 441 log_err("out of memory adding local data"); 442 return 0; 443 } 444 ld->node.key = ld; 445 ld->name = regional_alloc_init(z->region, nm, nmlen); 446 if(!ld->name) { 447 log_err("out of memory"); 448 return 0; 449 } 450 ld->namelen = nmlen; 451 ld->namelabs = nmlabs; 452 if(!rbtree_insert(&z->data, &ld->node)) { 453 log_assert(0); /* duplicate name */ 454 } 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)) 459 return 0; 460 } 461 } 462 *res = ld; 463 return 1; 464} 465 466int 467local_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) 470{ 471 struct local_data* node; 472 struct local_rrset* rrset; 473 struct packed_rrset_data* pd; 474 475 if(!lz_find_create_node(z, nm, nmlen, nmlabs, &node)) { 476 return 0; 477 } 478 log_assert(node); 479 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) 486 othertype = "other"; 487 else if (node->rrsets->rrset->rk.type == 488 htons(LDNS_RR_TYPE_CNAME)) { 489 othertype = "CNAME"; 490 } 491 if(othertype) { 492 log_err("local-data '%s' in redirect zone must not " 493 "coexist with %s local-data", rrstr, othertype); 494 return 0; 495 } 496 } 497 rrset = local_data_find_type(node, rrtype, 0); 498 if(!rrset) { 499 rrset = new_local_rrset(z->region, node, rrtype, rrclass); 500 if(!rrset) 501 return 0; 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; 507 } 508 } 509 pd = (struct packed_rrset_data*)rrset->rrset->entry.data; 510 log_assert(rrset && pd); 511 512 /* check for duplicate RR */ 513 if(rr_is_duplicate(pd, rdata, rdata_len)) { 514 verbose(VERB_ALGO, "ignoring duplicate RR: %s", rrstr); 515 return 1; 516 } 517 return rrset_insert_rr(z->region, pd, rdata, rdata_len, ttl, rrstr); 518} 519 520/** enter data RR into auth zone */ 521static int 522lz_enter_rr_into_zone(struct local_zone* z, const char* rrstr) 523{ 524 uint8_t* nm; 525 size_t nmlen; 526 int nmlabs, ret; 527 uint16_t rrtype = 0, rrclass = 0; 528 time_t ttl = 0; 529 uint8_t rr[LDNS_RR_BUF_SIZE]; 530 uint8_t* rdata; 531 size_t rdata_len; 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); 535 return 0; 536 } 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); 543 free(nm); 544 return 0; 545 } 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); 549 free(nm); 550 return ret; 551} 552 553/** enter a data RR into auth data; a zone for it must exist */ 554static int 555lz_enter_rr_str(struct local_zones* zones, const char* rr) 556{ 557 uint8_t* rr_name; 558 uint16_t rr_class, rr_type; 559 size_t len; 560 int labs; 561 struct local_zone* z; 562 int r; 563 if(!get_rr_nameclass(rr, &rr_name, &rr_class, &rr_type)) { 564 log_err("bad rr %s", rr); 565 return 0; 566 } 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); 570 if(!z) { 571 lock_rw_unlock(&zones->lock); 572 fatal_exit("internal error: no zone for rr %s", rr); 573 } 574 lock_rw_wrlock(&z->lock); 575 lock_rw_unlock(&zones->lock); 576 free(rr_name); 577 r = lz_enter_rr_into_zone(z, rr); 578 lock_rw_unlock(&z->lock); 579 return r; 580} 581 582/** enter tagstring into zone */ 583static int 584lz_enter_zone_tag(struct local_zones* zones, char* zname, uint8_t* list, 585 size_t len, uint16_t rr_class) 586{ 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; 591 592 if(sldns_str2wire_dname_buf(zname, dname, &dname_len) != 0) { 593 log_err("cannot parse zone name in local-zone-tag: %s", zname); 594 return 0; 595 } 596 dname_labs = dname_count_labels(dname); 597 598 lock_rw_rdlock(&zones->lock); 599 z = local_zones_find(zones, dname, dname_len, dname_labs, rr_class); 600 if(!z) { 601 lock_rw_unlock(&zones->lock); 602 log_err("no local-zone for tag %s", zname); 603 return 0; 604 } 605 lock_rw_wrlock(&z->lock); 606 lock_rw_unlock(&zones->lock); 607 free(z->taglist); 608 z->taglist = memdup(list, len); 609 z->taglen = len; 610 if(z->taglist) 611 r = 1; 612 lock_rw_unlock(&z->lock); 613 return r; 614} 615 616/** enter override into zone */ 617static int 618lz_enter_override(struct local_zones* zones, char* zname, char* netblock, 619 char* type, uint16_t rr_class) 620{ 621 uint8_t dname[LDNS_MAX_DOMAINLEN+1]; 622 size_t dname_len = sizeof(dname); 623 int dname_labs; 624 struct sockaddr_storage addr; 625 int net; 626 socklen_t addrlen; 627 struct local_zone* z; 628 enum localzone_type t; 629 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", 633 zname, netblock); 634 return 0; 635 } 636 dname_labs = dname_count_labels(dname); 637 638 /* parse netblock */ 639 if(!netblockstrtoaddr(netblock, UNBOUND_DNS_PORT, &addr, &addrlen, 640 &net)) { 641 log_err("cannot parse netblock in local-zone-override: %s %s", 642 zname, netblock); 643 return 0; 644 } 645 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); 650 return 0; 651 } 652 653 /* find localzone entry */ 654 lock_rw_rdlock(&zones->lock); 655 z = local_zones_find(zones, dname, dname_len, dname_labs, rr_class); 656 if(!z) { 657 lock_rw_unlock(&zones->lock); 658 log_err("no local-zone for local-zone-override %s", zname); 659 return 0; 660 } 661 lock_rw_wrlock(&z->lock); 662 lock_rw_unlock(&zones->lock); 663 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"); 671 return 0; 672 } 673 addr_tree_init(z->override_tree); 674 } 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)); 680 if(!n) { 681 lock_rw_unlock(&z->lock); 682 log_err("out of memory"); 683 return 0; 684 } 685 n->type = t; 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", 690 zname, netblock); 691 return 1; 692 } 693 } 694 695 lock_rw_unlock(&z->lock); 696 return 1; 697} 698 699/** parse local-zone: statements */ 700static int 701lz_enter_zones(struct local_zones* zones, struct config_file* cfg) 702{ 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, 707 LDNS_RR_CLASS_IN))) 708 return 0; 709 lock_rw_unlock(&z->lock); 710 } 711 return 1; 712} 713 714/** lookup a zone in rbtree; exact match only; SLOW due to parse */ 715static int 716lz_exists(struct local_zones* zones, const char* name) 717{ 718 struct local_zone z; 719 z.node.key = &z; 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); 723 return 0; 724 } 725 lock_rw_rdlock(&zones->lock); 726 if(rbtree_search(&zones->ztree, &z.node)) { 727 lock_rw_unlock(&zones->lock); 728 free(z.name); 729 return 1; 730 } 731 lock_rw_unlock(&zones->lock); 732 free(z.name); 733 return 0; 734} 735 736/** lookup a zone in cfg->nodefault list */ 737static int 738lz_nodefault(struct config_file* cfg, const char* name) 739{ 740 struct config_strlist* p; 741 size_t len = strlen(name); 742 if(len == 0) return 0; 743 if(name[len-1] == '.') len--; 744 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] == '.'))) 750 return 1; 751 } 752 return 0; 753} 754 755/** enter (AS112) empty default zone */ 756static int 757add_empty_default(struct local_zones* zones, struct config_file* cfg, 758 const char* name) 759{ 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))) 765 return 0; 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); 770 return 0; 771 } 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); 775 return 0; 776 } 777 lock_rw_unlock(&z->lock); 778 return 1; 779} 780 781/** enter default zones */ 782int local_zone_enter_defaults(struct local_zones* zones, struct config_file* cfg) 783{ 784 struct local_zone* z; 785 const char** zstr; 786 787 /* Do not add any default */ 788 if(cfg->local_zones_disable_default) 789 return 1; 790 791 /* this list of zones is from RFC 6303 and RFC 7686 */ 792 793 /* block localhost level zones first, then onion and later the LAN zones */ 794 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); } 811 return 0; 812 } 813 lock_rw_unlock(&z->lock); 814 } 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); } 829 return 0; 830 } 831 lock_rw_unlock(&z->lock); 832 } 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); } 847 return 0; 848 } 849 lock_rw_unlock(&z->lock); 850 } 851 /* onion. zone (RFC 7686) */ 852 if(!add_empty_default(zones, cfg, "onion.")) { 853 log_err("out of memory adding default zone"); 854 return 0; 855 } 856 /* test. zone (RFC 6761) */ 857 if(!add_empty_default(zones, cfg, "test.")) { 858 log_err("out of memory adding default zone"); 859 return 0; 860 } 861 /* invalid. zone (RFC 6761) */ 862 if(!add_empty_default(zones, cfg, "invalid.")) { 863 log_err("out of memory adding default zone"); 864 return 0; 865 } 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"); 871 return 0; 872 } 873 } 874 } 875 return 1; 876} 877 878/** parse local-zone-override: statements */ 879static int 880lz_enter_overrides(struct local_zones* zones, struct config_file* cfg) 881{ 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, 885 LDNS_RR_CLASS_IN)) 886 return 0; 887 } 888 return 1; 889} 890 891/** setup parent pointers, so that a lookup can be done for closest match */ 892static void 893init_parents(struct local_zones* zones) 894{ 895 struct local_zone* node, *prev = NULL, *p; 896 int m; 897 lock_rw_wrlock(&zones->lock); 898 RBTREE_FOR(node, struct local_zone*, &zones->ztree) { 899 lock_rw_wrlock(&node->lock); 900 node->parent = NULL; 901 if(!prev || prev->dclass != node->dclass) { 902 prev = node; 903 lock_rw_unlock(&node->lock); 904 continue; 905 } 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 */ 916 node->parent = p; 917 break; 918 } 919 prev = node; 920 921 if(node->override_tree) 922 addr_tree_init_parents(node->override_tree); 923 lock_rw_unlock(&node->lock); 924 } 925 lock_rw_unlock(&zones->lock); 926} 927 928/** enter implicit transparent zone for local-data: without local-zone: */ 929static int 930lz_setup_implicit(struct local_zones* zones, struct config_file* cfg) 931{ 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; 936 int have_name = 0; 937 int have_other_classes = 0; 938 uint16_t dclass = 0; 939 uint8_t* nm = 0; 940 size_t nmlen = 0; 941 int nmlabs = 0; 942 int match = 0; /* number of labels match count */ 943 944 init_parents(zones); /* to enable local_zones_lookup() */ 945 for(p = cfg->local_data; p; p = p->next) { 946 uint8_t* rr_name; 947 uint16_t rr_class, rr_type; 948 size_t len; 949 int labs; 950 if(!get_rr_nameclass(p->str, &rr_name, &rr_class, &rr_type)) { 951 log_err("Bad local-data RR %s", p->str); 952 return 0; 953 } 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, 957 rr_type)) { 958 if(!have_name) { 959 dclass = rr_class; 960 nm = rr_name; 961 nmlen = len; 962 nmlabs = labs; 963 match = labs; 964 have_name = 1; 965 } else { 966 int m; 967 if(rr_class != dclass) { 968 /* process other classes later */ 969 free(rr_name); 970 have_other_classes = 1; 971 lock_rw_unlock(&zones->lock); 972 continue; 973 } 974 /* find smallest shared topdomain */ 975 (void)dname_lab_cmp(nm, nmlabs, 976 rr_name, labs, &m); 977 free(rr_name); 978 if(m < match) 979 match = m; 980 } 981 } else free(rr_name); 982 lock_rw_unlock(&zones->lock); 983 } 984 if(have_name) { 985 uint8_t* n2; 986 struct local_zone* z; 987 /* allocate zone of smallest shared topdomain to contain em */ 988 n2 = nm; 989 dname_remove_labels(&n2, &nmlen, nmlabs - match); 990 n2 = memdup(n2, nmlen); 991 free(nm); 992 if(!n2) { 993 log_err("out of memory"); 994 return 0; 995 } 996 log_nametypeclass(VERB_ALGO, "implicit transparent local-zone", 997 n2, 0, dclass); 998 if(!(z=lz_enter_zone_dname(zones, n2, nmlen, match, 999 local_zone_transparent, dclass))) { 1000 return 0; 1001 } 1002 lock_rw_unlock(&z->lock); 1003 } 1004 if(have_other_classes) { 1005 /* restart to setup other class */ 1006 return lz_setup_implicit(zones, cfg); 1007 } 1008 return 1; 1009} 1010 1011/** enter local-zone-tag info */ 1012static int 1013lz_enter_zone_tags(struct local_zones* zones, struct config_file* cfg) 1014{ 1015 struct config_strbytelist* p; 1016 int c = 0; 1017 for(p = cfg->local_zone_tags; p; p = p->next) { 1018 if(!lz_enter_zone_tag(zones, p->str, p->str2, p->str2len, 1019 LDNS_RR_CLASS_IN)) 1020 return 0; 1021 c++; 1022 } 1023 if(c) verbose(VERB_ALGO, "applied tags to %d local zones", c); 1024 return 1; 1025} 1026 1027/** enter auth data */ 1028static int 1029lz_enter_data(struct local_zones* zones, struct config_file* cfg) 1030{ 1031 struct config_strlist* p; 1032 for(p = cfg->local_data; p; p = p->next) { 1033 if(!lz_enter_rr_str(zones, p->str)) 1034 return 0; 1035 } 1036 return 1; 1037} 1038 1039/** free memory from config */ 1040static void 1041lz_freeup_cfg(struct config_file* cfg) 1042{ 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; 1049} 1050 1051int 1052local_zones_apply_cfg(struct local_zones* zones, struct config_file* cfg) 1053{ 1054 /* create zones from zone statements. */ 1055 if(!lz_enter_zones(zones, cfg)) { 1056 return 0; 1057 } 1058 /* apply default zones+content (unless disabled, or overridden) */ 1059 if(!local_zone_enter_defaults(zones, cfg)) { 1060 return 0; 1061 } 1062 /* enter local zone overrides */ 1063 if(!lz_enter_overrides(zones, cfg)) { 1064 return 0; 1065 } 1066 /* create implicit transparent zone from data. */ 1067 if(!lz_setup_implicit(zones, cfg)) { 1068 return 0; 1069 } 1070 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)) { 1075 return 0; 1076 } 1077 /* insert local data */ 1078 if(!lz_enter_data(zones, cfg)) { 1079 return 0; 1080 } 1081 /* freeup memory from cfg struct. */ 1082 lz_freeup_cfg(cfg); 1083 return 1; 1084} 1085 1086struct local_zone* 1087local_zones_lookup(struct local_zones* zones, 1088 uint8_t* name, size_t len, int labs, uint16_t dclass, uint16_t dtype) 1089{ 1090 return local_zones_tags_lookup(zones, name, len, labs, 1091 dclass, dtype, NULL, 0, 1); 1092} 1093 1094struct local_zone* 1095local_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) 1098{ 1099 rbnode_type* res = NULL; 1100 struct local_zone *result; 1101 struct local_zone key; 1102 int m; 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); 1106 labs--; 1107 } 1108 key.node.key = &key; 1109 key.dclass = dclass; 1110 key.name = name; 1111 key.namelen = len; 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) 1117 return NULL; 1118 /* count number of labels matched */ 1119 (void)dname_lab_cmp(result->name, result->namelabs, key.name, 1120 key.namelabs, &m); 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)) 1126 break; 1127 result = result->parent; 1128 } 1129 return result; 1130} 1131 1132struct local_zone* 1133local_zones_find(struct local_zones* zones, 1134 uint8_t* name, size_t len, int labs, uint16_t dclass) 1135{ 1136 struct local_zone key; 1137 key.node.key = &key; 1138 key.dclass = dclass; 1139 key.name = name; 1140 key.namelen = len; 1141 key.namelabs = labs; 1142 /* exact */ 1143 return (struct local_zone*)rbtree_search(&zones->ztree, &key); 1144} 1145 1146struct local_zone* 1147local_zones_find_le(struct local_zones* zones, 1148 uint8_t* name, size_t len, int labs, uint16_t dclass, 1149 int* exact) 1150{ 1151 struct local_zone key; 1152 rbnode_type *node; 1153 key.node.key = &key; 1154 key.dclass = dclass; 1155 key.name = name; 1156 key.namelen = len; 1157 key.namelabs = labs; 1158 *exact = rbtree_find_less_equal(&zones->ztree, &key, &node); 1159 return (struct local_zone*)node; 1160} 1161 1162/** print all RRsets in local zone */ 1163static void 1164local_zone_out(struct local_zone* z) 1165{ 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)); 1173 } 1174 } 1175} 1176 1177void local_zones_print(struct local_zones* zones) 1178{ 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) { 1183 char buf[64]; 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); 1188 local_zone_out(z); 1189 lock_rw_unlock(&z->lock); 1190 } 1191 lock_rw_unlock(&zones->lock); 1192} 1193 1194/** encode answer consisting of 1 rrset */ 1195static int 1196local_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, 1199 int rcode) 1200{ 1201 struct reply_info rep; 1202 uint16_t udpsize; 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); 1206 rep.qdcount = 1; 1207 if(ansec) 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); 1224 } 1225 return 1; 1226} 1227 1228/** encode local error answer */ 1229static void 1230local_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) 1233{ 1234 edns->edns_version = EDNS_ADVERTISED_VERSION; 1235 edns->udp_size = EDNS_ADVERTISED_SIZE; 1236 edns->ext_rcode = 0; 1237 edns->bits &= EDNS_DO; 1238 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); 1244} 1245 1246/** find local data tag string match for the given type in the list */ 1247int 1248local_data_find_tag_datas(const struct query_info* qinfo, 1249 struct config_strlist* list, struct ub_packed_rrset_key* r, 1250 struct regional* temp) 1251{ 1252 struct config_strlist* p; 1253 char buf[65536]; 1254 uint8_t rr[LDNS_RR_BUF_SIZE]; 1255 size_t len; 1256 int res; 1257 struct packed_rrset_data* d; 1258 for(p=list; p; p=p->next) { 1259 uint16_t rdr_type; 1260 1261 len = sizeof(rr); 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, 1265 NULL, 0, NULL, 0); 1266 if(res != 0) 1267 /* parse errors are already checked before, in 1268 * acllist check_data, skip this for robustness */ 1269 continue; 1270 if(len < 1 /* . */ + 8 /* typeclassttl*/ + 2 /*rdatalen*/) 1271 continue; 1272 rdr_type = sldns_wirerr_get_type(rr, len, 1); 1273 if(rdr_type != qinfo->qtype && rdr_type != LDNS_RR_TYPE_CNAME) 1274 continue; 1275 1276 /* do we have entries already? if not setup key */ 1277 if(r->rk.dname == NULL) { 1278 r->entry.key = r; 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); 1283 r->rk.flags = 0; 1284 d = (struct packed_rrset_data*)regional_alloc_zero( 1285 temp, sizeof(struct packed_rrset_data) 1286 + sizeof(size_t) + sizeof(uint8_t*) + 1287 sizeof(time_t)); 1288 if(!d) return 0; /* out of memory */ 1289 r->entry.data = d; 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]); 1295 } 1296 d = (struct packed_rrset_data*)r->entry.data; 1297 /* add entry to the data */ 1298 if(d->count != 0) { 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)); 1319 } 1320 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 */ 1328 d->count++; 1329 } 1330 if(r->rk.dname) 1331 return 1; 1332 return 0; 1333} 1334 1335static int 1336find_tag_datas(struct query_info* qinfo, struct config_strlist* list, 1337 struct ub_packed_rrset_key* r, struct regional* temp) 1338{ 1339 int result = local_data_find_tag_datas(qinfo, list, r, temp); 1340 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 1343 * chain later. */ 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 */ 1354 } 1355 return result; 1356} 1357 1358int 1359local_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) 1365{ 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) { 1375 key.name = z->name; 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")); 1384 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 1388 * chain. */ 1389 if(qinfo->local_alias) 1390 return 1; 1391 return local_encode(qinfo, env, edns, repinfo, buf, temp, 1392 &r, 1, LDNS_RCODE_NOERROR); 1393 } 1394 } 1395 } 1396 ld = (struct local_data*)rbtree_search(&z->data, &key.node); 1397 *ldp = ld; 1398 if(!ld) { 1399 return 0; 1400 } 1401 lr = local_data_find_type(ld, qinfo->qtype, 1); 1402 if(!lr) 1403 return 0; 1404 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)) { 1410 uint8_t* ctarget; 1411 size_t ctargetlen = 0; 1412 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); 1424 if(!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; 1431 1432 log_assert(ctargetlen >= 3); 1433 log_assert(qinfo->qname_len >= 1); 1434 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)); 1440 return 1; 1441 } 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) 1451 + newtargetlen); 1452 if(!d) 1453 return 0; /* out of memory */ 1454 qinfo->local_alias->rrset->entry.data = d; 1455 d->ttl = 0; /* 0 for synthesized CNAME TTL */ 1456 d->count = 1; 1457 d->rrsig_count = 0; 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); 1465 /* write qname */ 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, 1471 ctargetlen - 2); 1472 } 1473 return 1; 1474 } 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); 1483 } 1484 return local_encode(qinfo, env, edns, repinfo, buf, temp, lr->rrset, 1, 1485 LDNS_RCODE_NOERROR); 1486} 1487 1488/** 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 */ 1491static int 1492local_zone_does_not_cover(struct local_zone* z, struct query_info* qinfo, 1493 int labs) 1494{ 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) 1499 return 1; 1500 if(z->type != local_zone_transparent 1501 && z->type != local_zone_typetransparent 1502 && z->type != local_zone_inform) 1503 return 0; 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); 1511 if(ld) 1512 lr = local_data_find_type(ld, qinfo->qtype, 1); 1513 /* local_zone_typetransparent */ 1514 return (lr == NULL); 1515} 1516 1517int 1518local_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) 1522{ 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); 1529 return 1; 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)); 1534 return 1; 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 1546 */ 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; 1551 if(z->soa) 1552 return local_encode(qinfo, env, edns, repinfo, buf, temp, 1553 z->soa, 0, rcode); 1554 local_error_encode(qinfo, env, edns, repinfo, buf, temp, rcode, 1555 (rcode|BIT_AA)); 1556 return 1; 1557 } else if(lz_type == local_zone_typetransparent 1558 || lz_type == local_zone_always_transparent) { 1559 /* no NODATA or NXDOMAINS for this zone type */ 1560 return 0; 1561 } 1562 /* else lz_type == local_zone_transparent */ 1563 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; 1568 if(z->soa) 1569 return local_encode(qinfo, env, edns, repinfo, buf, temp, 1570 z->soa, 0, rcode); 1571 local_error_encode(qinfo, env, edns, repinfo, buf, temp, rcode, 1572 (rcode|BIT_AA)); 1573 return 1; 1574 } 1575 1576 /* stop here, and resolve further on */ 1577 return 0; 1578} 1579 1580/** print log information for an inform zone query */ 1581static void 1582lz_inform_print(struct local_zone* z, struct query_info* qinfo, 1583 struct comm_reply* repinfo) 1584{ 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, 1591 (unsigned)port); 1592 log_nametypeclass(NO_VERBOSE, txt, qinfo->qname, qinfo->qtype, qinfo->qclass); 1593} 1594 1595static enum localzone_type 1596lz_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) 1600{ 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)); 1608 return lzo->type; 1609 } 1610 } 1611 if(!taglist || !taglist2) 1612 return lzt; 1613 return local_data_find_tag_action(taglist, taglen, taglist2, taglen2, 1614 tagactions, tagactionssize, lzt, tag, tagname, num_tags); 1615} 1616 1617enum localzone_type 1618local_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) 1622{ 1623 size_t i, j; 1624 uint8_t tagmatch; 1625 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]; 1642 } 1643 return lzt; 1644 } 1645 tagmatch >>= 1; 1646 } 1647 } 1648 return lzt; 1649} 1650 1651int 1652local_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) 1658{ 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; 1666 int r, tag = -1; 1667 1668 if(view) { 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); 1675 lzt = z->type; 1676 } 1677 if(lzt == local_zone_noview) { 1678 lock_rw_unlock(&z->lock); 1679 z = NULL; 1680 } 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); 1687 z = NULL; 1688 } 1689 if(view->local_zones && !z && !view->isfirst){ 1690 lock_rw_unlock(&view->lock); 1691 return 0; 1692 } 1693 if(z && verbosity >= VERB_ALGO) { 1694 char zname[255+1]; 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); 1698 } 1699 lock_rw_unlock(&view->lock); 1700 } 1701 if(!z) { 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); 1708 return 0; 1709 } 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) { 1716 char zname[255+1]; 1717 dname_str(z->name, zname); 1718 verbose(VERB_ALGO, "using localzone %s %s", zname, 1719 local_zone_type2str(lzt)); 1720 } 1721 } 1722 if((env->cfg->log_local_actions || 1723 lzt == local_zone_inform || 1724 lzt == local_zone_inform_deny || 1725 lzt == local_zone_inform_redirect) 1726 && repinfo) 1727 lz_inform_print(z, qinfo, repinfo); 1728 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 1738 * a local alias. */ 1739 return !qinfo->local_alias; 1740 } 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 */ 1744} 1745 1746const char* local_zone_type2str(enum localzone_type t) 1747{ 1748 switch(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"; 1767 } 1768 return "badtyped"; 1769} 1770 1771int local_zone_str2type(const char* type, enum localzone_type* t) 1772{ 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; 1805 else return 0; 1806 return 1; 1807} 1808 1809/** iterate over the kiddies of the given name and set their parent ptr */ 1810static void 1811set_kiddo_parents(struct local_zone* z, struct local_zone* match, 1812 struct local_zone* newp) 1813{ 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) 1829 p->parent = newp; 1830 lock_rw_unlock(&p->lock); 1831 p = (struct local_zone*)rbtree_next(&p->node); 1832 } 1833} 1834 1835struct 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) 1838{ 1839 /* create */ 1840 struct local_zone* z = local_zone_create(name, len, labs, tp, dclass); 1841 if(!z) { 1842 free(name); 1843 return NULL; 1844 } 1845 lock_rw_wrlock(&z->lock); 1846 1847 /* find the closest parent */ 1848 z->parent = local_zones_find(zones, name, len, labs, dclass); 1849 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"); 1856 return NULL; 1857 } 1858 1859 /* set parent pointers right */ 1860 set_kiddo_parents(z, z->parent, z); 1861 1862 lock_rw_unlock(&z->lock); 1863 return z; 1864} 1865 1866void local_zones_del_zone(struct local_zones* zones, struct local_zone* z) 1867{ 1868 /* fix up parents in tree */ 1869 lock_rw_wrlock(&z->lock); 1870 set_kiddo_parents(z, z, z->parent); 1871 1872 /* remove from tree */ 1873 (void)rbtree_delete(&zones->ztree, z); 1874 1875 /* delete the zone */ 1876 lock_rw_unlock(&z->lock); 1877 local_zone_delete(z); 1878} 1879 1880int 1881local_zones_add_RR(struct local_zones* zones, const char* rr) 1882{ 1883 uint8_t* rr_name; 1884 uint16_t rr_class, rr_type; 1885 size_t len; 1886 int labs; 1887 struct local_zone* z; 1888 int r; 1889 if(!get_rr_nameclass(rr, &rr_name, &rr_class, &rr_type)) { 1890 return 0; 1891 } 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); 1897 if(!z) { 1898 z = local_zones_add_zone(zones, rr_name, len, labs, rr_class, 1899 local_zone_transparent); 1900 if(!z) { 1901 lock_rw_unlock(&zones->lock); 1902 return 0; 1903 } 1904 } else { 1905 free(rr_name); 1906 } 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); 1911 return r; 1912} 1913 1914/** returns true if the node is terminal so no deeper domain names exist */ 1915static int 1916is_terminal(struct local_data* d) 1917{ 1918 /* for empty nonterminals, the deeper domain names are sorted 1919 * right after them, so simply check the next name in the tree 1920 */ 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 */ 1926 return 1; 1927} 1928 1929/** delete empty terminals from tree when final data is deleted */ 1930static void 1931del_empty_term(struct local_zone* z, struct local_data* d, 1932 uint8_t* name, size_t len, int labs) 1933{ 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); 1938 1939 /* go up and to the next label */ 1940 if(dname_is_root(name)) 1941 return; 1942 dname_remove_label(&name, &len); 1943 labs--; 1944 d = local_zone_find_data(z, name, len, labs); 1945 } 1946} 1947 1948/** find and remove type from list in domain struct */ 1949static void 1950del_local_rrset(struct local_data* d, uint16_t dtype) 1951{ 1952 struct local_rrset* prev=NULL, *p=d->rrsets; 1953 while(p && ntohs(p->rrset->rk.type) != dtype) { 1954 prev = p; 1955 p = p->next; 1956 } 1957 if(!p) 1958 return; /* rrset type not found */ 1959 /* unlink it */ 1960 if(prev) prev->next = p->next; 1961 else d->rrsets = p->next; 1962 /* no memory recycling for zone deletions ... */ 1963} 1964 1965void local_zones_del_data(struct local_zones* zones, 1966 uint8_t* name, size_t len, int labs, uint16_t dclass) 1967{ 1968 /* find zone */ 1969 struct local_zone* z; 1970 struct local_data* d; 1971 1972 /* remove DS */ 1973 lock_rw_rdlock(&zones->lock); 1974 z = local_zones_lookup(zones, name, len, labs, dclass, LDNS_RR_TYPE_DS); 1975 if(z) { 1976 lock_rw_wrlock(&z->lock); 1977 d = local_zone_find_data(z, name, len, labs); 1978 if(d) { 1979 del_local_rrset(d, LDNS_RR_TYPE_DS); 1980 del_empty_term(z, d, name, len, labs); 1981 } 1982 lock_rw_unlock(&z->lock); 1983 } 1984 lock_rw_unlock(&zones->lock); 1985 1986 /* remove other types */ 1987 lock_rw_rdlock(&zones->lock); 1988 z = local_zones_lookup(zones, name, len, labs, dclass, 0); 1989 if(!z) { 1990 /* no such zone, we're done */ 1991 lock_rw_unlock(&zones->lock); 1992 return; 1993 } 1994 lock_rw_wrlock(&z->lock); 1995 lock_rw_unlock(&zones->lock); 1996 1997 /* find the domain */ 1998 d = local_zone_find_data(z, name, len, labs); 1999 if(d) { 2000 /* no memory recycling for zone deletions ... */ 2001 d->rrsets = NULL; 2002 /* did we delete the soa record ? */ 2003 if(query_dname_compare(d->name, z->name) == 0) 2004 z->soa = NULL; 2005 2006 /* cleanup the empty nonterminals for this name */ 2007 del_empty_term(z, d, name, len, labs); 2008 } 2009 2010 lock_rw_unlock(&z->lock); 2011} 2012