Lines Matching +full:a +full:- +full:z
2 * services/localzone.c - local zones authority service.
26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
56 * with 16 bytes for an A record, a 64K packet has about 4000 max */
61 local_zone_out(struct local_zone* z)
65 RBTREE_FOR(d, struct local_data*, &z->data) {
66 for(p = d->rrsets; p; p = p->next) {
67 log_nametypeclass(NO_VERBOSE, "rrset", d->name,
68 ntohs(p->rrset->rk.type),
69 ntohs(p->rrset->rk.rrset_class));
75 local_zone_print(struct local_zone* z)
78 lock_rw_rdlock(&z->lock);
80 local_zone_type2str(z->type));
81 log_nametypeclass(NO_VERBOSE, buf, z->name, 0, z->dclass);
82 local_zone_out(z);
83 lock_rw_unlock(&z->lock);
88 struct local_zone* z;
89 lock_rw_rdlock(&zones->lock);
90 log_info("number of auth zones %u", (unsigned)zones->ztree.count);
91 RBTREE_FOR(z, struct local_zone*, &zones->ztree) {
92 local_zone_print(z);
94 lock_rw_unlock(&zones->lock);
104 rbtree_init(&zones->ztree, &local_zone_cmp);
105 lock_rw_init(&zones->lock);
106 lock_protect(&zones->lock, &zones->ztree, sizeof(zones->ztree));
115 struct local_zone* z = (struct local_zone*)n->key;
116 local_zone_delete(z);
124 lock_rw_destroy(&zones->lock);
126 traverse_postorder(&zones->ztree, lzdel, NULL);
131 local_zone_delete(struct local_zone* z)
133 if(!z)
135 lock_rw_destroy(&z->lock);
136 regional_destroy(z->region);
137 free(z->name);
138 free(z->taglist);
139 free(z);
146 * a class */
147 struct local_zone* a = (struct local_zone*)z1;
150 if(a->dclass != b->dclass) {
151 if(a->dclass < b->dclass)
152 return -1;
155 return dname_lab_cmp(a->name, a->namelabs, b->name, b->namelabs, &m);
161 struct local_data* a = (struct local_data*)d1;
164 return dname_canon_lab_cmp(a->name, a->namelabs, b->name,
165 b->namelabs, &m);
182 /** create a new localzone */
187 struct local_zone* z = (struct local_zone*)calloc(1, sizeof(*z));
188 if(!z) {
191 z->node.key = z;
192 z->dclass = dclass;
193 z->type = t;
194 z->name = nm;
195 z->namelen = len;
196 z->namelabs = labs;
197 lock_rw_init(&z->lock);
198 z->region = regional_create_nochunk(sizeof(struct regional));
199 if(!z->region) {
200 free(z);
203 rbtree_init(&z->data, &local_data_cmp);
204 lock_protect(&z->lock, &z->parent, sizeof(*z)-sizeof(rbnode_type));
205 /* also the zones->lock protects node, parent, name*, class */
206 return z;
209 /** enter a new zone with allocated dname returns with WRlock */
214 struct local_zone* z = local_zone_create(nm, len, labs, t, c);
215 if(!z) {
222 lock_rw_wrlock(&zones->lock);
223 lock_rw_wrlock(&z->lock);
224 if(!rbtree_insert(&zones->ztree, &z->node)) {
228 log_warn("duplicate local-zone %s", str);
229 lock_rw_unlock(&z->lock);
232 oldz = z;
234 z = local_zones_find(zones, nm, len, labs, c);
235 lock_rw_wrlock(&z->lock);
236 lock_rw_unlock(&zones->lock);
238 return z;
240 lock_rw_unlock(&zones->lock);
241 return z;
244 /** enter a new zone */
249 struct local_zone* z;
263 if(!(z=lz_enter_zone_dname(zones, nm, len, labs, t, dclass))) {
267 return z;
279 log_err("error parsing local-data at %d: '%s': %s",
307 log_err("error parsing local-data at %d '%s': %s",
326 * @param alias_ok: 1 if matching a non-exact, alias type such as CNAME is
335 for(p = data->rrsets; p; p = p->next) {
336 if(p->rrset->rk.type == type)
338 if(alias_ok && p->rrset->rk.type == htons(LDNS_RR_TYPE_CNAME))
351 for(i=0; i<pd->count; i++) {
352 if(pd->rr_len[i] == rdata_len &&
353 memcmp(pd->rr_data[i], rdata, rdata_len) == 0)
371 rrset->next = node->rrsets;
372 node->rrsets = rrset;
373 rrset->rrset = (struct ub_packed_rrset_key*)
374 regional_alloc_zero(region, sizeof(*rrset->rrset));
375 if(!rrset->rrset) {
379 rrset->rrset->entry.key = rrset->rrset;
386 pd->trust = rrset_trust_prim_noglue;
387 pd->security = sec_status_insecure;
388 rrset->rrset->entry.data = pd;
389 rrset->rrset->rk.dname = node->name;
390 rrset->rrset->rk.dname_len = node->namelen;
391 rrset->rrset->rk.type = htons(rrtype);
392 rrset->rrset->rk.rrset_class = htons(rrclass);
396 /** insert RR into RRset data structure; Wastes a couple of bytes */
401 size_t* oldlen = pd->rr_len;
402 time_t* oldttl = pd->rr_ttl;
403 uint8_t** olddata = pd->rr_data;
406 if(pd->count > LOCALZONE_RRSET_COUNT_MAX) {
411 pd->count++;
412 pd->rr_len = regional_alloc(region, sizeof(*pd->rr_len)*pd->count);
413 pd->rr_ttl = regional_alloc(region, sizeof(*pd->rr_ttl)*pd->count);
414 pd->rr_data = regional_alloc(region, sizeof(*pd->rr_data)*pd->count);
415 if(!pd->rr_len || !pd->rr_ttl || !pd->rr_data) {
419 if(pd->count > 1) {
420 memcpy(pd->rr_len+1, oldlen,
421 sizeof(*pd->rr_len)*(pd->count-1));
422 memcpy(pd->rr_ttl+1, oldttl,
423 sizeof(*pd->rr_ttl)*(pd->count-1));
424 memcpy(pd->rr_data+1, olddata,
425 sizeof(*pd->rr_data)*(pd->count-1));
427 pd->rr_len[0] = rdata_len;
428 pd->rr_ttl[0] = ttl;
429 pd->rr_data[0] = regional_alloc_init(region, rdata, rdata_len);
430 if(!pd->rr_data[0]) {
437 /** Delete RR from local-zone RRset, wastes memory as the deleted RRs cannot be
442 log_assert(pd->count > 0);
443 if(index >= pd->count) {
447 if(index + 1 < pd->count) {
450 size_t num = pd->count - nexti;
451 memmove(pd->rr_len+index, pd->rr_len+nexti, sizeof(*pd->rr_len)*num);
452 memmove(pd->rr_ttl+index, pd->rr_ttl+nexti, sizeof(*pd->rr_ttl)*num);
453 memmove(pd->rr_data+index, pd->rr_data+nexti, sizeof(*pd->rr_data)*num);
455 pd->count--;
460 local_zone_find_data(struct local_zone* z, uint8_t* nm, size_t nmlen, int nmlabs)
467 return (struct local_data*)rbtree_search(&z->data, &key.node);
470 /** find a node, create it if not and all its empty nonterminal parents */
472 lz_find_create_node(struct local_zone* z, uint8_t* nm, size_t nmlen,
475 struct local_data* ld = local_zone_find_data(z, nm, nmlen, nmlabs);
477 /* create a domain name to store rr. */
478 ld = (struct local_data*)regional_alloc_zero(z->region,
484 ld->node.key = ld;
485 ld->name = regional_alloc_init(z->region, nm, nmlen);
486 if(!ld->name) {
490 ld->namelen = nmlen;
491 ld->namelabs = nmlabs;
492 if(!rbtree_insert(&z->data, &ld->node)) {
496 if(nmlabs > z->namelabs) {
498 if(!lz_find_create_node(z, nm, nmlen, nmlabs-1, res))
508 * records. An artificial soa_negative record with a modified TTL (minimum of
512 lz_mark_soa_for_zone(struct local_zone* z, struct ub_packed_rrset_key* soa_rrset,
516 regional_alloc_zero(z->region, sizeof(*pd));
518 regional_alloc_zero(z->region, sizeof(*rrset_negative));
525 z->soa = soa_rrset;
526 rrset_negative->entry.key = rrset_negative;
527 pd->trust = rrset_trust_prim_noglue;
528 pd->security = sec_status_insecure;
529 rrset_negative->entry.data = pd;
530 rrset_negative->rk.dname = soa_rrset->rk.dname;
531 rrset_negative->rk.dname_len = soa_rrset->rk.dname_len;
532 rrset_negative->rk.type = soa_rrset->rk.type;
533 rrset_negative->rk.rrset_class = soa_rrset->rk.rrset_class;
534 if(!rrset_insert_rr(z->region, pd, rdata, rdata_len, ttl, rrstr))
537 if(pd->count == 0 || pd->rr_len[0] < 2+4)
539 minimum = (time_t)sldns_read_uint32(pd->rr_data[0]+(pd->rr_len[0]-4));
541 pd->ttl = minimum;
542 pd->rr_ttl[0] = minimum;
544 z->soa_negative = rrset_negative;
549 local_zone_enter_rr(struct local_zone* z, uint8_t* nm, size_t nmlen,
557 if(!lz_find_create_node(z, nm, nmlen, nmlabs, &node)) {
563 * another CNAME) for a redirect zone. */
564 if((z->type == local_zone_redirect ||
565 z->type == local_zone_inform_redirect) && node->rrsets) {
569 else if (node->rrsets->rrset->rk.type ==
574 log_err("local-data '%s' in redirect zone must not "
575 "coexist with %s local-data", rrstr, othertype);
581 rrset = new_local_rrset(z->region, node, rrtype, rrclass);
584 if(query_dname_compare(node->name, z->name) == 0) {
586 rrset->rrset->rk.flags = PACKED_RRSET_NSEC_AT_APEX;
588 !lz_mark_soa_for_zone(z, rrset->rrset, rdata, rdata_len, ttl,
593 pd = (struct packed_rrset_data*)rrset->rrset->entry.data;
601 return rrset_insert_rr(z->region, pd, rdata, rdata_len, ttl, rrstr);
606 lz_enter_rr_into_zone(struct local_zone* z, const char* rrstr)
618 log_err("bad local-data: %s", rrstr);
621 log_assert(z->dclass == rrclass);
622 if((z->type == local_zone_redirect ||
623 z->type == local_zone_inform_redirect) &&
624 query_dname_compare(z->name, nm) != 0) {
625 log_err("local-data in redirect zone must reside at top of zone"
631 ret = local_zone_enter_rr(z, nm, nmlen, nmlabs, rrtype, rrclass, ttl,
637 /** enter a data RR into auth data; a zone for it must exist */
645 struct local_zone* z;
652 lock_rw_rdlock(&zones->lock);
653 z = local_zones_lookup(zones, rr_name, len, labs, rr_class, rr_type);
654 if(!z) {
655 lock_rw_unlock(&zones->lock);
658 lock_rw_wrlock(&z->lock);
659 lock_rw_unlock(&zones->lock);
661 r = lz_enter_rr_into_zone(z, rr);
662 lock_rw_unlock(&z->lock);
674 struct local_zone* z;
677 log_err("cannot parse zone name in local-zone-tag: %s", zname);
682 lock_rw_rdlock(&zones->lock);
683 z = local_zones_find(zones, dname, dname_len, dname_labs, rr_class);
684 if(!z) {
685 lock_rw_unlock(&zones->lock);
686 log_err("no local-zone for tag %s", zname);
689 lock_rw_wrlock(&z->lock);
690 lock_rw_unlock(&zones->lock);
691 free(z->taglist);
692 z->taglist = memdup(list, len);
693 z->taglen = len;
694 if(z->taglist)
696 lock_rw_unlock(&z->lock);
711 struct local_zone* z;
716 log_err("cannot parse zone name in local-zone-override: %s %s",
725 log_err("cannot parse netblock in local-zone-override: %s %s",
732 log_err("cannot parse type in local-zone-override: %s %s %s",
738 lock_rw_rdlock(&zones->lock);
739 z = local_zones_find(zones, dname, dname_len, dname_labs, rr_class);
740 if(!z) {
741 lock_rw_unlock(&zones->lock);
742 log_err("no local-zone for local-zone-override %s", zname);
745 lock_rw_wrlock(&z->lock);
746 lock_rw_unlock(&zones->lock);
749 if(!z->override_tree) {
750 z->override_tree = (struct rbtree_type*)regional_alloc_zero(
751 z->region, sizeof(*z->override_tree));
752 if(!z->override_tree) {
753 lock_rw_unlock(&z->lock);
757 addr_tree_init(z->override_tree);
760 if(z->override_tree) {
763 z->region, sizeof(*n));
765 lock_rw_unlock(&z->lock);
769 n->type = t;
770 if(!addr_tree_insert(z->override_tree,
772 lock_rw_unlock(&z->lock);
773 log_err("duplicate local-zone-override %s %s",
779 lock_rw_unlock(&z->lock);
783 /** parse local-zone: statements */
789 struct local_zone* z;
791 for(p = cfg->local_zones; p; p = p->next) {
794 z=
796 lz_enter_zone(zones, p->str, p->str2,
799 lock_rw_unlock(&z->lock);
804 /** lookup a zone in rbtree; exact match only; SLOW due to parse */
808 struct local_zone z;
809 z.node.key = &z;
810 z.dclass = LDNS_RR_CLASS_IN;
811 if(!parse_dname(name, &z.name, &z.namelen, &z.namelabs)) {
815 lock_rw_rdlock(&zones->lock);
816 if(rbtree_search(&zones->ztree, &z.node)) {
817 lock_rw_unlock(&zones->lock);
818 free(z.name);
821 lock_rw_unlock(&zones->lock);
822 free(z.name);
826 /** lookup a zone in cfg->nodefault list */
833 if(name[len-1] == '.') len--;
835 for(p = cfg->local_zones_nodefault; p; p = p->next) {
837 if(strncasecmp(p->str, name, len) == 0 &&
838 (strlen(p->str) == len || (strlen(p->str)==len+1 &&
839 p->str[len] == '.')))
850 struct local_zone* z;
854 if(!(z=lz_enter_zone(zones, name, "static", LDNS_RR_CLASS_IN)))
858 if(!lz_enter_rr_into_zone(z, str)) {
859 lock_rw_unlock(&z->lock);
863 if(!lz_enter_rr_into_zone(z, str)) {
864 lock_rw_unlock(&z->lock);
867 lock_rw_unlock(&z->lock);
874 struct local_zone* z;
878 if(cfg->local_zones_disable_default)
888 if(!(z=lz_enter_zone(zones, "localhost.", "redirect",
890 !lz_enter_rr_into_zone(z,
892 !lz_enter_rr_into_zone(z,
895 !lz_enter_rr_into_zone(z,
896 "localhost. 10800 IN A 127.0.0.1") ||
897 !lz_enter_rr_into_zone(z,
900 if(z) { lock_rw_unlock(&z->lock); }
903 lock_rw_unlock(&z->lock);
906 if(!lz_exists(zones, "127.in-addr.arpa.") &&
907 !lz_nodefault(cfg, "127.in-addr.arpa.")) {
908 if(!(z=lz_enter_zone(zones, "127.in-addr.arpa.", "static",
910 !lz_enter_rr_into_zone(z,
911 "127.in-addr.arpa. 10800 IN NS localhost.") ||
912 !lz_enter_rr_into_zone(z,
913 "127.in-addr.arpa. 10800 IN SOA localhost. "
915 !lz_enter_rr_into_zone(z,
916 "1.0.0.127.in-addr.arpa. 10800 IN PTR localhost.")) {
918 if(z) { lock_rw_unlock(&z->lock); }
921 lock_rw_unlock(&z->lock);
926 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",
928 !lz_enter_rr_into_zone(z,
930 !lz_enter_rr_into_zone(z,
933 !lz_enter_rr_into_zone(z,
936 if(z) { lock_rw_unlock(&z->lock); }
939 lock_rw_unlock(&z->lock);
951 /* service.arpa. zone (draft-ietf-dnssd-srp-25) */
972 if(!cfg->unblock_lan_zones) {
983 /** parse local-zone-override: statements */
988 for(p = cfg->local_zone_overrides; p; p = p->next) {
989 if(!lz_enter_override(zones, p->str, p->str2, p->str3,
1002 if(!prev || prev->dclass != curr->dclass) return NULL;
1003 (void)dname_lab_cmp(prev->name, prev->namelabs, curr->name,
1004 curr->namelabs, &m); /* we know prev is smaller */
1006 /* find the previous, or parent-parent-parent */
1007 for(p = prev; p; p = p->parent) {
1008 /* looking for name with few labels, a parent */
1009 if(p->namelabs <= m) {
1011 /* <: prev matches more, but is not a parent,
1012 * this one is a (grand)parent */
1019 /** setup parent pointers, so that a lookup can be done for closest match */
1024 lock_rw_wrlock(&zones->lock);
1025 RBTREE_FOR(node, struct local_zone*, &zones->ztree) {
1026 lock_rw_wrlock(&node->lock);
1027 node->parent = find_closest_parent(node, prev);
1029 if(node->override_tree)
1030 addr_tree_init_parents(node->override_tree);
1031 lock_rw_unlock(&node->lock);
1033 lock_rw_unlock(&zones->lock);
1036 /** enter implicit transparent zone for local-data: without local-zone: */
1042 * add that as a transparent zone */
1053 for(p = cfg->local_data; p; p = p->next) {
1058 if(!get_rr_nameclass(p->str, &rr_name, &rr_class, &rr_type)) {
1059 log_err("Bad local-data RR %s", p->str);
1063 lock_rw_rdlock(&zones->lock);
1066 /* Check if there is a zone that this could go
1069 * a different class but the same configured
1071 struct local_zone* z = local_zones_lookup(zones,
1073 if(z) {
1074 uint8_t* name = memdup(z->name, z->namelen);
1075 size_t znamelen = z->namelen;
1076 int znamelabs = z->namelabs;
1077 enum localzone_type ztype = z->type;
1078 lock_rw_unlock(&zones->lock);
1086 z =
1094 lock_rw_unlock(&z->lock);
1111 lock_rw_unlock(&zones->lock);
1122 lock_rw_unlock(&zones->lock);
1127 struct local_zone* z;
1131 dname_remove_labels(&n2, &nmlen, nmlabs - match);
1138 log_nametypeclass(VERB_ALGO, "implicit transparent local-zone",
1142 z=
1148 lock_rw_unlock(&z->lock);
1157 /** enter local-zone-tag info */
1163 for(p = cfg->local_zone_tags; p; p = p->next) {
1164 if(!lz_enter_zone_tag(zones, p->str, p->str2, p->str2len,
1178 for(p = cfg->local_data; p; p = p->next) {
1179 if(!lz_enter_rr_str(zones, p->str))
1189 config_deldblstrlist(cfg->local_zones);
1190 cfg->local_zones = NULL;
1191 config_delstrlist(cfg->local_zones_nodefault);
1192 cfg->local_zones_nodefault = NULL;
1193 config_delstrlist(cfg->local_data);
1194 cfg->local_data = NULL;
1249 /* for type DS use a zone higher when on a zonecut */
1252 labs--;
1259 rbtree_find_less_equal(&zones->ztree, &key, &res);
1262 if(!result || result->dclass != dclass)
1265 (void)dname_lab_cmp(result->name, result->namelabs, key.name,
1268 if(result->namelabs <= m)
1269 if(ignoretags || !result->taglist ||
1270 taglist_intersect(result->taglist,
1271 result->taglen, taglist, taglen))
1273 result = result->parent;
1289 return (struct local_zone*)rbtree_search(&zones->ztree, &key);
1304 *exact = rbtree_find_less_equal(&zones->ztree, &key, &node);
1327 udpsize = edns->udp_size;
1328 edns->edns_version = EDNS_ADVERTISED_VERSION;
1329 edns->udp_size = EDNS_ADVERTISED_SIZE;
1330 edns->ext_rcode = 0;
1331 edns->bits &= EDNS_DO;
1333 repinfo, temp, env->now_tv) || !reply_info_answer_encode(qinfo, &rep,
1335 buf, 0, 0, temp, udpsize, edns, (int)(edns->bits&EDNS_DO), 0)) {
1350 edns->edns_version = EDNS_ADVERTISED_VERSION;
1351 edns->udp_size = EDNS_ADVERTISED_SIZE;
1352 edns->ext_rcode = 0;
1353 edns->bits &= EDNS_DO;
1356 rcode, edns, repinfo, temp, env->now_tv))
1357 edns->opt_list_inplace_cb_out = NULL;
1359 if(ede_code != LDNS_EDE_NONE && env->cfg->ede) {
1360 edns_opt_list_append_ede(&edns->opt_list_out, temp,
1380 for(p=list; p; p=p->next) {
1385 snprintf(buf, sizeof(buf), ". %s", p->str);
1395 if(rdr_type != qinfo->qtype && rdr_type != LDNS_RR_TYPE_CNAME)
1399 if(r->rk.dname == NULL) {
1400 r->entry.key = r;
1401 r->rk.dname = qinfo->qname;
1402 r->rk.dname_len = qinfo->qname_len;
1403 r->rk.type = htons(rdr_type);
1404 r->rk.rrset_class = htons(qinfo->qclass);
1405 r->rk.flags = 0;
1411 r->entry.data = d;
1412 d->ttl = sldns_wirerr_get_ttl(rr, len, 1);
1413 d->rr_len = (size_t*)((uint8_t*)d +
1415 d->rr_data = (uint8_t**)&(d->rr_len[1]);
1416 d->rr_ttl = (time_t*)&(d->rr_data[1]);
1418 d = (struct packed_rrset_data*)r->entry.data;
1420 if(d->count != 0) {
1421 size_t* oldlen = d->rr_len;
1422 uint8_t** olddata = d->rr_data;
1423 time_t* oldttl = d->rr_ttl;
1427 d->rr_len = (size_t*)regional_alloc_zero(temp,
1428 (d->count+1)*sizeof(size_t));
1429 d->rr_data = (uint8_t**)regional_alloc_zero(temp,
1430 (d->count+1)*sizeof(uint8_t*));
1431 d->rr_ttl = (time_t*)regional_alloc_zero(temp,
1432 (d->count+1)*sizeof(time_t));
1433 if(!d->rr_len || !d->rr_data || !d->rr_ttl)
1438 memmove(d->rr_len, oldlen, d->count*sizeof(size_t));
1439 memmove(d->rr_data, olddata, d->count*sizeof(uint8_t*));
1440 memmove(d->rr_ttl, oldttl, d->count*sizeof(time_t));
1443 d->rr_len[d->count] = sldns_wirerr_get_rdatalen(rr, len, 1)+2;
1444 d->rr_ttl[d->count] = sldns_wirerr_get_ttl(rr, len, 1);
1445 d->rr_data[d->count] = regional_alloc_init(temp,
1447 d->rr_len[d->count]);
1448 if(!d->rr_data[d->count])
1450 d->count++;
1452 if(r->rk.dname)
1463 /* If we've found a non-exact alias type of local data, make a shallow
1466 if(result && qinfo->qtype != LDNS_RR_TYPE_CNAME &&
1467 r->rk.type == htons(LDNS_RR_TYPE_CNAME)) {
1468 qinfo->local_alias =
1470 if(!qinfo->local_alias)
1472 qinfo->local_alias->rrset =
1474 if(!qinfo->local_alias->rrset)
1481 local_data_answer(struct local_zone* z, struct module_env* env,
1492 key.name = qinfo->qname;
1493 key.namelen = qinfo->qname_len;
1497 key.name = z->name;
1498 key.namelen = z->namelen;
1499 key.namelabs = z->namelabs;
1500 if(tag != -1 && (size_t)tag<tag_datas_size && tag_datas[tag]) {
1507 /* If we found a matching alias, we should
1511 if(qinfo->local_alias)
1518 ld = (struct local_data*)rbtree_search(&z->data, &key.node);
1523 lr = local_data_find_type(ld, qinfo->qtype, 1);
1530 qinfo->qtype != LDNS_RR_TYPE_CNAME &&
1531 lr->rrset->rk.type == htons(LDNS_RR_TYPE_CNAME)) {
1535 qinfo->local_alias =
1537 if(!qinfo->local_alias)
1539 qinfo->local_alias->rrset = regional_alloc_init(
1540 temp, lr->rrset, sizeof(*lr->rrset));
1541 if(!qinfo->local_alias->rrset)
1543 qinfo->local_alias->rrset->rk.dname = qinfo->qname;
1544 qinfo->local_alias->rrset->rk.dname_len = qinfo->qname_len;
1545 get_cname_target(lr->rrset, &ctarget, &ctargetlen);
1551 /* -3 for wildcard label and root label from qname */
1552 size_t newtargetlen = qinfo->qname_len + ctargetlen - 3;
1555 log_assert(qinfo->qname_len >= 1);
1558 qinfo->local_alias = NULL;
1566 memset(&qinfo->local_alias->rrset->entry, 0,
1567 sizeof(qinfo->local_alias->rrset->entry));
1568 qinfo->local_alias->rrset->entry.key =
1569 qinfo->local_alias->rrset;
1570 qinfo->local_alias->rrset->entry.hash =
1571 rrset_key_hash(&qinfo->local_alias->rrset->rk);
1578 lr_d = (struct packed_rrset_data*)lr->rrset->entry.data;
1579 qinfo->local_alias->rrset->entry.data = d;
1580 d->ttl = lr_d->rr_ttl[0]; /* RFC6672-like behavior:
1582 d->count = 1;
1583 d->rrsig_count = 0;
1584 d->trust = rrset_trust_ans_noAA;
1585 d->rr_len = (size_t*)((uint8_t*)d +
1587 d->rr_len[0] = newtargetlen + sizeof(uint16_t);
1589 d->rr_ttl[0] = d->ttl;
1590 sldns_write_uint16(d->rr_data[0], newtargetlen);
1592 memmove(d->rr_data[0] + sizeof(uint16_t), qinfo->qname,
1593 qinfo->qname_len - 1);
1595 memmove(d->rr_data[0] + sizeof(uint16_t) +
1596 qinfo->qname_len - 1, ctarget + 2,
1597 ctargetlen - 2);
1603 /* convert rrset name to query name; like a wildcard */
1604 struct ub_packed_rrset_key r = *lr->rrset;
1605 r.rk.dname = qinfo->qname;
1606 r.rk.dname_len = qinfo->qname_len;
1610 return local_encode(qinfo, env, edns, repinfo, buf, temp, lr->rrset, 1,
1618 local_zone_does_not_cover(struct local_zone* z, struct query_info* qinfo,
1624 if(z->type == local_zone_always_transparent || z->type == local_zone_block_a)
1626 if(z->type != local_zone_transparent
1627 && z->type != local_zone_typetransparent
1628 && z->type != local_zone_inform)
1631 key.name = qinfo->qname;
1632 key.namelen = qinfo->qname_len;
1634 ld = (struct local_data*)rbtree_search(&z->data, &key.node);
1635 if(z->type == local_zone_transparent || z->type == local_zone_inform)
1638 lr = local_data_find_type(ld, qinfo->qtype, 1);
1646 ? (repinfo->c != NULL
1647 ? repinfo->c->type == comm_udp
1653 local_zones_zone_answer(struct local_zone* z, struct module_env* env,
1691 if(z != NULL && z->soa && z->soa_negative)
1693 z->soa_negative, 0, rcode);
1702 /* Return NODATA for all A queries */
1703 if(qinfo->qtype == LDNS_RR_TYPE_A) {
1714 if(qinfo->qtype == LDNS_RR_TYPE_A ||
1715 qinfo->qtype == LDNS_RR_TYPE_AAAA) {
1725 lrr.rk.dname = qinfo->qname;
1726 lrr.rk.dname_len = qinfo->qname_len;
1727 lrr.rk.type = htons(qinfo->qtype);
1728 lrr.rk.rrset_class = htons(qinfo->qclass);
1729 if(qinfo->qtype == LDNS_RR_TYPE_A) {
1749 (LDNS_RCODE_NOERROR|BIT_AA), -1, NULL);
1757 if(ld && ld->rrsets) {
1759 if(z != NULL && z->soa && z->soa_negative)
1761 z->soa_negative, 0, rcode);
1774 lz_inform_print(struct local_zone* z, struct query_info* qinfo,
1779 uint16_t port = ntohs(((struct sockaddr_in*)addr)->sin_port);
1780 dname_str(z->name, zname);
1782 snprintf(txt, sizeof(txt), "%s %s %s@%u", zname, local_zone_type2str(z->type), ip,
1784 log_nametypeclass(NO_VERBOSE, txt, qinfo->qname, qinfo->qtype, qinfo->qclass);
1796 override_tree, &repinfo->client_addr,
1797 repinfo->client_addrlen);
1798 if(lzo && lzo->type) {
1800 local_zone_type2str(lzo->type));
1801 return lzo->type;
1826 /* does this tag have a tag action? */
1852 /* see if query is covered by a zone,
1853 * if so: - try to match (exact) local data
1854 * - look at zone type for negative response. */
1855 int labs = dname_count_labels(qinfo->qname);
1857 struct local_zone* z = NULL;
1859 int r, tag = -1;
1862 lock_rw_rdlock(&view->lock);
1863 if(view->local_zones &&
1864 (z = local_zones_lookup(view->local_zones,
1865 qinfo->qname, qinfo->qname_len, labs,
1866 qinfo->qclass, qinfo->qtype))) {
1867 lock_rw_rdlock(&z->lock);
1868 lzt = z->type;
1871 lock_rw_unlock(&z->lock);
1872 z = NULL;
1874 if(z && (lzt == local_zone_transparent ||
1879 local_zone_does_not_cover(z, qinfo, labs)) {
1880 lock_rw_unlock(&z->lock);
1881 z = NULL;
1883 if(view->local_zones && !z && !view->isfirst){
1884 lock_rw_unlock(&view->lock);
1887 if(z && verbosity >= VERB_ALGO) {
1889 dname_str(z->name, zname);
1891 zname, local_zone_type2str(lzt), view->name);
1893 lock_rw_unlock(&view->lock);
1895 if(!z) {
1897 lock_rw_rdlock(&zones->lock);
1898 if(!(z = local_zones_tags_lookup(zones, qinfo->qname,
1899 qinfo->qname_len, labs, qinfo->qclass, qinfo->qtype,
1901 lock_rw_unlock(&zones->lock);
1904 lock_rw_rdlock(&z->lock);
1905 lzt = lz_type(taglist, taglen, z->taglist, z->taglen,
1906 tagactions, tagactionssize, z->type, repinfo,
1907 z->override_tree, &tag, tagname, num_tags);
1908 lock_rw_unlock(&zones->lock);
1909 if(z && verbosity >= VERB_ALGO) {
1911 dname_str(z->name, zname);
1916 if((env->cfg->log_local_actions ||
1921 lz_inform_print(z, qinfo, &repinfo->client_addr,
1922 repinfo->client_addrlen);
1930 && local_data_answer(z, env, qinfo, edns, repinfo, buf, temp, labs,
1932 lock_rw_unlock(&z->lock);
1934 * a local alias. */
1935 return !qinfo->local_alias;
1937 r = local_zones_zone_answer(z, env, qinfo, edns, repinfo, buf, temp, ld, lzt);
1938 lock_rw_unlock(&z->lock);
1939 return r && !qinfo->local_alias; /* see above */
2016 set_kiddo_parents(struct local_zone* z, struct local_zone* match,
2019 /* both zones and z are locked already */
2020 /* in the sorted rbtree, the kiddies of z are located after z */
2021 /* z must be present in the tree */
2022 struct local_zone* p = z;
2023 p = (struct local_zone*)rbtree_next(&p->node);
2025 p->dclass == z->dclass && dname_strict_subdomain(p->name,
2026 p->namelabs, z->name, z->namelabs)) {
2030 * update of x, and a.x, b.x, f.b.x, g.b.x, c.x, y
2031 * gets to update a.x, b.x and c.x */
2032 lock_rw_wrlock(&p->lock);
2033 if(p->parent == match)
2034 p->parent = newp;
2035 lock_rw_unlock(&p->lock);
2036 p = (struct local_zone*)rbtree_next(&p->node);
2047 struct local_zone* z = local_zone_create(name, len, labs, tp, dclass);
2048 if(!z) {
2052 lock_rw_wrlock(&z->lock);
2057 z->parent = find_closest_parent(z, prev);
2060 if(exact||!rbtree_insert(&zones->ztree, &z->node)) {
2062 lock_rw_unlock(&z->lock);
2063 local_zone_delete(z);
2069 set_kiddo_parents(z, z->parent, z);
2071 lock_rw_unlock(&z->lock);
2072 return z;
2075 void local_zones_del_zone(struct local_zones* zones, struct local_zone* z)
2078 lock_rw_wrlock(&z->lock);
2079 set_kiddo_parents(z, z, z->parent);
2082 (void)rbtree_delete(&zones->ztree, z);
2085 lock_rw_unlock(&z->lock);
2086 local_zone_delete(z);
2096 struct local_zone* z;
2104 lock_rw_wrlock(&zones->lock);
2105 z = local_zones_lookup(zones, rr_name, len, labs, rr_class, rr_type);
2106 if(!z) {
2107 z = local_zones_add_zone(zones, rr_name, len, labs, rr_class,
2109 if(!z) {
2110 lock_rw_unlock(&zones->lock);
2116 lock_rw_wrlock(&z->lock);
2117 lock_rw_unlock(&zones->lock);
2118 r = lz_enter_rr_into_zone(z, rr);
2119 lock_rw_unlock(&z->lock);
2130 struct local_data* n = (struct local_data*)rbtree_next(&d->node);
2133 if(dname_strict_subdomain(n->name, n->namelabs, d->name, d->namelabs))
2134 return 0; /* there is a deeper node */
2140 del_empty_term(struct local_zone* z, struct local_data* d,
2143 while(d && d->rrsets == NULL && is_terminal(d)) {
2146 (void)rbtree_delete(&z->data, d);
2152 labs--;
2153 d = local_zone_find_data(z, name, len, labs);
2161 struct local_rrset* prev=NULL, *p=d->rrsets;
2162 while(p && ntohs(p->rrset->rk.type) != dtype) {
2164 p = p->next;
2169 if(prev) prev->next = p->next;
2170 else d->rrsets = p->next;
2178 struct local_zone* z;
2182 lock_rw_rdlock(&zones->lock);
2183 z = local_zones_lookup(zones, name, len, labs, dclass, LDNS_RR_TYPE_DS);
2184 if(z) {
2185 lock_rw_wrlock(&z->lock);
2186 d = local_zone_find_data(z, name, len, labs);
2189 del_empty_term(z, d, name, len, labs);
2191 lock_rw_unlock(&z->lock);
2193 lock_rw_unlock(&zones->lock);
2196 lock_rw_rdlock(&zones->lock);
2197 z = local_zones_lookup(zones, name, len, labs, dclass, 0);
2198 if(!z) {
2200 lock_rw_unlock(&zones->lock);
2203 lock_rw_wrlock(&z->lock);
2204 lock_rw_unlock(&zones->lock);
2207 d = local_zone_find_data(z, name, len, labs);
2210 d->rrsets = NULL;
2212 if(query_dname_compare(d->name, z->name) == 0) {
2213 z->soa = NULL;
2214 z->soa_negative = NULL;
2218 del_empty_term(z, d, name, len, labs);
2221 lock_rw_unlock(&z->lock);
2226 local_zone_get_mem(struct local_zone* z)
2228 size_t m = sizeof(*z);
2229 lock_rw_rdlock(&z->lock);
2230 m += z->namelen + z->taglen + regional_get_mem(z->region);
2231 lock_rw_unlock(&z->lock);
2237 struct local_zone* z;
2241 lock_rw_rdlock(&zones->lock);
2242 RBTREE_FOR(z, struct local_zone*, &zones->ztree) {
2243 m += local_zone_get_mem(z);
2245 lock_rw_unlock(&zones->lock);
2251 rbtree_type oldtree = zones->ztree;
2252 zones->ztree = data->ztree;
2253 data->ztree = oldtree;