diff --git a/CHANGES b/CHANGES index 114f130831..ef6cbd4db9 100644 --- a/CHANGES +++ b/CHANGES @@ -1,6 +1,9 @@ 6116. [bug] Fix error path cleanup issues in dns_catz_new_zones() and dns_catz_new_zone() functions. [GL #3900] +6112. [func] Add reference count tracing for dns_catz_zone_t and + dns_catz_zones_t. [GL !7570] + 6105. [bug] Detach 'rpzs' and 'catzs' from the previous view in configure_rpz() and configure_catz(), respectively, just after attaching it to the new view. [GL #3880] diff --git a/bin/named/server.c b/bin/named/server.c index f21745f4bc..73d8fd1fde 100644 --- a/bin/named/server.c +++ b/bin/named/server.c @@ -2877,7 +2877,7 @@ cleanup: cfg_obj_destroy(cfg->add_parser, &zoneconf); } dns_catz_entry_detach(ev->origin, &ev->entry); - dns_catz_zone_detach(&ev->origin); + dns_catz_detach_catz(&ev->origin); dns_view_detach(&ev->view); isc_event_free(ISC_EVENT_PTR(&ev)); } @@ -2952,7 +2952,7 @@ cleanup: dns_zone_detach(&zone); } dns_catz_entry_detach(ev->origin, &ev->entry); - dns_catz_zone_detach(&ev->origin); + dns_catz_detach_catz(&ev->origin); dns_view_detach(&ev->view); isc_event_free(ISC_EVENT_PTR(&ev)); } @@ -2994,7 +2994,7 @@ catz_create_chg_task(dns_catz_entry_t *entry, dns_catz_zone_t *origin, event->mod = (type == DNS_EVENT_CATZMODZONE); dns_catz_entry_attach(entry, &event->entry); - dns_catz_zone_attach(origin, &event->origin); + dns_catz_attach_catz(origin, &event->origin); dns_view_attach(view, &event->view); isc_task_send(task, ISC_EVENT_PTR(&event)); @@ -3161,7 +3161,7 @@ static dns_catz_zonemodmethods_t ns_catz_zonemodmethods = { static isc_result_t configure_catz(dns_view_t *view, dns_view_t *pview, const cfg_obj_t *config, const cfg_obj_t *catz_obj) { - const cfg_listelt_t *zone_element; + const cfg_listelt_t *zone_element = NULL; const dns_catz_zones_t *old = NULL; bool pview_must_detach = false; isc_result_t result; @@ -3174,9 +3174,8 @@ configure_catz(dns_view_t *view, dns_view_t *pview, const cfg_obj_t *config, return (ISC_R_SUCCESS); } - CHECK(dns_catz_new_zones(&view->catzs, &ns_catz_zonemodmethods, - view->mctx, named_g_taskmgr, - named_g_timermgr)); + CHECK(dns_catz_new_zones(view->mctx, named_g_taskmgr, named_g_timermgr, + &view->catzs, &ns_catz_zonemodmethods)); if (pview != NULL) { old = pview->catzs; @@ -3190,9 +3189,9 @@ configure_catz(dns_view_t *view, dns_view_t *pview, const cfg_obj_t *config, } if (old != NULL) { - dns_catz_catzs_detach(&view->catzs); - dns_catz_catzs_attach(pview->catzs, &view->catzs); - dns_catz_catzs_detach(&pview->catzs); + dns_catz_detach_catzs(&view->catzs); + dns_catz_attach_catzs(pview->catzs, &view->catzs); + dns_catz_detach_catzs(&pview->catzs); dns_catz_prereconfig(view->catzs); } diff --git a/lib/dns/catz.c b/lib/dns/catz.c index c5131d1489..4edc8c80ec 100644 --- a/lib/dns/catz.c +++ b/lib/dns/catz.c @@ -15,6 +15,8 @@ #include #include +#include +#include #include #include @@ -50,7 +52,7 @@ struct dns_catz_coo { unsigned int magic; dns_name_t name; - isc_refcount_t refs; + isc_refcount_t references; }; /*% @@ -60,7 +62,7 @@ struct dns_catz_entry { unsigned int magic; dns_name_t name; dns_catz_options_t opts; - isc_refcount_t refs; + isc_refcount_t references; }; /*% @@ -96,17 +98,17 @@ struct dns_catz_zone { bool db_registered; bool broken; - isc_refcount_t refs; + isc_refcount_t references; }; static isc_result_t -catz_process_zones_entry(dns_catz_zone_t *zone, dns_rdataset_t *value, +catz_process_zones_entry(dns_catz_zone_t *catz, dns_rdataset_t *value, dns_label_t *mhash); static isc_result_t -catz_process_zones_suboption(dns_catz_zone_t *zone, dns_rdataset_t *value, +catz_process_zones_suboption(dns_catz_zone_t *catz, dns_rdataset_t *value, dns_label_t *mhash, dns_name_t *name); static void -catz_entry_add_or_mod(dns_catz_zone_t *target, isc_ht_t *ht, unsigned char *key, +catz_entry_add_or_mod(dns_catz_zone_t *catz, isc_ht_t *ht, unsigned char *key, size_t keysize, dns_catz_entry_t *nentry, dns_catz_entry_t *oentry, const char *msg, const char *zname, const char *czname); @@ -118,7 +120,7 @@ struct dns_catz_zones { unsigned int magic; isc_ht_t *zones; isc_mem_t *mctx; - isc_refcount_t refs; + isc_refcount_t references; isc_mutex_t lock; dns_catz_zonemodmethods_t *zmm; isc_taskmgr_t *taskmgr; @@ -232,31 +234,31 @@ catz_coo_new(isc_mem_t *mctx, const dns_name_t *domain, REQUIRE(domain != NULL); REQUIRE(ncoop != NULL && *ncoop == NULL); - ncoo = isc_mem_get(mctx, sizeof(dns_catz_coo_t)); + ncoo = isc_mem_get(mctx, sizeof(*ncoo)); dns_name_init(&ncoo->name, NULL); dns_name_dup(domain, mctx, &ncoo->name); - isc_refcount_init(&ncoo->refs, 1); + isc_refcount_init(&ncoo->references, 1); ncoo->magic = DNS_CATZ_COO_MAGIC; *ncoop = ncoo; } static void -catz_coo_detach(dns_catz_zone_t *zone, dns_catz_coo_t **coop) { +catz_coo_detach(dns_catz_zone_t *catz, dns_catz_coo_t **coop) { dns_catz_coo_t *coo; - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); REQUIRE(coop != NULL && DNS_CATZ_COO_VALID(*coop)); coo = *coop; *coop = NULL; - if (isc_refcount_decrement(&coo->refs) == 1) { - isc_mem_t *mctx = zone->catzs->mctx; + if (isc_refcount_decrement(&coo->references) == 1) { + isc_mem_t *mctx = catz->catzs->mctx; coo->magic = 0; - isc_refcount_destroy(&coo->refs); + isc_refcount_destroy(&coo->references); if (dns_name_dynamic(&coo->name)) { dns_name_free(&coo->name, mctx); } - isc_mem_put(mctx, coo, sizeof(dns_catz_coo_t)); + isc_mem_put(mctx, coo, sizeof(*coo)); } } @@ -268,7 +270,7 @@ dns_catz_entry_new(isc_mem_t *mctx, const dns_name_t *domain, REQUIRE(mctx != NULL); REQUIRE(nentryp != NULL && *nentryp == NULL); - nentry = isc_mem_get(mctx, sizeof(dns_catz_entry_t)); + nentry = isc_mem_get(mctx, sizeof(*nentry)); dns_name_init(&nentry->name, NULL); if (domain != NULL) { @@ -276,7 +278,7 @@ dns_catz_entry_new(isc_mem_t *mctx, const dns_name_t *domain, } dns_catz_options_init(&nentry->opts); - isc_refcount_init(&nentry->refs, 1); + isc_refcount_init(&nentry->references, 1); nentry->magic = DNS_CATZ_ENTRY_MAGIC; *nentryp = nentry; } @@ -288,17 +290,17 @@ dns_catz_entry_getname(dns_catz_entry_t *entry) { } void -dns_catz_entry_copy(dns_catz_zone_t *zone, const dns_catz_entry_t *entry, +dns_catz_entry_copy(dns_catz_zone_t *catz, const dns_catz_entry_t *entry, dns_catz_entry_t **nentryp) { dns_catz_entry_t *nentry = NULL; - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); REQUIRE(DNS_CATZ_ENTRY_VALID(entry)); REQUIRE(nentryp != NULL && *nentryp == NULL); - dns_catz_entry_new(zone->catzs->mctx, &entry->name, &nentry); + dns_catz_entry_new(catz->catzs->mctx, &entry->name, &nentry); - dns_catz_options_copy(zone->catzs->mctx, &entry->opts, &nentry->opts); + dns_catz_options_copy(catz->catzs->mctx, &entry->opts, &nentry->opts); *nentryp = nentry; } @@ -307,28 +309,28 @@ dns_catz_entry_attach(dns_catz_entry_t *entry, dns_catz_entry_t **entryp) { REQUIRE(DNS_CATZ_ENTRY_VALID(entry)); REQUIRE(entryp != NULL && *entryp == NULL); - isc_refcount_increment(&entry->refs); + isc_refcount_increment(&entry->references); *entryp = entry; } void -dns_catz_entry_detach(dns_catz_zone_t *zone, dns_catz_entry_t **entryp) { +dns_catz_entry_detach(dns_catz_zone_t *catz, dns_catz_entry_t **entryp) { dns_catz_entry_t *entry; - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); REQUIRE(entryp != NULL && DNS_CATZ_ENTRY_VALID(*entryp)); entry = *entryp; *entryp = NULL; - if (isc_refcount_decrement(&entry->refs) == 1) { - isc_mem_t *mctx = zone->catzs->mctx; + if (isc_refcount_decrement(&entry->references) == 1) { + isc_mem_t *mctx = catz->catzs->mctx; entry->magic = 0; - isc_refcount_destroy(&entry->refs); + isc_refcount_destroy(&entry->references); dns_catz_options_free(&entry->opts, mctx); if (dns_name_dynamic(&entry->name)) { dns_name_free(&entry->name, mctx); } - isc_mem_put(mctx, entry, sizeof(dns_catz_entry_t)); + isc_mem_put(mctx, entry, sizeof(*entry)); } } @@ -426,29 +428,29 @@ dns_catz_entry_cmp(const dns_catz_entry_t *ea, const dns_catz_entry_t *eb) { } dns_name_t * -dns_catz_zone_getname(dns_catz_zone_t *zone) { - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); +dns_catz_zone_getname(dns_catz_zone_t *catz) { + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); - return (&zone->name); + return (&catz->name); } dns_catz_options_t * -dns_catz_zone_getdefoptions(dns_catz_zone_t *zone) { - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); +dns_catz_zone_getdefoptions(dns_catz_zone_t *catz) { + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); - return (&zone->defoptions); + return (&catz->defoptions); } void -dns_catz_zone_resetdefoptions(dns_catz_zone_t *zone) { - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); +dns_catz_zone_resetdefoptions(dns_catz_zone_t *catz) { + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); - dns_catz_options_free(&zone->defoptions, zone->catzs->mctx); - dns_catz_options_init(&zone->defoptions); + dns_catz_options_free(&catz->defoptions, catz->catzs->mctx); + dns_catz_options_init(&catz->defoptions); } isc_result_t -dns_catz_zones_merge(dns_catz_zone_t *target, dns_catz_zone_t *newzone) { +dns_catz_zones_merge(dns_catz_zone_t *catz, dns_catz_zone_t *newcatz) { isc_result_t result; isc_ht_iter_t *iter1 = NULL, *iter2 = NULL; isc_ht_iter_t *iteradd = NULL, *itermod = NULL; @@ -458,39 +460,35 @@ dns_catz_zones_merge(dns_catz_zone_t *target, dns_catz_zone_t *newzone) { char zname[DNS_NAME_FORMATSIZE]; dns_catz_zoneop_fn_t addzone, modzone, delzone; - REQUIRE(DNS_CATZ_ZONE_VALID(newzone)); - REQUIRE(DNS_CATZ_ZONE_VALID(target)); + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); + REQUIRE(DNS_CATZ_ZONE_VALID(newcatz)); /* TODO verify the new zone first! */ - addzone = target->catzs->zmm->addzone; - modzone = target->catzs->zmm->modzone; - delzone = target->catzs->zmm->delzone; + addzone = catz->catzs->zmm->addzone; + modzone = catz->catzs->zmm->modzone; + delzone = catz->catzs->zmm->delzone; - /* Copy zoneoptions from newzone into target. */ + /* Copy zoneoptions from newcatz into catz. */ - dns_catz_options_free(&target->zoneoptions, target->catzs->mctx); - dns_catz_options_copy(target->catzs->mctx, &newzone->zoneoptions, - &target->zoneoptions); - dns_catz_options_setdefault(target->catzs->mctx, &target->defoptions, - &target->zoneoptions); + dns_catz_options_free(&catz->zoneoptions, catz->catzs->mctx); + dns_catz_options_copy(catz->catzs->mctx, &newcatz->zoneoptions, + &catz->zoneoptions); + dns_catz_options_setdefault(catz->catzs->mctx, &catz->defoptions, + &catz->zoneoptions); - dns_name_format(&target->name, czname, DNS_NAME_FORMATSIZE); + dns_name_format(&catz->name, czname, DNS_NAME_FORMATSIZE); - isc_ht_init(&toadd, target->catzs->mctx, 16, ISC_HT_CASE_SENSITIVE); - - isc_ht_init(&tomod, target->catzs->mctx, 16, ISC_HT_CASE_SENSITIVE); - - isc_ht_iter_create(newzone->entries, &iter1); - - isc_ht_iter_create(target->entries, &iter2); + isc_ht_init(&toadd, catz->catzs->mctx, 16, ISC_HT_CASE_SENSITIVE); + isc_ht_init(&tomod, catz->catzs->mctx, 16, ISC_HT_CASE_SENSITIVE); + isc_ht_iter_create(newcatz->entries, &iter1); + isc_ht_iter_create(catz->entries, &iter2); /* * We can create those iterators now, even though toadd and tomod are * empty */ isc_ht_iter_create(toadd, &iteradd); - isc_ht_iter_create(tomod, &itermod); /* @@ -519,7 +517,7 @@ dns_catz_zones_merge(dns_catz_zone_t *target, dns_catz_zone_t *newzone) { * xxxwpk: make it a separate verification phase? */ if (dns_name_countlabels(&nentry->name) == 0) { - dns_catz_entry_detach(newzone, &nentry); + dns_catz_entry_detach(newcatz, &nentry); delcur = true; continue; } @@ -530,12 +528,11 @@ dns_catz_zones_merge(dns_catz_zone_t *target, dns_catz_zone_t *newzone) { DNS_LOGMODULE_MASTER, ISC_LOG_DEBUG(3), "catz: iterating over '%s' from catalog '%s'", zname, czname); - dns_catz_options_setdefault(target->catzs->mctx, - &target->zoneoptions, - &nentry->opts); + dns_catz_options_setdefault(catz->catzs->mctx, + &catz->zoneoptions, &nentry->opts); /* Try to find the zone in the view */ - zt_find_result = dns_zt_find(target->catzs->view->zonetable, + zt_find_result = dns_zt_find(catz->catzs->view->zonetable, dns_catz_entry_getname(nentry), 0, NULL, &zone); if (zt_find_result == ISC_R_SUCCESS) { @@ -546,11 +543,11 @@ dns_catz_zones_merge(dns_catz_zone_t *target, dns_catz_zone_t *newzone) { * Change of ownership (coo) processing, if required */ parentcatz = dns_zone_get_parentcatz(zone); - if (parentcatz != NULL && parentcatz != target && + if (parentcatz != NULL && parentcatz != catz && isc_ht_find(parentcatz->coos, nentry->name.ndata, nentry->name.length, (void **)&coo) == ISC_R_SUCCESS && - dns_name_equal(&coo->name, &target->name)) + dns_name_equal(&coo->name, &catz->name)) { dns_name_format(&parentcatz->name, pczname, DNS_NAME_FORMATSIZE); @@ -581,11 +578,11 @@ dns_catz_zones_merge(dns_catz_zone_t *target, dns_catz_zone_t *newzone) { } /* Try to find the zone in the old catalog zone */ - result = isc_ht_find(target->entries, key, (uint32_t)keysize, + result = isc_ht_find(catz->entries, key, (uint32_t)keysize, (void **)&oentry); if (result != ISC_R_SUCCESS) { if (zt_find_result == ISC_R_SUCCESS && - parentcatz == target) + parentcatz == catz) { /* * This means that the zone's unique label @@ -607,9 +604,8 @@ dns_catz_zones_merge(dns_catz_zone_t *target, dns_catz_zone_t *newzone) { zname); } - catz_entry_add_or_mod(target, toadd, key, keysize, - nentry, NULL, "adding", zname, - czname); + catz_entry_add_or_mod(catz, toadd, key, keysize, nentry, + NULL, "adding", zname, czname); continue; } @@ -619,16 +615,15 @@ dns_catz_zones_merge(dns_catz_zone_t *target, dns_catz_zone_t *newzone) { "catz: zone '%s' was expected to exist " "but can not be found, will be restored", zname); - catz_entry_add_or_mod(target, toadd, key, keysize, - nentry, oentry, "adding", zname, - czname); + catz_entry_add_or_mod(catz, toadd, key, keysize, nentry, + oentry, "adding", zname, czname); continue; } if (dns_catz_entry_cmp(oentry, nentry) != true) { - catz_entry_add_or_mod(target, tomod, key, keysize, - nentry, oentry, "modifying", - zname, czname); + catz_entry_add_or_mod(catz, tomod, key, keysize, nentry, + oentry, "modifying", zname, + czname); continue; } @@ -636,8 +631,8 @@ dns_catz_zones_merge(dns_catz_zone_t *target, dns_catz_zone_t *newzone) { * Delete the old entry so that it won't accidentally be * removed as a non-existing entry below. */ - dns_catz_entry_detach(target, &oentry); - result = isc_ht_delete(target->entries, key, (uint32_t)keysize); + dns_catz_entry_detach(catz, &oentry); + result = isc_ht_delete(catz->entries, key, (uint32_t)keysize); RUNTIME_CHECK(result == ISC_R_SUCCESS); } RUNTIME_CHECK(result == ISC_R_NOMORE); @@ -653,20 +648,19 @@ dns_catz_zones_merge(dns_catz_zone_t *target, dns_catz_zone_t *newzone) { isc_ht_iter_current(iter2, (void **)&entry); dns_name_format(&entry->name, zname, DNS_NAME_FORMATSIZE); - result = delzone(entry, target, target->catzs->view, - target->catzs->taskmgr, - target->catzs->zmm->udata); + result = delzone(entry, catz, catz->catzs->view, + catz->catzs->taskmgr, catz->catzs->zmm->udata); isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_INFO, "catz: deleting zone '%s' from catalog '%s' - %s", zname, czname, isc_result_totext(result)); - dns_catz_entry_detach(target, &entry); + dns_catz_entry_detach(catz, &entry); } RUNTIME_CHECK(result == ISC_R_NOMORE); isc_ht_iter_destroy(&iter2); - /* At this moment target->entries has to be be empty. */ - INSIST(isc_ht_count(target->entries) == 0); - isc_ht_destroy(&target->entries); + /* At this moment catz->entries has to be be empty. */ + INSIST(isc_ht_count(catz->entries) == 0); + isc_ht_destroy(&catz->entries); for (result = isc_ht_iter_first(iteradd); result == ISC_R_SUCCESS; result = isc_ht_iter_delcurrent_next(iteradd)) @@ -675,9 +669,8 @@ dns_catz_zones_merge(dns_catz_zone_t *target, dns_catz_zone_t *newzone) { isc_ht_iter_current(iteradd, (void **)&entry); dns_name_format(&entry->name, zname, DNS_NAME_FORMATSIZE); - result = addzone(entry, target, target->catzs->view, - target->catzs->taskmgr, - target->catzs->zmm->udata); + result = addzone(entry, catz, catz->catzs->view, + catz->catzs->taskmgr, catz->catzs->zmm->udata); isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_INFO, "catz: adding zone '%s' from catalog " @@ -692,9 +685,8 @@ dns_catz_zones_merge(dns_catz_zone_t *target, dns_catz_zone_t *newzone) { isc_ht_iter_current(itermod, (void **)&entry); dns_name_format(&entry->name, zname, DNS_NAME_FORMATSIZE); - result = modzone(entry, target, target->catzs->view, - target->catzs->taskmgr, - target->catzs->zmm->udata); + result = modzone(entry, catz, catz->catzs->view, + catz->catzs->taskmgr, catz->catzs->zmm->udata); isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_INFO, "catz: modifying zone '%s' from catalog " @@ -702,34 +694,34 @@ dns_catz_zones_merge(dns_catz_zone_t *target, dns_catz_zone_t *newzone) { zname, czname, isc_result_totext(result)); } - target->entries = newzone->entries; - newzone->entries = NULL; + catz->entries = newcatz->entries; + newcatz->entries = NULL; /* * We do not need to merge old coo (change of ownership) permission * records with the new ones, just replace them. */ - if (target->coos != NULL && newzone->coos != NULL) { + if (catz->coos != NULL && newcatz->coos != NULL) { isc_ht_iter_t *iter = NULL; - isc_ht_iter_create(target->coos, &iter); + isc_ht_iter_create(catz->coos, &iter); for (result = isc_ht_iter_first(iter); result == ISC_R_SUCCESS; result = isc_ht_iter_delcurrent_next(iter)) { dns_catz_coo_t *coo = NULL; isc_ht_iter_current(iter, (void **)&coo); - catz_coo_detach(target, &coo); + catz_coo_detach(catz, &coo); } INSIST(result == ISC_R_NOMORE); isc_ht_iter_destroy(&iter); /* The hashtable has to be empty now. */ - INSIST(isc_ht_count(target->coos) == 0); - isc_ht_destroy(&target->coos); + INSIST(isc_ht_count(catz->coos) == 0); + isc_ht_destroy(&catz->coos); - target->coos = newzone->coos; - newzone->coos = NULL; + catz->coos = newcatz->coos; + newcatz->coos = NULL; } result = ISC_R_SUCCESS; @@ -743,43 +735,40 @@ dns_catz_zones_merge(dns_catz_zone_t *target, dns_catz_zone_t *newzone) { } isc_result_t -dns_catz_new_zones(dns_catz_zones_t **catzsp, dns_catz_zonemodmethods_t *zmm, - isc_mem_t *mctx, isc_taskmgr_t *taskmgr, - isc_timermgr_t *timermgr) { - dns_catz_zones_t *new_zones; +dns_catz_new_zones(isc_mem_t *mctx, isc_taskmgr_t *taskmgr, + isc_timermgr_t *timermgr, dns_catz_zones_t **catzsp, + dns_catz_zonemodmethods_t *zmm) { isc_result_t result; + dns_catz_zones_t *catzs = NULL; + REQUIRE(mctx != NULL); + REQUIRE(taskmgr != NULL); + REQUIRE(timermgr != NULL); REQUIRE(catzsp != NULL && *catzsp == NULL); REQUIRE(zmm != NULL); - new_zones = isc_mem_get(mctx, sizeof(*new_zones)); - memset(new_zones, 0, sizeof(*new_zones)); + catzs = isc_mem_get(mctx, sizeof(*catzs)); + *catzs = (dns_catz_zones_t){ .taskmgr = taskmgr, + .timermgr = timermgr, + .zmm = zmm, + .magic = DNS_CATZ_ZONES_MAGIC }; - isc_mutex_init(&new_zones->lock); - - isc_refcount_init(&new_zones->refs, 1); - - isc_ht_init(&new_zones->zones, mctx, 4, ISC_HT_CASE_SENSITIVE); - - isc_mem_attach(mctx, &new_zones->mctx); - new_zones->zmm = zmm; - new_zones->timermgr = timermgr; - new_zones->taskmgr = taskmgr; - - result = isc_task_create(taskmgr, 0, &new_zones->updater); + result = isc_task_create(taskmgr, 0, &catzs->updater); if (result != ISC_R_SUCCESS) { - goto cleanup_ht; + goto cleanup_task; } - new_zones->magic = DNS_CATZ_ZONES_MAGIC; - *catzsp = new_zones; + isc_mutex_init(&catzs->lock); + isc_refcount_init(&catzs->references, 1); + isc_ht_init(&catzs->zones, mctx, 4, ISC_HT_CASE_SENSITIVE); + isc_mem_attach(mctx, &catzs->mctx); + + *catzsp = catzs; + return (ISC_R_SUCCESS); -cleanup_ht: - isc_ht_destroy(&new_zones->zones); - isc_refcount_destroy(&new_zones->refs); - isc_mutex_destroy(&new_zones->lock); - isc_mem_putanddetach(&new_zones->mctx, new_zones, sizeof(*new_zones)); +cleanup_task: + isc_mem_put(mctx, catzs, sizeof(*catzs)); return (result); } @@ -795,70 +784,58 @@ dns_catz_catzs_set_view(dns_catz_zones_t *catzs, dns_view_t *view) { } isc_result_t -dns_catz_new_zone(dns_catz_zones_t *catzs, dns_catz_zone_t **zonep, +dns_catz_new_zone(dns_catz_zones_t *catzs, dns_catz_zone_t **catzp, const dns_name_t *name) { isc_result_t result; - dns_catz_zone_t *new_zone; + dns_catz_zone_t *catz = NULL; REQUIRE(DNS_CATZ_ZONES_VALID(catzs)); - REQUIRE(zonep != NULL && *zonep == NULL); + REQUIRE(catzp != NULL && *catzp == NULL); REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC)); - new_zone = isc_mem_get(catzs->mctx, sizeof(*new_zone)); + catz = isc_mem_get(catzs->mctx, sizeof(*catz)); + *catz = (dns_catz_zone_t){ .catzs = catzs, + .active = true, + .version = DNS_CATZ_VERSION_UNDEFINED, + .magic = DNS_CATZ_ZONE_MAGIC }; - memset(new_zone, 0, sizeof(*new_zone)); - - dns_name_init(&new_zone->name, NULL); - dns_name_dup(name, catzs->mctx, &new_zone->name); - - isc_ht_init(&new_zone->entries, catzs->mctx, 4, ISC_HT_CASE_SENSITIVE); - isc_ht_init(&new_zone->coos, catzs->mctx, 4, ISC_HT_CASE_INSENSITIVE); - - new_zone->updatetimer = NULL; result = isc_timer_create(catzs->timermgr, isc_timertype_inactive, NULL, NULL, catzs->updater, - dns_catz_update_taskaction, new_zone, - &new_zone->updatetimer); + dns_catz_update_taskaction, catz, + &catz->updatetimer); if (result != ISC_R_SUCCESS) { - goto cleanup_ht; + goto cleanup_timer; } - isc_time_settoepoch(&new_zone->lastupdated); - new_zone->updatepending = false; - new_zone->db = NULL; - new_zone->dbversion = NULL; - new_zone->catzs = catzs; - dns_catz_options_init(&new_zone->defoptions); - dns_catz_options_init(&new_zone->zoneoptions); - new_zone->active = true; - new_zone->db_registered = false; - new_zone->version = DNS_CATZ_VERSION_UNDEFINED; - isc_refcount_init(&new_zone->refs, 1); - new_zone->magic = DNS_CATZ_ZONE_MAGIC; + isc_refcount_init(&catz->references, 1); + isc_ht_init(&catz->entries, catzs->mctx, 4, ISC_HT_CASE_SENSITIVE); + isc_ht_init(&catz->coos, catzs->mctx, 4, ISC_HT_CASE_INSENSITIVE); + isc_time_settoepoch(&catz->lastupdated); + dns_catz_options_init(&catz->defoptions); + dns_catz_options_init(&catz->zoneoptions); + dns_name_init(&catz->name, NULL); + dns_name_dup(name, catzs->mctx, &catz->name); - *zonep = new_zone; + *catzp = catz; return (ISC_R_SUCCESS); -cleanup_ht: - isc_ht_destroy(&new_zone->entries); - isc_ht_destroy(&new_zone->coos); - dns_name_free(&new_zone->name, catzs->mctx); - isc_mem_put(catzs->mctx, new_zone, sizeof(*new_zone)); +cleanup_timer: + isc_mem_put(catzs->mctx, catz, sizeof(*catz)); return (result); } isc_result_t dns_catz_add_zone(dns_catz_zones_t *catzs, const dns_name_t *name, - dns_catz_zone_t **zonep) { - dns_catz_zone_t *new_zone = NULL; + dns_catz_zone_t **catzp) { + dns_catz_zone_t *catz = NULL; isc_result_t result, tresult; char zname[DNS_NAME_FORMATSIZE]; REQUIRE(DNS_CATZ_ZONES_VALID(catzs)); REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC)); - REQUIRE(zonep != NULL && *zonep == NULL); + REQUIRE(catzp != NULL && *catzp == NULL); dns_name_format(name, zname, DNS_NAME_FORMATSIZE); isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, @@ -866,15 +843,15 @@ dns_catz_add_zone(dns_catz_zones_t *catzs, const dns_name_t *name, LOCK(&catzs->lock); - result = dns_catz_new_zone(catzs, &new_zone, name); + result = dns_catz_new_zone(catzs, &catz, name); if (result != ISC_R_SUCCESS) { goto cleanup; } - result = isc_ht_add(catzs->zones, new_zone->name.ndata, - new_zone->name.length, new_zone); + result = isc_ht_add(catzs->zones, catz->name.ndata, catz->name.length, + catz); if (result != ISC_R_SUCCESS) { - dns_catz_zone_detach(&new_zone); + dns_catz_detach_catz(&catz); if (result != ISC_R_EXISTS) { goto cleanup; } @@ -882,12 +859,12 @@ dns_catz_add_zone(dns_catz_zones_t *catzs, const dns_name_t *name, if (result == ISC_R_EXISTS) { tresult = isc_ht_find(catzs->zones, name->ndata, name->length, - (void **)&new_zone); - INSIST(tresult == ISC_R_SUCCESS && !new_zone->active); - new_zone->active = true; + (void **)&catz); + INSIST(tresult == ISC_R_SUCCESS && !catz->active); + catz->active = true; } - *zonep = new_zone; + *catzp = catz; cleanup: UNLOCK(&catzs->lock); @@ -912,130 +889,105 @@ dns_catz_get_zone(dns_catz_zones_t *catzs, const dns_name_t *name) { return (found); } -void -dns_catz_catzs_attach(dns_catz_zones_t *catzs, dns_catz_zones_t **catzsp) { - REQUIRE(DNS_CATZ_ZONES_VALID(catzs)); - REQUIRE(catzsp != NULL && *catzsp == NULL); +static void +dns__catz_zone_destroy(dns_catz_zone_t *catz) { + isc_mem_t *mctx = catz->catzs->mctx; - isc_refcount_increment(&catzs->refs); - *catzsp = catzs; -} + if (catz->entries != NULL) { + isc_ht_iter_t *iter = NULL; + isc_result_t result; + isc_ht_iter_create(catz->entries, &iter); + for (result = isc_ht_iter_first(iter); result == ISC_R_SUCCESS; + result = isc_ht_iter_delcurrent_next(iter)) + { + dns_catz_entry_t *entry = NULL; -void -dns_catz_zone_attach(dns_catz_zone_t *zone, dns_catz_zone_t **zonep) { - REQUIRE(zonep != NULL && *zonep == NULL); - - isc_refcount_increment(&zone->refs); - *zonep = zone; -} - -void -dns_catz_zone_detach(dns_catz_zone_t **zonep) { - REQUIRE(zonep != NULL && *zonep != NULL); - dns_catz_zone_t *zone = *zonep; - *zonep = NULL; - - if (isc_refcount_decrement(&zone->refs) == 1) { - isc_mem_t *mctx = zone->catzs->mctx; - isc_refcount_destroy(&zone->refs); - if (zone->entries != NULL) { - isc_ht_iter_t *iter = NULL; - isc_result_t result; - isc_ht_iter_create(zone->entries, &iter); - for (result = isc_ht_iter_first(iter); - result == ISC_R_SUCCESS; - result = isc_ht_iter_delcurrent_next(iter)) - { - dns_catz_entry_t *entry = NULL; - - isc_ht_iter_current(iter, (void **)&entry); - dns_catz_entry_detach(zone, &entry); - } - INSIST(result == ISC_R_NOMORE); - isc_ht_iter_destroy(&iter); - - /* The hashtable has to be empty now. */ - INSIST(isc_ht_count(zone->entries) == 0); - isc_ht_destroy(&zone->entries); + isc_ht_iter_current(iter, (void **)&entry); + dns_catz_entry_detach(catz, &entry); } - if (zone->coos != NULL) { - isc_ht_iter_t *iter = NULL; - isc_result_t result; - isc_ht_iter_create(zone->coos, &iter); - for (result = isc_ht_iter_first(iter); - result == ISC_R_SUCCESS; - result = isc_ht_iter_delcurrent_next(iter)) - { - dns_catz_coo_t *coo = NULL; + INSIST(result == ISC_R_NOMORE); + isc_ht_iter_destroy(&iter); - isc_ht_iter_current(iter, (void **)&coo); - catz_coo_detach(zone, &coo); - } - INSIST(result == ISC_R_NOMORE); - isc_ht_iter_destroy(&iter); - - /* The hashtable has to be empty now. */ - INSIST(isc_ht_count(zone->coos) == 0); - isc_ht_destroy(&zone->coos); - } - zone->magic = 0; - isc_timer_destroy(&zone->updatetimer); - if (zone->db_registered) { - dns_db_updatenotify_unregister( - zone->db, dns_catz_dbupdate_callback, - zone->catzs); - } - if (zone->dbversion) { - dns_db_closeversion(zone->db, &zone->dbversion, false); - } - if (zone->db != NULL) { - dns_db_detach(&zone->db); - } - - dns_name_free(&zone->name, mctx); - dns_catz_options_free(&zone->defoptions, mctx); - dns_catz_options_free(&zone->zoneoptions, mctx); - - zone->catzs = NULL; - isc_mem_put(mctx, zone, sizeof(dns_catz_zone_t)); + /* The hashtable has to be empty now. */ + INSIST(isc_ht_count(catz->entries) == 0); + isc_ht_destroy(&catz->entries); } -} + if (catz->coos != NULL) { + isc_ht_iter_t *iter = NULL; + isc_result_t result; + isc_ht_iter_create(catz->coos, &iter); + for (result = isc_ht_iter_first(iter); result == ISC_R_SUCCESS; + result = isc_ht_iter_delcurrent_next(iter)) + { + dns_catz_coo_t *coo = NULL; -void -dns_catz_catzs_detach(dns_catz_zones_t **catzsp) { - dns_catz_zones_t *catzs; - - REQUIRE(catzsp != NULL && DNS_CATZ_ZONES_VALID(*catzsp)); - - catzs = *catzsp; - *catzsp = NULL; - - if (isc_refcount_decrement(&catzs->refs) == 1) { - catzs->magic = 0; - isc_task_destroy(&catzs->updater); - isc_mutex_destroy(&catzs->lock); - if (catzs->zones != NULL) { - isc_ht_iter_t *iter = NULL; - isc_result_t result; - isc_ht_iter_create(catzs->zones, &iter); - for (result = isc_ht_iter_first(iter); - result == ISC_R_SUCCESS;) - { - dns_catz_zone_t *zone = NULL; - isc_ht_iter_current(iter, (void **)&zone); - result = isc_ht_iter_delcurrent_next(iter); - dns_catz_zone_detach(&zone); - } - INSIST(result == ISC_R_NOMORE); - isc_ht_iter_destroy(&iter); - INSIST(isc_ht_count(catzs->zones) == 0); - isc_ht_destroy(&catzs->zones); + isc_ht_iter_current(iter, (void **)&coo); + catz_coo_detach(catz, &coo); } - isc_refcount_destroy(&catzs->refs); - isc_mem_putanddetach(&catzs->mctx, catzs, sizeof(*catzs)); + INSIST(result == ISC_R_NOMORE); + isc_ht_iter_destroy(&iter); + + /* The hashtable has to be empty now. */ + INSIST(isc_ht_count(catz->coos) == 0); + isc_ht_destroy(&catz->coos); } + catz->magic = 0; + isc_timer_destroy(&catz->updatetimer); + if (catz->db_registered) { + dns_db_updatenotify_unregister( + catz->db, dns_catz_dbupdate_callback, catz->catzs); + } + if (catz->dbversion != NULL) { + dns_db_closeversion(catz->db, &catz->dbversion, false); + } + if (catz->db != NULL) { + dns_db_detach(&catz->db); + } + + dns_name_free(&catz->name, mctx); + dns_catz_options_free(&catz->defoptions, mctx); + dns_catz_options_free(&catz->zoneoptions, mctx); + + catz->catzs = NULL; + isc_refcount_destroy(&catz->references); + + isc_mem_put(mctx, catz, sizeof(*catz)); } +static void +dns__catz_zones_destroy(dns_catz_zones_t *catzs) { + if (catzs->zones != NULL) { + isc_ht_iter_t *iter = NULL; + isc_result_t result; + isc_ht_iter_create(catzs->zones, &iter); + for (result = isc_ht_iter_first(iter); result == ISC_R_SUCCESS;) + { + dns_catz_zone_t *zone = NULL; + isc_ht_iter_current(iter, (void **)&zone); + result = isc_ht_iter_delcurrent_next(iter); + dns_catz_detach_catz(&zone); + } + INSIST(result == ISC_R_NOMORE); + isc_ht_iter_destroy(&iter); + INSIST(isc_ht_count(catzs->zones) == 0); + isc_ht_destroy(&catzs->zones); + } + catzs->magic = 0; + isc_task_destroy(&catzs->updater); + isc_mutex_destroy(&catzs->lock); + isc_refcount_destroy(&catzs->references); + + isc_mem_putanddetach(&catzs->mctx, catzs, sizeof(*catzs)); +} + +#ifdef DNS_CATZ_TRACE +ISC_REFCOUNT_TRACE_IMPL(dns_catz_zone, dns__catz_zone_destroy); +ISC_REFCOUNT_TRACE_IMPL(dns_catz_zones, dns__catz_zones_destroy); +#else +ISC_REFCOUNT_IMPL(dns_catz_zone, dns__catz_zone_destroy); +ISC_REFCOUNT_IMPL(dns_catz_zones, dns__catz_zones_destroy); +#endif + typedef enum { CATZ_OPT_NONE, CATZ_OPT_ZONES, @@ -1085,12 +1037,12 @@ catz_get_option(const dns_label_t *option) { } static isc_result_t -catz_process_zones(dns_catz_zone_t *zone, dns_rdataset_t *value, +catz_process_zones(dns_catz_zone_t *catz, dns_rdataset_t *value, dns_name_t *name) { dns_label_t mhash; dns_name_t opt; - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); REQUIRE(DNS_RDATASET_VALID(value)); REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC)); @@ -1101,17 +1053,17 @@ catz_process_zones(dns_catz_zone_t *zone, dns_rdataset_t *value, dns_name_getlabel(name, name->labels - 1, &mhash); if (name->labels == 1) { - return (catz_process_zones_entry(zone, value, &mhash)); + return (catz_process_zones_entry(catz, value, &mhash)); } else { dns_name_init(&opt, NULL); dns_name_split(name, 1, &opt, NULL); - return (catz_process_zones_suboption(zone, value, &mhash, + return (catz_process_zones_suboption(catz, value, &mhash, &opt)); } } static isc_result_t -catz_process_coo(dns_catz_zone_t *zone, dns_label_t *mhash, +catz_process_coo(dns_catz_zone_t *catz, dns_label_t *mhash, dns_rdataset_t *value) { isc_result_t result; dns_rdata_t rdata; @@ -1120,12 +1072,12 @@ catz_process_coo(dns_catz_zone_t *zone, dns_label_t *mhash, dns_catz_coo_t *ncoo = NULL; dns_catz_coo_t *ocoo = NULL; - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); REQUIRE(mhash != NULL); REQUIRE(DNS_RDATASET_VALID(value)); /* Change of Ownership was introduced in version "2" of the schema. */ - if (zone->version < 2) { + if (catz->version < 2) { return (ISC_R_FAILURE); } @@ -1138,7 +1090,7 @@ catz_process_coo(dns_catz_zone_t *zone, dns_label_t *mhash, DNS_LOGMODULE_MASTER, ISC_LOG_WARNING, "catz: 'coo' property PTR RRset contains " "more than one record, which is invalid"); - zone->broken = true; + catz->broken = true; return (ISC_R_FAILURE); } @@ -1160,7 +1112,7 @@ catz_process_coo(dns_catz_zone_t *zone, dns_label_t *mhash, goto cleanup; } - result = isc_ht_find(zone->entries, mhash->base, mhash->length, + result = isc_ht_find(catz->entries, mhash->base, mhash->length, (void **)&entry); if (result != ISC_R_SUCCESS) { /* The entry was not found .*/ @@ -1172,18 +1124,18 @@ catz_process_coo(dns_catz_zone_t *zone, dns_label_t *mhash, goto cleanup; } - result = isc_ht_find(zone->coos, entry->name.ndata, entry->name.length, + result = isc_ht_find(catz->coos, entry->name.ndata, entry->name.length, (void **)&ocoo); if (result == ISC_R_SUCCESS) { /* The change of ownership permission was already registered. */ goto cleanup; } - catz_coo_new(zone->catzs->mctx, &ptr.ptr, &ncoo); - result = isc_ht_add(zone->coos, entry->name.ndata, entry->name.length, + catz_coo_new(catz->catzs->mctx, &ptr.ptr, &ncoo); + result = isc_ht_add(catz->coos, entry->name.ndata, entry->name.length, ncoo); if (result != ISC_R_SUCCESS) { - catz_coo_detach(zone, &ncoo); + catz_coo_detach(catz, &ncoo); } cleanup: @@ -1193,7 +1145,7 @@ cleanup: } static isc_result_t -catz_process_zones_entry(dns_catz_zone_t *zone, dns_rdataset_t *value, +catz_process_zones_entry(dns_catz_zone_t *catz, dns_rdataset_t *value, dns_label_t *mhash) { isc_result_t result; dns_rdata_t rdata; @@ -1209,7 +1161,7 @@ catz_process_zones_entry(dns_catz_zone_t *zone, dns_rdataset_t *value, DNS_LOGMODULE_MASTER, ISC_LOG_WARNING, "catz: member zone PTR RRset contains " "more than one record, which is invalid"); - zone->broken = true; + catz->broken = true; return (ISC_R_FAILURE); } @@ -1226,7 +1178,7 @@ catz_process_zones_entry(dns_catz_zone_t *zone, dns_rdataset_t *value, return (result); } - result = isc_ht_find(zone->entries, mhash->base, mhash->length, + result = isc_ht_find(catz->entries, mhash->base, mhash->length, (void **)&entry); if (result == ISC_R_SUCCESS) { if (dns_name_countlabels(&entry->name) != 0) { @@ -1234,16 +1186,16 @@ catz_process_zones_entry(dns_catz_zone_t *zone, dns_rdataset_t *value, dns_rdata_freestruct(&ptr); return (ISC_R_FAILURE); } else { - dns_name_dup(&ptr.ptr, zone->catzs->mctx, &entry->name); + dns_name_dup(&ptr.ptr, catz->catzs->mctx, &entry->name); } } else { - dns_catz_entry_new(zone->catzs->mctx, &ptr.ptr, &entry); + dns_catz_entry_new(catz->catzs->mctx, &ptr.ptr, &entry); - result = isc_ht_add(zone->entries, mhash->base, mhash->length, + result = isc_ht_add(catz->entries, mhash->base, mhash->length, entry); if (result != ISC_R_SUCCESS) { dns_rdata_freestruct(&ptr); - dns_catz_entry_detach(zone, &entry); + dns_catz_entry_detach(catz, &entry); return (result); } } @@ -1254,7 +1206,7 @@ catz_process_zones_entry(dns_catz_zone_t *zone, dns_rdataset_t *value, } static isc_result_t -catz_process_version(dns_catz_zone_t *zone, dns_rdataset_t *value) { +catz_process_version(dns_catz_zone_t *catz, dns_rdataset_t *value) { isc_result_t result; dns_rdata_t rdata; dns_rdata_txt_t rdatatxt; @@ -1262,7 +1214,7 @@ catz_process_version(dns_catz_zone_t *zone, dns_rdataset_t *value) { uint32_t tversion; char t[16]; - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); REQUIRE(DNS_RDATASET_VALID(value)); if (value->type != dns_rdatatype_txt) { @@ -1274,7 +1226,7 @@ catz_process_version(dns_catz_zone_t *zone, dns_rdataset_t *value) { DNS_LOGMODULE_MASTER, ISC_LOG_WARNING, "catz: 'version' property TXT RRset contains " "more than one record, which is invalid"); - zone->broken = true; + catz->broken = true; return (ISC_R_FAILURE); } @@ -1316,7 +1268,7 @@ catz_process_version(dns_catz_zone_t *zone, dns_rdataset_t *value) { if (result != ISC_R_SUCCESS) { goto cleanup; } - zone->version = tversion; + catz->version = tversion; result = ISC_R_SUCCESS; cleanup: @@ -1326,13 +1278,13 @@ cleanup: DNS_LOGMODULE_MASTER, ISC_LOG_WARNING, "catz: invalid record for the catalog " "zone version property"); - zone->broken = true; + catz->broken = true; } return (result); } static isc_result_t -catz_process_primaries(dns_catz_zone_t *zone, dns_ipkeylist_t *ipkl, +catz_process_primaries(dns_catz_zone_t *catz, dns_ipkeylist_t *ipkl, dns_rdataset_t *value, dns_name_t *name) { isc_result_t result; dns_rdata_t rdata; @@ -1346,13 +1298,13 @@ catz_process_primaries(dns_catz_zone_t *zone, dns_ipkeylist_t *ipkl, isc_buffer_t keybuf; unsigned int rcount; - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); REQUIRE(ipkl != NULL); REQUIRE(DNS_RDATASET_VALID(value)); REQUIRE(dns_rdataset_isassociated(value)); REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC)); - mctx = zone->catzs->mctx; + mctx = catz->catzs->mctx; memset(&rdata_a, 0, sizeof(rdata_a)); memset(&rdata_aaaa, 0, sizeof(rdata_aaaa)); memset(&rdata_txt, 0, sizeof(rdata_txt)); @@ -1413,7 +1365,7 @@ catz_process_primaries(dns_catz_zone_t *zone, dns_ipkeylist_t *ipkl, } /* rdatastr.length < DNS_NAME_MAXTEXT */ - keyname = isc_mem_get(mctx, sizeof(dns_name_t)); + keyname = isc_mem_get(mctx, sizeof(*keyname)); dns_name_init(keyname, 0); memmove(keycbuf, rdatastr.data, rdatastr.length); keycbuf[rdatastr.length] = 0; @@ -1421,7 +1373,7 @@ catz_process_primaries(dns_catz_zone_t *zone, dns_ipkeylist_t *ipkl, result = dns_name_fromstring(keyname, keycbuf, 0, mctx); if (result != ISC_R_SUCCESS) { dns_name_free(keyname, mctx); - isc_mem_put(mctx, keyname, sizeof(dns_name_t)); + isc_mem_put(mctx, keyname, sizeof(*keyname)); return (result); } break; @@ -1447,7 +1399,7 @@ catz_process_primaries(dns_catz_zone_t *zone, dns_ipkeylist_t *ipkl, ipkl->keys[i] = keyname; } else { /* A/AAAA */ memmove(&ipkl->addrs[i], &sockaddr, - sizeof(isc_sockaddr_t)); + sizeof(sockaddr)); } } else { result = dns_ipkeylist_resize(mctx, ipkl, i + 1); @@ -1455,7 +1407,8 @@ catz_process_primaries(dns_catz_zone_t *zone, dns_ipkeylist_t *ipkl, return (result); } - ipkl->labels[i] = isc_mem_get(mctx, sizeof(dns_name_t)); + ipkl->labels[i] = isc_mem_get(mctx, + sizeof(*ipkl->labels[0])); dns_name_init(ipkl->labels[i], NULL); dns_name_dup(name, mctx, ipkl->labels[i]); @@ -1463,7 +1416,7 @@ catz_process_primaries(dns_catz_zone_t *zone, dns_ipkeylist_t *ipkl, ipkl->keys[i] = keyname; } else { /* A/AAAA */ memmove(&ipkl->addrs[i], &sockaddr, - sizeof(isc_sockaddr_t)); + sizeof(sockaddr)); } ipkl->count++; } @@ -1512,7 +1465,7 @@ catz_process_primaries(dns_catz_zone_t *zone, dns_ipkeylist_t *ipkl, } static isc_result_t -catz_process_apl(dns_catz_zone_t *zone, isc_buffer_t **aclbp, +catz_process_apl(dns_catz_zone_t *catz, isc_buffer_t **aclbp, dns_rdataset_t *value) { isc_result_t result = ISC_R_SUCCESS; dns_rdata_t rdata; @@ -1522,7 +1475,7 @@ catz_process_apl(dns_catz_zone_t *zone, isc_buffer_t **aclbp, isc_buffer_t *aclb = NULL; unsigned char buf[256]; /* larger than INET6_ADDRSTRLEN */ - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); REQUIRE(aclbp != NULL); REQUIRE(*aclbp == NULL); REQUIRE(DNS_RDATASET_VALID(value)); @@ -1542,11 +1495,11 @@ catz_process_apl(dns_catz_zone_t *zone, isc_buffer_t **aclbp, RUNTIME_CHECK(result == ISC_R_SUCCESS); dns_rdata_init(&rdata); dns_rdataset_current(value, &rdata); - result = dns_rdata_tostruct(&rdata, &rdata_apl, zone->catzs->mctx); + result = dns_rdata_tostruct(&rdata, &rdata_apl, catz->catzs->mctx); if (result != ISC_R_SUCCESS) { return (result); } - isc_buffer_allocate(zone->catzs->mctx, &aclb, 16); + isc_buffer_allocate(catz->catzs->mctx, &aclb, 16); isc_buffer_setautorealloc(aclb, true); for (result = dns_rdata_apl_first(&rdata_apl); result == ISC_R_SUCCESS; result = dns_rdata_apl_next(&rdata_apl)) @@ -1594,7 +1547,7 @@ cleanup: } static isc_result_t -catz_process_zones_suboption(dns_catz_zone_t *zone, dns_rdataset_t *value, +catz_process_zones_suboption(dns_catz_zone_t *catz, dns_rdataset_t *value, dns_label_t *mhash, dns_name_t *name) { isc_result_t result; dns_catz_entry_t *entry = NULL; @@ -1603,7 +1556,7 @@ catz_process_zones_suboption(dns_catz_zone_t *zone, dns_rdataset_t *value, catz_opt_t opt; unsigned int suffix_labels = 1; - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); REQUIRE(mhash != NULL); REQUIRE(DNS_RDATASET_VALID(value)); REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC)); @@ -1618,7 +1571,7 @@ catz_process_zones_suboption(dns_catz_zone_t *zone, dns_rdataset_t *value, * The custom properties in version 2 schema must be placed under the * "ext" label. */ - if (zone->version >= 2 && opt >= CATZ_OPT_CUSTOM_START) { + if (catz->version >= 2 && opt >= CATZ_OPT_CUSTOM_START) { if (opt != CATZ_OPT_EXT || name->labels < 2) { return (ISC_R_FAILURE); } @@ -1631,14 +1584,14 @@ catz_process_zones_suboption(dns_catz_zone_t *zone, dns_rdataset_t *value, * We're adding this entry now, in case the option is invalid we'll get * rid of it in verification phase. */ - result = isc_ht_find(zone->entries, mhash->base, mhash->length, + result = isc_ht_find(catz->entries, mhash->base, mhash->length, (void **)&entry); if (result != ISC_R_SUCCESS) { - dns_catz_entry_new(zone->catzs->mctx, NULL, &entry); - result = isc_ht_add(zone->entries, mhash->base, mhash->length, + dns_catz_entry_new(catz->catzs->mctx, NULL, &entry); + result = isc_ht_add(catz->entries, mhash->base, mhash->length, entry); if (result != ISC_R_SUCCESS) { - dns_catz_entry_detach(zone, &entry); + dns_catz_entry_detach(catz, &entry); return (result); } } @@ -1647,21 +1600,21 @@ catz_process_zones_suboption(dns_catz_zone_t *zone, dns_rdataset_t *value, dns_name_split(name, suffix_labels, &prefix, NULL); switch (opt) { case CATZ_OPT_COO: - return (catz_process_coo(zone, mhash, value)); + return (catz_process_coo(catz, mhash, value)); case CATZ_OPT_PRIMARIES: - return (catz_process_primaries(zone, &entry->opts.masters, + return (catz_process_primaries(catz, &entry->opts.masters, value, &prefix)); case CATZ_OPT_ALLOW_QUERY: if (prefix.labels != 0) { return (ISC_R_FAILURE); } - return (catz_process_apl(zone, &entry->opts.allow_query, + return (catz_process_apl(catz, &entry->opts.allow_query, value)); case CATZ_OPT_ALLOW_TRANSFER: if (prefix.labels != 0) { return (ISC_R_FAILURE); } - return (catz_process_apl(zone, &entry->opts.allow_transfer, + return (catz_process_apl(catz, &entry->opts.allow_transfer, value)); default: return (ISC_R_FAILURE); @@ -1671,7 +1624,7 @@ catz_process_zones_suboption(dns_catz_zone_t *zone, dns_rdataset_t *value, } static void -catz_entry_add_or_mod(dns_catz_zone_t *target, isc_ht_t *ht, unsigned char *key, +catz_entry_add_or_mod(dns_catz_zone_t *catz, isc_ht_t *ht, unsigned char *key, size_t keysize, dns_catz_entry_t *nentry, dns_catz_entry_t *oentry, const char *msg, const char *zname, const char *czname) { @@ -1684,21 +1637,21 @@ catz_entry_add_or_mod(dns_catz_zone_t *target, isc_ht_t *ht, unsigned char *key, msg, zname, czname, isc_result_totext(result)); } if (oentry != NULL) { - dns_catz_entry_detach(target, &oentry); - result = isc_ht_delete(target->entries, key, (uint32_t)keysize); + dns_catz_entry_detach(catz, &oentry); + result = isc_ht_delete(catz->entries, key, (uint32_t)keysize); RUNTIME_CHECK(result == ISC_R_SUCCESS); } } static isc_result_t -catz_process_value(dns_catz_zone_t *zone, dns_name_t *name, +catz_process_value(dns_catz_zone_t *catz, dns_name_t *name, dns_rdataset_t *rdataset) { dns_label_t option; dns_name_t prefix; catz_opt_t opt; unsigned int suffix_labels = 1; - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC)); REQUIRE(DNS_RDATASET_VALID(rdataset)); @@ -1712,7 +1665,7 @@ catz_process_value(dns_catz_zone_t *zone, dns_name_t *name, * The custom properties in version 2 schema must be placed under the * "ext" label. */ - if (zone->version >= 2 && opt >= CATZ_OPT_CUSTOM_START) { + if (catz->version >= 2 && opt >= CATZ_OPT_CUSTOM_START) { if (opt != CATZ_OPT_EXT || name->labels < 2) { return (ISC_R_FAILURE); } @@ -1726,34 +1679,34 @@ catz_process_value(dns_catz_zone_t *zone, dns_name_t *name, switch (opt) { case CATZ_OPT_ZONES: - return (catz_process_zones(zone, rdataset, &prefix)); + return (catz_process_zones(catz, rdataset, &prefix)); case CATZ_OPT_PRIMARIES: - return (catz_process_primaries(zone, &zone->zoneoptions.masters, + return (catz_process_primaries(catz, &catz->zoneoptions.masters, rdataset, &prefix)); case CATZ_OPT_ALLOW_QUERY: if (prefix.labels != 0) { return (ISC_R_FAILURE); } - return (catz_process_apl(zone, &zone->zoneoptions.allow_query, + return (catz_process_apl(catz, &catz->zoneoptions.allow_query, rdataset)); case CATZ_OPT_ALLOW_TRANSFER: if (prefix.labels != 0) { return (ISC_R_FAILURE); } return (catz_process_apl( - zone, &zone->zoneoptions.allow_transfer, rdataset)); + catz, &catz->zoneoptions.allow_transfer, rdataset)); case CATZ_OPT_VERSION: if (prefix.labels != 0) { return (ISC_R_FAILURE); } - return (catz_process_version(zone, rdataset)); + return (catz_process_version(catz, rdataset)); default: return (ISC_R_FAILURE); } } isc_result_t -dns_catz_update_process(dns_catz_zones_t *catzs, dns_catz_zone_t *zone, +dns_catz_update_process(dns_catz_zones_t *catzs, dns_catz_zone_t *catz, const dns_name_t *src_name, dns_rdataset_t *rdataset) { isc_result_t result; int order; @@ -1764,18 +1717,18 @@ dns_catz_update_process(dns_catz_zones_t *catzs, dns_catz_zone_t *zone, dns_name_t prefix; REQUIRE(DNS_CATZ_ZONES_VALID(catzs)); - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); REQUIRE(ISC_MAGIC_VALID(src_name, DNS_NAME_MAGIC)); if (rdataset->rdclass != dns_rdataclass_in) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_ERROR, "catz: RR found which has a non-IN class"); - zone->broken = true; + catz->broken = true; return (ISC_R_FAILURE); } - nrres = dns_name_fullcompare(src_name, &zone->name, &order, &nlabels); + nrres = dns_name_fullcompare(src_name, &catz->name, &order, &nlabels); if (nrres == dns_namereln_equal) { if (rdataset->type == dns_rdatatype_soa) { result = dns_rdataset_first(rdataset); @@ -1802,8 +1755,8 @@ dns_catz_update_process(dns_catz_zones_t *catzs, dns_catz_zone_t *zone, } dns_name_init(&prefix, NULL); - dns_name_split(src_name, zone->name.labels, &prefix, NULL); - result = catz_process_value(zone, &prefix, rdataset); + dns_name_split(src_name, catz->name.labels, &prefix, NULL); + result = catz_process_value(catz, &prefix, rdataset); return (result); } @@ -1823,7 +1776,7 @@ digest2hex(unsigned char *digest, unsigned int digestlen, char *hash, } isc_result_t -dns_catz_generate_masterfilename(dns_catz_zone_t *zone, dns_catz_entry_t *entry, +dns_catz_generate_masterfilename(dns_catz_zone_t *catz, dns_catz_entry_t *entry, isc_buffer_t **buffer) { isc_buffer_t *tbuf = NULL; isc_region_t r; @@ -1831,17 +1784,17 @@ dns_catz_generate_masterfilename(dns_catz_zone_t *zone, dns_catz_entry_t *entry, size_t rlen; bool special = false; - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); REQUIRE(DNS_CATZ_ENTRY_VALID(entry)); REQUIRE(buffer != NULL && *buffer != NULL); - isc_buffer_allocate(zone->catzs->mctx, &tbuf, - strlen(zone->catzs->view->name) + + isc_buffer_allocate(catz->catzs->mctx, &tbuf, + strlen(catz->catzs->view->name) + 2 * DNS_NAME_FORMATSIZE + 2); - isc_buffer_putstr(tbuf, zone->catzs->view->name); + isc_buffer_putstr(tbuf, catz->catzs->view->name); isc_buffer_putstr(tbuf, "_"); - result = dns_name_totext(&zone->name, true, tbuf); + result = dns_name_totext(&catz->name, true, tbuf); if (result != ISC_R_SUCCESS) { goto cleanup; } @@ -1919,7 +1872,7 @@ cleanup: * } */ isc_result_t -dns_catz_generate_zonecfg(dns_catz_zone_t *zone, dns_catz_entry_t *entry, +dns_catz_generate_zonecfg(dns_catz_zone_t *catz, dns_catz_entry_t *entry, isc_buffer_t **buf) { isc_buffer_t *buffer = NULL; isc_region_t region; @@ -1929,7 +1882,7 @@ dns_catz_generate_zonecfg(dns_catz_zone_t *zone, dns_catz_entry_t *entry, char pbuf[sizeof("65535")]; /* used for port number */ char zname[DNS_NAME_FORMATSIZE]; - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); REQUIRE(DNS_CATZ_ENTRY_VALID(entry)); REQUIRE(buf != NULL && *buf == NULL); @@ -1937,7 +1890,7 @@ dns_catz_generate_zonecfg(dns_catz_zone_t *zone, dns_catz_entry_t *entry, * The buffer will be reallocated if something won't fit, * ISC_BUFFER_INCR seems like a good start. */ - isc_buffer_allocate(zone->catzs->mctx, &buffer, ISC_BUFFER_INCR); + isc_buffer_allocate(catz->catzs->mctx, &buffer, ISC_BUFFER_INCR); isc_buffer_setautorealloc(buffer, true); isc_buffer_putstr(buffer, "zone \""); @@ -1997,7 +1950,7 @@ dns_catz_generate_zonecfg(dns_catz_zone_t *zone, dns_catz_entry_t *entry, isc_buffer_putstr(buffer, "}; "); if (!entry->opts.in_memory) { isc_buffer_putstr(buffer, "file \""); - result = dns_catz_generate_masterfilename(zone, entry, &buffer); + result = dns_catz_generate_masterfilename(catz, entry, &buffer); if (result != ISC_R_SUCCESS) { goto cleanup; } @@ -2029,78 +1982,84 @@ cleanup: void dns_catz_update_taskaction(isc_task_t *task, isc_event_t *event) { isc_result_t result; - dns_catz_zone_t *zone; + dns_catz_zone_t *catz; (void)task; REQUIRE(event != NULL); - zone = event->ev_arg; - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); + catz = event->ev_arg; + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); - LOCK(&zone->catzs->lock); - zone->updatepending = false; - dns_catz_update_from_db(zone->db, zone->catzs); - result = isc_timer_reset(zone->updatetimer, isc_timertype_inactive, + LOCK(&catz->catzs->lock); + catz->updatepending = false; + dns_catz_update_from_db(catz->db, catz->catzs); + result = isc_timer_reset(catz->updatetimer, isc_timertype_inactive, NULL, NULL, true); RUNTIME_CHECK(result == ISC_R_SUCCESS); isc_event_free(&event); - result = isc_time_now(&zone->lastupdated); + result = isc_time_now(&catz->lastupdated); RUNTIME_CHECK(result == ISC_R_SUCCESS); - UNLOCK(&zone->catzs->lock); + UNLOCK(&catz->catzs->lock); } isc_result_t dns_catz_dbupdate_callback(dns_db_t *db, void *fn_arg) { - dns_catz_zones_t *catzs; - dns_catz_zone_t *zone = NULL; + dns_catz_zones_t *catzs = (dns_catz_zones_t *)fn_arg; + dns_catz_zone_t *catz = NULL; isc_time_t now; - uint64_t tdiff; isc_result_t result = ISC_R_SUCCESS; isc_region_t r; + char dname[DNS_NAME_FORMATSIZE]; REQUIRE(DNS_DB_VALID(db)); - REQUIRE(DNS_CATZ_ZONES_VALID(fn_arg)); - catzs = (dns_catz_zones_t *)fn_arg; + REQUIRE(DNS_CATZ_ZONES_VALID(catzs)); dns_name_toregion(&db->origin, &r); LOCK(&catzs->lock); - result = isc_ht_find(catzs->zones, r.base, r.length, (void **)&zone); + result = isc_ht_find(catzs->zones, r.base, r.length, (void **)&catz); if (result != ISC_R_SUCCESS) { goto cleanup; } /* New zone came as AXFR */ - if (zone->db != NULL && zone->db != db) { - if (zone->dbversion != NULL) { - dns_db_closeversion(zone->db, &zone->dbversion, false); + if (catz->db != NULL && catz->db != db) { + if (catz->dbversion != NULL) { + dns_db_closeversion(catz->db, &catz->dbversion, false); } - dns_db_detach(&zone->db); + dns_db_detach(&catz->db); /* * We're not registering db update callback, it will be * registered at the end of update_from_db */ - zone->db_registered = false; + catz->db_registered = false; } - if (zone->db == NULL) { - dns_db_attach(db, &zone->db); + if (catz->db == NULL) { + dns_db_attach(db, &catz->db); } - if (!zone->updatepending) { - zone->updatepending = true; + dns_name_format(&catz->name, dname, DNS_NAME_FORMATSIZE); + + if (!catz->updatepending) { + uint64_t tdiff; + + catz->updatepending = true; + isc_time_now(&now); - tdiff = isc_time_microdiff(&now, &zone->lastupdated) / 1000000; - if (tdiff < zone->defoptions.min_update_interval) { + tdiff = isc_time_microdiff(&now, &catz->lastupdated) / 1000000; + if (tdiff < catz->defoptions.min_update_interval) { + uint64_t defer = catz->defoptions.min_update_interval - + tdiff; isc_interval_t interval; + isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_INFO, - "catz: new zone version came too soon, " - "deferring update"); - isc_interval_set(&interval, - zone->defoptions.min_update_interval - - (unsigned int)tdiff, - 0); - dns_db_currentversion(db, &zone->dbversion); - result = isc_timer_reset(zone->updatetimer, + "catz: %s: new zone version came " + "too soon, deferring update for " + "%" PRIu64 " seconds", + dname, defer); + isc_interval_set(&interval, (unsigned int)defer, 0); + dns_db_currentversion(db, &catz->dbversion); + result = isc_timer_reset(catz->updatetimer, isc_timertype_once, NULL, &interval, true); if (result != ISC_R_SUCCESS) { @@ -2109,23 +2068,23 @@ dns_catz_dbupdate_callback(dns_db_t *db, void *fn_arg) { } else { isc_event_t *event; - dns_db_currentversion(db, &zone->dbversion); - ISC_EVENT_INIT(&zone->updateevent, - sizeof(zone->updateevent), 0, NULL, + dns_db_currentversion(db, &catz->dbversion); + ISC_EVENT_INIT(&catz->updateevent, + sizeof(catz->updateevent), 0, NULL, DNS_EVENT_CATZUPDATED, - dns_catz_update_taskaction, zone, zone, + dns_catz_update_taskaction, catz, catz, NULL, NULL); - event = &zone->updateevent; + event = &catz->updateevent; isc_task_send(catzs->updater, &event); } } else { isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_DEBUG(3), "catz: update already queued"); - if (zone->dbversion != NULL) { - dns_db_closeversion(zone->db, &zone->dbversion, false); + if (catz->dbversion != NULL) { + dns_db_closeversion(catz->db, &catz->dbversion, false); } - dns_db_currentversion(zone->db, &zone->dbversion); + dns_db_currentversion(catz->db, &catz->dbversion); } cleanup: @@ -2142,7 +2101,7 @@ catz_rdatatype_is_processable(const dns_rdatatype_t type) { void dns_catz_update_from_db(dns_db_t *db, dns_catz_zones_t *catzs) { - dns_catz_zone_t *oldzone = NULL, *newzone = NULL; + dns_catz_zone_t *oldcatz = NULL, *newcatz = NULL; isc_result_t result; isc_region_t r; dns_dbnode_t *node = NULL; @@ -2167,7 +2126,7 @@ dns_catz_update_from_db(dns_db_t *db, dns_catz_zones_t *catzs) { * Create a new catz in the same context as current catz. */ dns_name_toregion(&db->origin, &r); - result = isc_ht_find(catzs->zones, r.base, r.length, (void **)&oldzone); + result = isc_ht_find(catzs->zones, r.base, r.length, (void **)&oldcatz); if (result != ISC_R_SUCCESS) { /* This can happen if we remove the zone in the meantime. */ isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, @@ -2176,7 +2135,7 @@ dns_catz_update_from_db(dns_db_t *db, dns_catz_zones_t *catzs) { return; } - result = dns_db_getsoaserial(db, oldzone->dbversion, &vers); + result = dns_db_getsoaserial(db, oldcatz->dbversion, &vers); if (result != ISC_R_SUCCESS) { /* A zone without SOA record?!? */ isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, @@ -2191,9 +2150,9 @@ dns_catz_update_from_db(dns_db_t *db, dns_catz_zones_t *catzs) { "catz: updating catalog zone '%s' with serial %" PRIu32, bname, vers); - result = dns_catz_new_zone(catzs, &newzone, &db->origin); + result = dns_catz_new_zone(catzs, &newcatz, &db->origin); if (result != ISC_R_SUCCESS) { - dns_db_closeversion(db, &oldzone->dbversion, false); + dns_db_closeversion(db, &oldcatz->dbversion, false); isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_ERROR, "catz: failed to create new zone - %s", @@ -2203,8 +2162,8 @@ dns_catz_update_from_db(dns_db_t *db, dns_catz_zones_t *catzs) { result = dns_db_createiterator(db, DNS_DB_NONSEC3, &it); if (result != ISC_R_SUCCESS) { - dns_catz_zone_detach(&newzone); - dns_db_closeversion(db, &oldzone->dbversion, false); + dns_catz_detach_catz(&newcatz); + dns_db_closeversion(db, &oldcatz->dbversion, false); isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_ERROR, "catz: failed to create DB iterator - %s", @@ -2222,8 +2181,8 @@ dns_catz_update_from_db(dns_db_t *db, dns_catz_zones_t *catzs) { result = dns_name_fromstring2(name, "version", &db->origin, 0, NULL); if (result != ISC_R_SUCCESS) { dns_dbiterator_destroy(&it); - dns_catz_zone_detach(&newzone); - dns_db_closeversion(db, &oldzone->dbversion, false); + dns_catz_detach_catz(&newcatz); + dns_db_closeversion(db, &oldcatz->dbversion, false); isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_ERROR, "catz: failed to create name from string - %s", @@ -2233,12 +2192,12 @@ dns_catz_update_from_db(dns_db_t *db, dns_catz_zones_t *catzs) { result = dns_dbiterator_seek(it, name); if (result != ISC_R_SUCCESS) { dns_dbiterator_destroy(&it); - dns_db_closeversion(db, &oldzone->dbversion, false); + dns_db_closeversion(db, &oldcatz->dbversion, false); isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_ERROR, "catz: zone '%s' has no 'version' record (%s)", bname, isc_result_totext(result)); - newzone->broken = true; + newcatz->broken = true; goto final; } @@ -2267,7 +2226,7 @@ dns_catz_update_from_db(dns_db_t *db, dns_catz_zones_t *catzs) { continue; } - result = dns_db_allrdatasets(db, node, oldzone->dbversion, 0, 0, + result = dns_db_allrdatasets(db, node, oldcatz->dbversion, 0, 0, &rdsiter); if (result != ISC_R_SUCCESS) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, @@ -2293,7 +2252,7 @@ dns_catz_update_from_db(dns_db_t *db, dns_catz_zones_t *catzs) { goto next; } - result = dns_catz_update_process(catzs, newzone, name, + result = dns_catz_update_process(catzs, newcatz, name, &rdataset); if (result != ISC_R_SUCCESS) { char typebuf[DNS_RDATATYPE_FORMATSIZE]; @@ -2332,7 +2291,7 @@ dns_catz_update_from_db(dns_db_t *db, dns_catz_zones_t *catzs) { } dns_dbiterator_destroy(&it); - dns_db_closeversion(db, &oldzone->dbversion, false); + dns_db_closeversion(db, &oldcatz->dbversion, false); isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_DEBUG(3), "catz: update_from_db: iteration finished"); @@ -2340,42 +2299,42 @@ dns_catz_update_from_db(dns_db_t *db, dns_catz_zones_t *catzs) { /* * Check catalog zone version compatibilites. */ - catz_vers = (newzone->version == DNS_CATZ_VERSION_UNDEFINED) - ? oldzone->version - : newzone->version; + catz_vers = (newcatz->version == DNS_CATZ_VERSION_UNDEFINED) + ? oldcatz->version + : newcatz->version; if (catz_vers == DNS_CATZ_VERSION_UNDEFINED) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_WARNING, "catz: zone '%s' version is not set", bname); - newzone->broken = true; + newcatz->broken = true; } else if (catz_vers != 1 && catz_vers != 2) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_WARNING, "catz: zone '%s' unsupported version " "'%" PRIu32 "'", bname, catz_vers); - newzone->broken = true; + newcatz->broken = true; } else { - oldzone->version = catz_vers; + oldcatz->version = catz_vers; } final: - if (newzone->broken) { + if (newcatz->broken) { dns_name_format(name, cname, DNS_NAME_FORMATSIZE); isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_ERROR, "catz: new catalog zone '%s' is broken and " "will not be processed", bname); - dns_catz_zone_detach(&newzone); + dns_catz_detach_catz(&newcatz); return; } /* * Finally merge new zone into old zone. */ - result = dns_catz_zones_merge(oldzone, newzone); - dns_catz_zone_detach(&newzone); + result = dns_catz_zones_merge(oldcatz, newcatz); + dns_catz_detach_catz(&newcatz); if (result != ISC_R_SUCCESS) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_ERROR, @@ -2395,11 +2354,11 @@ final: * update callback in zone_startload or axfr_makedb, but we will * call onupdate() artificially so we can register the callback here. */ - if (!oldzone->db_registered) { + if (!oldcatz->db_registered) { result = dns_db_updatenotify_register( - db, dns_catz_dbupdate_callback, oldzone->catzs); + db, dns_catz_dbupdate_callback, oldcatz->catzs); if (result == ISC_R_SUCCESS) { - oldzone->db_registered = true; + oldcatz->db_registered = true; } } } @@ -2415,9 +2374,9 @@ dns_catz_prereconfig(dns_catz_zones_t *catzs) { for (result = isc_ht_iter_first(iter); result == ISC_R_SUCCESS; result = isc_ht_iter_next(iter)) { - dns_catz_zone_t *zone = NULL; - isc_ht_iter_current(iter, (void **)&zone); - zone->active = false; + dns_catz_zone_t *catz = NULL; + isc_ht_iter_current(iter, (void **)&catz); + catz->active = false; } INSIST(result == ISC_R_NOMORE); isc_ht_iter_destroy(&iter); @@ -2426,7 +2385,7 @@ dns_catz_prereconfig(dns_catz_zones_t *catzs) { void dns_catz_postreconfig(dns_catz_zones_t *catzs) { isc_result_t result; - dns_catz_zone_t *newzone = NULL; + dns_catz_zone_t *newcatz = NULL; isc_ht_iter_t *iter = NULL; REQUIRE(DNS_CATZ_ZONES_VALID(catzs)); @@ -2434,12 +2393,12 @@ dns_catz_postreconfig(dns_catz_zones_t *catzs) { LOCK(&catzs->lock); isc_ht_iter_create(catzs->zones, &iter); for (result = isc_ht_iter_first(iter); result == ISC_R_SUCCESS;) { - dns_catz_zone_t *zone = NULL; + dns_catz_zone_t *catz = NULL; - isc_ht_iter_current(iter, (void **)&zone); - if (!zone->active) { + isc_ht_iter_current(iter, (void **)&catz); + if (!catz->active) { char cname[DNS_NAME_FORMATSIZE]; - dns_name_format(&zone->name, cname, + dns_name_format(&catz->name, cname, DNS_NAME_FORMATSIZE); isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_WARNING, @@ -2449,16 +2408,16 @@ dns_catz_postreconfig(dns_catz_zones_t *catzs) { * Merge the old zone with an empty one to remove * all members. */ - result = dns_catz_new_zone(catzs, &newzone, - &zone->name); + result = dns_catz_new_zone(catzs, &newcatz, + &catz->name); INSIST(result == ISC_R_SUCCESS); - dns_catz_zones_merge(zone, newzone); - dns_catz_zone_detach(&newzone); + dns_catz_zones_merge(catz, newcatz); + dns_catz_detach_catz(&newcatz); /* Make sure that we have an empty catalog zone. */ - INSIST(isc_ht_count(zone->entries) == 0); + INSIST(isc_ht_count(catz->entries) == 0); result = isc_ht_iter_delcurrent_next(iter); - dns_catz_zone_detach(&zone); + dns_catz_detach_catz(&catz); } else { result = isc_ht_iter_next(iter); } diff --git a/lib/dns/include/dns/catz.h b/lib/dns/include/dns/catz.h index 9c74e15584..049d76e622 100644 --- a/lib/dns/include/dns/catz.h +++ b/lib/dns/include/dns/catz.h @@ -13,6 +13,11 @@ #pragma once +/* + * Define this for reference count tracing in the unit + */ +#undef DNS_CATZ_TRACE + #include #include @@ -144,7 +149,7 @@ dns_catz_entry_new(isc_mem_t *mctx, const dns_name_t *domain, */ void -dns_catz_entry_copy(dns_catz_zone_t *zone, const dns_catz_entry_t *entry, +dns_catz_entry_copy(dns_catz_zone_t *catz, const dns_catz_entry_t *entry, dns_catz_entry_t **nentryp); /*%< * Allocate a new catz_entry and deep copy 'entry' into 'nentryp'. @@ -170,7 +175,7 @@ dns_catz_entry_attach(dns_catz_entry_t *entry, dns_catz_entry_t **entryp); */ void -dns_catz_entry_detach(dns_catz_zone_t *zone, dns_catz_entry_t **entryp); +dns_catz_entry_detach(dns_catz_zone_t *catz, dns_catz_entry_t **entryp); /*%< * Detach an entry, free if no further references * @@ -203,34 +208,15 @@ dns_catz_entry_cmp(const dns_catz_entry_t *ea, const dns_catz_entry_t *eb); * \li 'false' if the entries differ. */ -void -dns_catz_zone_attach(dns_catz_zone_t *zone, dns_catz_zone_t **zonep); -/*%< - * Attach a catzone - * - * Requires: - * \li 'zone' is a valid dns_catz_zone_t. - * \li 'zonep' is not NULL and '*zonep' is NULL. - */ - -void -dns_catz_zone_detach(dns_catz_zone_t **zonep); -/*%< - * Detach a zone, free if no further references - * - * Requires: - * \li 'zonep' is not NULL and '*zonep' is not NULL. - */ - isc_result_t -dns_catz_new_zone(dns_catz_zones_t *catzs, dns_catz_zone_t **zonep, +dns_catz_new_zone(dns_catz_zones_t *catzs, dns_catz_zone_t **catzp, const dns_name_t *name); /*%< * Allocate a new catz zone on catzs mctx * * Requires: * \li 'catzs' is a valid dns_catz_zones_t. - * \li 'zonep' is not NULL and '*zonep' is NULL. + * \li 'catzp' is not NULL and '*zonep' is NULL. * \li 'name' is a valid dns_name_t. * */ @@ -334,14 +320,17 @@ struct dns_catz_zonemodmethods { }; isc_result_t -dns_catz_new_zones(dns_catz_zones_t **catzsp, dns_catz_zonemodmethods_t *zmm, - isc_mem_t *mctx, isc_taskmgr_t *taskmgr, - isc_timermgr_t *timermgr); +dns_catz_new_zones(isc_mem_t *mctx, isc_taskmgr_t *taskmgr, + isc_timermgr_t *timermgr, dns_catz_zones_t **catzsp, + dns_catz_zonemodmethods_t *zmm); /*%< * Allocate a new catz_zones object, a collection storing all catalog zones * for a view. * * Requires: + * \li 'mctx' is not NULL. + * \li 'taskmgr' is not NULL. + * \li 'timermgr' is not NULL. * \li 'catzsp' is not NULL and '*catzsp' is NULL. * \li 'zmm' is not NULL. * @@ -370,25 +359,6 @@ dns_catz_get_zone(dns_catz_zones_t *catzs, const dns_name_t *name); * \li 'name' is a valid dns_name_t. */ -void -dns_catz_catzs_attach(dns_catz_zones_t *catzs, dns_catz_zones_t **catzsp); -/*%< - * Attach 'catzs' to 'catzsp'. - * - * Requires: - * \li 'catzs' is a valid dns_catz_zones_t. - * \li 'catzsp' is not NULL and *catzsp is NULL. - */ - -void -dns_catz_catzs_detach(dns_catz_zones_t **catzsp); -/*%< - * Detach 'catzsp', free if no further references. - * - * Requires: - * \li 'catzsp' is not NULL and *catzsp is not NULL. - */ - void dns_catz_catzs_set_view(dns_catz_zones_t *catzs, dns_view_t *view); /*%< @@ -467,4 +437,43 @@ dns_catz_get_iterator(dns_catz_zone_t *catz, isc_ht_iter_t **itp); * */ +#ifdef DNS_CATZ_TRACE +/* Compatibility macros */ +#define dns_catz_attach_catz(catz, catzp) \ + dns_catz_zone__attach(catz, catzp, __func__, __FILE__, __LINE__) +#define dns_catz_detach_catz(catzp) \ + dns_catz_zone__detach(catzp, __func__, __FILE__, __LINE__) +#define dns_catz_ref_catz(ptr) \ + dns_catz_zone__ref(ptr, __func__, __FILE__, __LINE__) +#define dns_catz_unref_catz(ptr) \ + dns_catz_zone__unref(ptr, __func__, __FILE__, __LINE__) + +#define dns_catz_attach_catzs(catzs, catzsp) \ + dns_catz_zones__attach(catzs, catzsp, __func__, __FILE__, __LINE__) +#define dns_catz_detach_catzs(catzsp) \ + dns_catz_zones__detach(catzsp, __func__, __FILE__, __LINE__) +#define dns_catz_ref_catzs(ptr) \ + dns_catz_zones__ref(ptr, __func__, __FILE__, __LINE__) +#define dns_catz_unref_catzs(ptr) \ + dns_catz_zones__unref(ptr, __func__, __FILE__, __LINE__) + +ISC_REFCOUNT_TRACE_DECL(dns_catz_zone); +ISC_REFCOUNT_TRACE_DECL(dns_catz_zones); +#else +/* Compatibility macros */ +#define dns_catz_attach_catz(catz, catzp) dns_catz_zone_attach(catz, catzp) +#define dns_catz_detach_catz(catzp) dns_catz_zone_detach(catzp) +#define dns_catz_ref_catz(ptr) dns_catz_zone_ref(ptr) +#define dns_catz_unref_catz(ptr) dns_catz_zone_unref(ptr) + +#define dns_catz_attach_catzs(catzs, catzsp) \ + dns_catz_zones_attach(catzs, catzsp) +#define dns_catz_detach_catzs(catzsp) dns_catz_zones_detach(catzsp) +#define dns_catz_ref_catzs(ptr) dns_catz_zones_ref(ptr) +#define dns_catz_unref_catzs(ptr) dns_catz_zones_unref(ptr) + +ISC_REFCOUNT_DECL(dns_catz_zone); +ISC_REFCOUNT_DECL(dns_catz_zones); +#endif /* DNS_CATZ_TRACE */ + ISC_LANG_ENDDECLS diff --git a/lib/dns/view.c b/lib/dns/view.c index 4ef3439ce7..755f69c8e7 100644 --- a/lib/dns/view.c +++ b/lib/dns/view.c @@ -423,7 +423,7 @@ destroy(dns_view_t *view) { dns_rpz_detach_rpzs(&view->rpzs); } if (view->catzs != NULL) { - dns_catz_catzs_detach(&view->catzs); + dns_catz_detach_catzs(&view->catzs); } for (dlzdb = ISC_LIST_HEAD(view->dlz_searched); dlzdb != NULL; dlzdb = ISC_LIST_HEAD(view->dlz_searched)) @@ -680,7 +680,7 @@ view_flushanddetach(dns_view_t **viewp, bool flush) { } } if (view->catzs != NULL) { - dns_catz_catzs_detach(&view->catzs); + dns_catz_detach_catzs(&view->catzs); } if (view->ntatable_priv != NULL) { dns_ntatable_shutdown(view->ntatable_priv); diff --git a/lib/dns/zone.c b/lib/dns/zone.c index 579c9da869..c9bb345156 100644 --- a/lib/dns/zone.c +++ b/lib/dns/zone.c @@ -1328,7 +1328,7 @@ zone_free(dns_zone_t *zone) { zone->rpz_num = DNS_RPZ_INVALID_NUM; } if (zone->catzs != NULL) { - dns_catz_catzs_detach(&zone->catzs); + dns_catz_detach_catzs(&zone->catzs); } zone_freedbargs(zone); dns_zone_setparentals(zone, NULL, NULL, NULL, 0); @@ -1981,7 +1981,7 @@ zone_catz_enable(dns_zone_t *zone, dns_catz_zones_t *catzs) { INSIST(zone->catzs == NULL || zone->catzs == catzs); dns_catz_catzs_set_view(catzs, zone->view); if (zone->catzs == NULL) { - dns_catz_catzs_attach(catzs, &zone->catzs); + dns_catz_attach_catzs(catzs, &zone->catzs); } } @@ -2002,7 +2002,7 @@ zone_catz_disable(dns_zone_t *zone) { if (zone->db != NULL) { dns_zone_catz_disable_db(zone, zone->db); } - dns_catz_catzs_detach(&zone->catzs); + dns_catz_detach_catzs(&zone->catzs); } }