From: Aram Sargsyan Date: Thu, 9 Feb 2023 10:32:33 +0000 (+0000) Subject: Light refactoring of catz.c X-Git-Tag: v9.19.11~25^2~3 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=8cb79fec9dbda31b199a5f5fdf3ae3d4c40d6a99;p=thirdparty%2Fbind9.git Light refactoring of catz.c * Change 'dns_catz_new_zones()' function's prototype (the order of the arguments) to synchronize it with the similar function in rpz.c. * Rename 'refs' to 'references' in preparation of ISC_REFCOUNT_* macros usage for reference tracking. * Unify dns_catz_zone_t naming to catz, and dns_catz_zones_t naming to catzs, following the logic of similar changes in rpz.c. * Use C compound literals for structure initialization. * Synchronize the "new zone version came too soon" log message with the one in rpz.c. * Use more of 'sizeof(*ptr)' style instead of the 'sizeof(type_t)' style expressions when allocating or freeing memory for 'ptr'. --- diff --git a/bin/named/server.c b/bin/named/server.c index 4330ce00e6f..fe02e1e496d 100644 --- a/bin/named/server.c +++ b/bin/named/server.c @@ -3163,8 +3163,8 @@ configure_catz(dns_view_t *view, dns_view_t *pview, const cfg_obj_t *config, return (ISC_R_SUCCESS); } - dns_catz_new_zones(&view->catzs, &ns_catz_zonemodmethods, view->mctx, - named_g_loopmgr); + dns_catz_new_zones(view->mctx, named_g_loopmgr, &view->catzs, + &ns_catz_zonemodmethods); if (pview != NULL) { old = pview->catzs; diff --git a/lib/dns/catz.c b/lib/dns/catz.c index 3c32ec9f5cd..b8030d21952 100644 --- a/lib/dns/catz.c +++ b/lib/dns/catz.c @@ -15,6 +15,8 @@ #include #include +#include +#include #include #include @@ -49,7 +51,7 @@ struct dns_catz_coo { unsigned int magic; dns_name_t name; - isc_refcount_t refs; + isc_refcount_t references; }; /*% @@ -59,7 +61,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; }; /*% @@ -98,16 +100,16 @@ struct dns_catz_zone { }; static void -catz_timer_start(dns_catz_zone_t *zone); +catz_timer_start(dns_catz_zone_t *catz); 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); @@ -119,7 +121,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_loopmgr_t *loopmgr; @@ -231,31 +233,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)); } } @@ -267,7 +269,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) { @@ -275,7 +277,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; } @@ -287,17 +289,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; } @@ -306,28 +308,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)); } } @@ -425,29 +427,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; @@ -457,39 +459,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; - - /* Copy zoneoptions from newzone into target. */ + addzone = catz->catzs->zmm->addzone; + modzone = catz->catzs->zmm->modzone; + delzone = catz->catzs->zmm->delzone; - 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); + /* Copy zoneoptions from newcatz into catz. */ - dns_name_format(&target->name, czname, DNS_NAME_FORMATSIZE); + 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); - isc_ht_init(&toadd, target->catzs->mctx, 1, ISC_HT_CASE_SENSITIVE); + dns_name_format(&catz->name, czname, DNS_NAME_FORMATSIZE); - isc_ht_init(&tomod, target->catzs->mctx, 1, 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, 1, ISC_HT_CASE_SENSITIVE); + isc_ht_init(&tomod, catz->catzs->mctx, 1, 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); /* @@ -518,7 +516,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; } @@ -529,12 +527,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) { @@ -545,11 +542,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); @@ -579,11 +576,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 @@ -605,9 +602,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; } @@ -617,16 +613,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; } @@ -634,8 +629,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); @@ -651,19 +646,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->zmm->udata); + result = delzone(entry, catz, catz->catzs->view, + 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)) @@ -672,8 +667,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->zmm->udata); + result = addzone(entry, catz, catz->catzs->view, + catz->catzs->zmm->udata); isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_INFO, "catz: adding zone '%s' from catalog " @@ -688,8 +683,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->zmm->udata); + result = modzone(entry, catz, catz->catzs->view, + catz->catzs->zmm->udata); isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_INFO, "catz: modifying zone '%s' from catalog " @@ -697,34 +692,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; @@ -738,28 +733,26 @@ dns_catz_zones_merge(dns_catz_zone_t *target, dns_catz_zone_t *newzone) { } void -dns_catz_new_zones(dns_catz_zones_t **catzsp, dns_catz_zonemodmethods_t *zmm, - isc_mem_t *mctx, isc_loopmgr_t *loopmgr) { - dns_catz_zones_t *new_zones = NULL; +dns_catz_new_zones(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, + dns_catz_zones_t **catzsp, dns_catz_zonemodmethods_t *zmm) { + dns_catz_zones_t *catzs = NULL; + REQUIRE(mctx != NULL); + REQUIRE(loopmgr != NULL); REQUIRE(catzsp != NULL && *catzsp == NULL); REQUIRE(zmm != NULL); - new_zones = isc_mem_getx(mctx, sizeof(*new_zones), ISC_MEM_ZERO); - - 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->loopmgr = loopmgr; + catzs = isc_mem_get(mctx, sizeof(*catzs)); + *catzs = (dns_catz_zones_t){ .loopmgr = loopmgr, + .zmm = zmm, + .magic = DNS_CATZ_ZONES_MAGIC }; - new_zones->magic = DNS_CATZ_ZONES_MAGIC; + 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 = new_zones; + *catzsp = catzs; } void @@ -773,78 +766,75 @@ 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) { - dns_catz_zone_t *new_zone; + dns_catz_zone_t *catz; 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_getx(catzs->mctx, sizeof(*new_zone), ISC_MEM_ZERO); - - 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); + 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 }; - new_zone->updatetimer = NULL; - 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->references, 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); } void -catz_timer_start(dns_catz_zone_t *zone) { +catz_timer_start(dns_catz_zone_t *catz) { isc_time_t now; uint64_t tdiff; isc_interval_t interval; + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); + 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; + char dname[DNS_NAME_FORMATSIZE]; + + dns_name_format(&catz->name, dname, DNS_NAME_FORMATSIZE); 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); + "catz: %s: new zone version came " + "too soon, deferring update for " + "%" PRIu64 " seconds", + dname, defer); + isc_interval_set(&interval, (unsigned int)defer, 0); } else { isc_interval_set(&interval, 0, 0); } - isc_timer_create(isc_loop_current(zone->catzs->loopmgr), - dns_catz_update_action, zone, &zone->updatetimer); - - isc_timer_start(zone->updatetimer, isc_timertype_once, &interval); + isc_timer_create(isc_loop_current(catz->catzs->loopmgr), + dns_catz_update_action, catz, &catz->updatetimer); + isc_timer_start(catz->updatetimer, isc_timertype_once, &interval); } 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, @@ -852,15 +842,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_zone_detach(&catz); if (result != ISC_R_EXISTS) { goto cleanup; } @@ -868,12 +858,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); @@ -903,75 +893,76 @@ 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); - isc_refcount_increment(&catzs->refs); + isc_refcount_increment(&catzs->references); *catzsp = catzs; } static void -dns__catz_zone_destroy(dns_catz_zone_t *zone) { - isc_mem_t *mctx = zone->catzs->mctx; - isc_refcount_destroy(&zone->references); - if (zone->entries != NULL) { +dns__catz_zone_destroy(dns_catz_zone_t *catz) { + isc_mem_t *mctx = catz->catzs->mctx; + if (catz->entries != NULL) { isc_ht_iter_t *iter = NULL; isc_result_t result; - isc_ht_iter_create(zone->entries, &iter); + 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; isc_ht_iter_current(iter, (void **)&entry); - dns_catz_entry_detach(zone, &entry); + dns_catz_entry_detach(catz, &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); + INSIST(isc_ht_count(catz->entries) == 0); + isc_ht_destroy(&catz->entries); } - if (zone->coos != NULL) { + if (catz->coos != NULL) { isc_ht_iter_t *iter = NULL; isc_result_t result; - isc_ht_iter_create(zone->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(zone, &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(zone->coos) == 0); - isc_ht_destroy(&zone->coos); + INSIST(isc_ht_count(catz->coos) == 0); + isc_ht_destroy(&catz->coos); } - zone->magic = 0; + catz->magic = 0; - if (zone->updatetimer != NULL) { - isc_timer_async_destroy(&zone->updatetimer); + if (catz->updatetimer != NULL) { + isc_timer_async_destroy(&catz->updatetimer); } - if (zone->db_registered) { + if (catz->db_registered) { dns_db_updatenotify_unregister( - zone->db, dns_catz_dbupdate_callback, zone->catzs); + catz->db, dns_catz_dbupdate_callback, catz->catzs); } - if (zone->dbversion) { - dns_db_closeversion(zone->db, &zone->dbversion, false); + if (catz->dbversion != NULL) { + dns_db_closeversion(catz->db, &catz->dbversion, false); } - if (zone->db != NULL) { - dns_db_detach(&zone->db); + if (catz->db != NULL) { + dns_db_detach(&catz->db); } - dns_name_free(&zone->name, mctx); - dns_catz_options_free(&zone->defoptions, mctx); - dns_catz_options_free(&zone->zoneoptions, mctx); + 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); - zone->catzs = NULL; - isc_mem_put(mctx, zone, sizeof(dns_catz_zone_t)); + isc_mem_put(mctx, catz, sizeof(*catz)); } ISC_REFCOUNT_IMPL(dns_catz_zone, dns__catz_zone_destroy); @@ -985,7 +976,7 @@ dns_catz_catzs_detach(dns_catz_zones_t **catzsp) { catzs = *catzsp; *catzsp = NULL; - if (isc_refcount_decrement(&catzs->refs) == 1) { + if (isc_refcount_decrement(&catzs->references) == 1) { catzs->magic = 0; isc_mutex_destroy(&catzs->lock); if (catzs->zones != NULL) { @@ -995,17 +986,17 @@ dns_catz_catzs_detach(dns_catz_zones_t **catzsp) { for (result = isc_ht_iter_first(iter); result == ISC_R_SUCCESS;) { - dns_catz_zone_t *zone = NULL; - isc_ht_iter_current(iter, (void **)&zone); + dns_catz_zone_t *catz = NULL; + isc_ht_iter_current(iter, (void **)&catz); result = isc_ht_iter_delcurrent_next(iter); - dns_catz_zone_detach(&zone); + dns_catz_zone_detach(&catz); } INSIST(result == ISC_R_NOMORE); isc_ht_iter_destroy(&iter); INSIST(isc_ht_count(catzs->zones) == 0); isc_ht_destroy(&catzs->zones); } - isc_refcount_destroy(&catzs->refs); + isc_refcount_destroy(&catzs->references); isc_mem_putanddetach(&catzs->mctx, catzs, sizeof(*catzs)); } } @@ -1059,12 +1050,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)); @@ -1075,17 +1066,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; @@ -1094,12 +1085,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); } @@ -1112,7 +1103,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); } @@ -1134,7 +1125,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 .*/ @@ -1146,18 +1137,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: @@ -1167,7 +1158,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; @@ -1183,7 +1174,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); } @@ -1200,7 +1191,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) { @@ -1208,16 +1199,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); } } @@ -1228,7 +1219,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; @@ -1236,7 +1227,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) { @@ -1248,7 +1239,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); } @@ -1290,7 +1281,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: @@ -1300,13 +1291,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; @@ -1320,13 +1311,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)); @@ -1387,7 +1378,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; @@ -1395,7 +1386,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; @@ -1421,7 +1412,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); @@ -1429,7 +1420,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]); @@ -1437,7 +1429,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++; } @@ -1486,7 +1478,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; @@ -1496,7 +1488,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)); @@ -1516,11 +1508,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); for (result = dns_rdata_apl_first(&rdata_apl); result == ISC_R_SUCCESS; result = dns_rdata_apl_next(&rdata_apl)) { @@ -1567,7 +1559,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; @@ -1576,7 +1568,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)); @@ -1591,7 +1583,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); } @@ -1604,14 +1596,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); } } @@ -1620,21 +1612,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); @@ -1644,7 +1636,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) { @@ -1657,21 +1649,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)); @@ -1685,7 +1677,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); } @@ -1699,34 +1691,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; @@ -1737,18 +1729,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); @@ -1775,8 +1767,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); } @@ -1796,7 +1788,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; @@ -1804,17 +1796,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; } @@ -1892,7 +1884,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; @@ -1902,7 +1894,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); @@ -1910,7 +1902,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_putstr(buffer, "zone \""); dns_name_totext(&entry->name, true, buffer); @@ -1969,7 +1961,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; } @@ -2001,24 +1993,24 @@ cleanup: void dns_catz_update_action(void *arg) { isc_result_t result; - dns_catz_zone_t *zone = arg; + dns_catz_zone_t *catz = arg; - REQUIRE(DNS_CATZ_ZONE_VALID(zone)); + REQUIRE(DNS_CATZ_ZONE_VALID(catz)); - LOCK(&zone->catzs->lock); - zone->updatepending = false; - dns_catz_update_from_db(zone->db, zone->catzs); - isc_timer_stop(zone->updatetimer); - isc_timer_destroy(&zone->updatetimer); - result = isc_time_now(&zone->lastupdated); + LOCK(&catz->catzs->lock); + catz->updatepending = false; + dns_catz_update_from_db(catz->db, catz->catzs); + isc_timer_stop(catz->updatetimer); + isc_timer_destroy(&catz->updatetimer); + 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 = NULL; + dns_catz_zone_t *catz = NULL; isc_result_t result = ISC_R_SUCCESS; isc_region_t r; @@ -2029,39 +2021,44 @@ dns_catz_dbupdate_callback(dns_db_t *db, void *fn_arg) { 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_db_currentversion(db, &zone->dbversion); - catz_timer_start(zone); + if (!catz->updatepending) { + catz->updatepending = true; + dns_db_currentversion(db, &catz->dbversion); + catz_timer_start(catz); } else { + char dname[DNS_NAME_FORMATSIZE]; + + catz->updatepending = true; + dns_name_format(&catz->name, dname, DNS_NAME_FORMATSIZE); 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); + "catz: %s: update already queued or running", + dname); + 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: @@ -2078,14 +2075,14 @@ 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; const dns_dbnode_t *vers_node = NULL; dns_dbiterator_t *it = NULL; dns_fixedname_t fixname; - dns_name_t *name; + dns_name_t *name = NULL; dns_rdatasetiter_t *rdsiter = NULL; dns_rdataset_t rdataset; char bname[DNS_NAME_FORMATSIZE]; @@ -2103,7 +2100,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, @@ -2112,7 +2109,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, @@ -2127,9 +2124,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", @@ -2139,8 +2136,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_zone_detach(&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", @@ -2158,8 +2155,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_zone_detach(&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", @@ -2169,12 +2166,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; } @@ -2203,7 +2200,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, @@ -2229,7 +2226,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]; @@ -2268,7 +2265,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"); @@ -2276,42 +2273,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_zone_detach(&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_zone_detach(&newcatz); if (result != ISC_R_SUCCESS) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER, ISC_LOG_ERROR, @@ -2331,11 +2328,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; } } } @@ -2351,9 +2348,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); @@ -2362,7 +2359,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)); @@ -2370,12 +2367,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, @@ -2385,16 +2382,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_zone_detach(&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_zone_detach(&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 46509f17508..3cce9e71ace 100644 --- a/lib/dns/include/dns/catz.h +++ b/lib/dns/include/dns/catz.h @@ -144,7 +144,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 +170,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 * @@ -209,14 +209,14 @@ ISC_REFCOUNT_DECL(dns_catz_zone); */ 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 '*catzp' is NULL. * \li 'name' is a valid dns_name_t. * */ @@ -318,13 +318,15 @@ struct dns_catz_zonemodmethods { }; void -dns_catz_new_zones(dns_catz_zones_t **catzsp, dns_catz_zonemodmethods_t *zmm, - isc_mem_t *mctx, isc_loopmgr_t *loopmgr); +dns_catz_new_zones(isc_mem_t *mctx, isc_loopmgr_t *loopmgr, + 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 'loopmgr' is not NULL. * \li 'catzsp' is not NULL and '*catzsp' is NULL. * \li 'zmm' is not NULL. *