Lines Matching defs:z
61 local_zone_out(struct local_zone* z)
65 RBTREE_FOR(d, struct local_data*, &z->data) {
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;
91 RBTREE_FOR(z, struct local_zone*, &zones->ztree) {
92 local_zone_print(z);
115 struct local_zone* z = (struct local_zone*)n->key;
116 local_zone_delete(z);
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);
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));
206 return z;
214 struct local_zone* z = local_zone_create(nm, len, labs, t, c);
215 if(!z) {
223 lock_rw_wrlock(&z->lock);
224 if(!rbtree_insert(&zones->ztree, &z->node)) {
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);
238 return z;
241 return z;
249 struct local_zone* z;
263 if(!(z=lz_enter_zone_dname(zones, nm, len, labs, t, dclass))) {
267 return z;
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);
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);
478 ld = (struct local_data*)regional_alloc_zero(z->region,
485 ld->name = regional_alloc_init(z->region, nm, nmlen);
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))
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;
534 if(!rrset_insert_rr(z->region, pd, rdata, rdata_len, ttl, rrstr))
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)) {
564 if((z->type == local_zone_redirect ||
565 z->type == local_zone_inform_redirect) && node->rrsets) {
581 rrset = new_local_rrset(z->region, node, rrtype, rrclass);
584 if(query_dname_compare(node->name, z->name) == 0) {
588 !lz_mark_soa_for_zone(z, rrset->rrset, rdata, rdata_len, ttl,
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)
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) {
631 ret = local_zone_enter_rr(z, nm, nmlen, nmlabs, rrtype, rrclass, ttl,
645 struct local_zone* z;
653 z = local_zones_lookup(zones, rr_name, len, labs, rr_class, rr_type);
654 if(!z) {
658 lock_rw_wrlock(&z->lock);
661 r = lz_enter_rr_into_zone(z, rr);
662 lock_rw_unlock(&z->lock);
674 struct local_zone* z;
683 z = local_zones_find(zones, dname, dname_len, dname_labs, rr_class);
684 if(!z) {
689 lock_rw_wrlock(&z->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;
739 z = local_zones_find(zones, dname, dname_len, dname_labs, rr_class);
740 if(!z) {
745 lock_rw_wrlock(&z->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);
770 if(!addr_tree_insert(z->override_tree,
772 lock_rw_unlock(&z->lock);
779 lock_rw_unlock(&z->lock);
789 struct local_zone* z;
794 z=
799 lock_rw_unlock(&z->lock);
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)) {
816 if(rbtree_search(&zones->ztree, &z.node)) {
818 free(z.name);
822 free(z.name);
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;
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,
897 !lz_enter_rr_into_zone(z,
900 if(z) { lock_rw_unlock(&z->lock); }
903 lock_rw_unlock(&z->lock);
908 if(!(z=lz_enter_zone(zones, "127.in-addr.arpa.", "static",
910 !lz_enter_rr_into_zone(z,
912 !lz_enter_rr_into_zone(z,
915 !lz_enter_rr_into_zone(z,
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);
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;
1086 z =
1094 lock_rw_unlock(&z->lock);
1127 struct local_zone* z;
1142 z=
1148 lock_rw_unlock(&z->lock);
1481 local_data_answer(struct local_zone* z, struct module_env* env,
1497 key.name = z->name;
1498 key.namelen = z->namelen;
1499 key.namelabs = z->namelabs;
1518 ld = (struct local_data*)rbtree_search(&z->data, &key.node);
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)
1634 ld = (struct local_data*)rbtree_search(&z->data, &key.node);
1635 if(z->type == local_zone_transparent || z->type == local_zone_inform)
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);
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,
1780 dname_str(z->name, zname);
1782 snprintf(txt, sizeof(txt), "%s %s %s@%u", zname, local_zone_type2str(z->type), ip,
1857 struct local_zone* z = NULL;
1864 (z = local_zones_lookup(view->local_zones,
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){
1887 if(z && verbosity >= VERB_ALGO) {
1889 dname_str(z->name, zname);
1895 if(!z) {
1898 if(!(z = local_zones_tags_lookup(zones, qinfo->qname,
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);
1909 if(z && verbosity >= VERB_ALGO) {
1911 dname_str(z->name, zname);
1921 lz_inform_print(z, qinfo, &repinfo->client_addr,
1930 && local_data_answer(z, env, qinfo, edns, repinfo, buf, temp, labs,
1932 lock_rw_unlock(&z->lock);
1937 r = local_zones_zone_answer(z, env, qinfo, edns, repinfo, buf, temp, ld, lzt);
1938 lock_rw_unlock(&z->lock);
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;
2025 p->dclass == z->dclass && dname_strict_subdomain(p->name,
2026 p->namelabs, z->name, z->namelabs)) {
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;
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) {
2116 lock_rw_wrlock(&z->lock);
2118 r = lz_enter_rr_into_zone(z, rr);
2119 lock_rw_unlock(&z->lock);
2140 del_empty_term(struct local_zone* z, struct local_data* d,
2146 (void)rbtree_delete(&z->data, d);
2153 d = local_zone_find_data(z, name, len, labs);
2178 struct local_zone* z;
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);
2197 z = local_zones_lookup(zones, name, len, labs, dclass, 0);
2198 if(!z) {
2203 lock_rw_wrlock(&z->lock);
2207 d = local_zone_find_data(z, name, len, labs);
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;
2242 RBTREE_FOR(z, struct local_zone*, &zones->ztree) {
2243 m += local_zone_get_mem(z);