cfg_obj_destroy(cfg->add_parser, &zoneconf);
}
dns_catz_entry_detach(cz->origin, &cz->entry);
- dns_catz_detach_catz(&cz->origin);
+ dns_catz_zone_detach(&cz->origin);
dns_view_detach(&cz->view);
isc_mem_putanddetach(&cz->mctx, cz, sizeof(*cz));
}
dns_zone_detach(&zone);
}
dns_catz_entry_detach(cz->origin, &cz->entry);
- dns_catz_detach_catz(&cz->origin);
+ dns_catz_zone_detach(&cz->origin);
dns_view_detach(&cz->view);
isc_mem_putanddetach(&cz->mctx, cz, sizeof(*cz));
}
isc_mem_attach(view->mctx, &cz->mctx);
dns_catz_entry_attach(entry, &cz->entry);
- dns_catz_attach_catz(origin, &cz->origin);
+ dns_catz_zone_attach(origin, &cz->origin);
dns_view_attach(view, &cz->view);
isc_async_run(named_g_mainloop, action, cz);
return (catz_run(entry, origin, view, udata, CATZ_MODZONE));
}
+static void
+catz_changeview(dns_catz_entry_t *entry, void *arg1, void *arg2) {
+ dns_view_t *pview = arg1;
+ dns_view_t *view = arg2;
+
+ dns_zone_t *zone = NULL;
+ isc_result_t result = dns_view_findzone(
+ pview, dns_catz_entry_getname(entry), DNS_ZTFIND_EXACT, &zone);
+
+ if (result != ISC_R_SUCCESS) {
+ return;
+ }
+
+ dns_zone_setview(zone, view);
+ dns_view_addzone(view, zone);
+
+ dns_zone_detach(&zone);
+}
+
static isc_result_t
configure_catz_zone(dns_view_t *view, dns_view_t *pview,
const cfg_obj_t *config, const cfg_listelt_t *element) {
goto cleanup;
}
- result = dns_catz_add_zone(view->catzs, &origin, &zone);
- if (result != ISC_R_SUCCESS && result != ISC_R_EXISTS) {
- cfg_obj_log(catz_obj, named_g_lctx, DNS_CATZ_ERROR_LEVEL,
- "catz: unable to create catalog zone '%s', "
- "error %s",
- str, isc_result_totext(result));
- goto cleanup;
- }
-
+ result = dns_catz_zone_add(view->catzs, &origin, &zone);
if (result == ISC_R_EXISTS) {
- isc_ht_iter_t *it = NULL;
-
- RUNTIME_CHECK(pview != NULL);
-
/*
- * xxxwpk todo: reconfigure the zone!!!!
- */
- cfg_obj_log(catz_obj, named_g_lctx, DNS_CATZ_ERROR_LEVEL,
- "catz: catalog zone '%s' will not be reconfigured",
- str);
- /*
- * We have to walk through all the member zones and attach
+ * We have to walk through all the member zones and re-attach
* them to current view
*/
- dns_catz_get_iterator(zone, &it);
-
- for (result = isc_ht_iter_first(it); result == ISC_R_SUCCESS;
- result = isc_ht_iter_next(it))
- {
- dns_name_t *name = NULL;
- dns_zone_t *dnszone = NULL;
- dns_catz_entry_t *entry = NULL;
- isc_result_t tresult;
-
- isc_ht_iter_current(it, (void **)&entry);
- name = dns_catz_entry_getname(entry);
-
- tresult = dns_view_findzone(pview, name,
- DNS_ZTFIND_EXACT, &dnszone);
- if (tresult != ISC_R_SUCCESS) {
- continue;
- }
-
- dns_zone_setview(dnszone, view);
- dns_view_addzone(view, dnszone);
-
- /*
- * The dns_view_findzone() call above increments the
- * zone's reference count, which we need to decrement
- * back. However, as dns_zone_detach() sets the
- * supplied pointer to NULL, calling it is deferred
- * until the dnszone variable is no longer used.
- */
- dns_zone_detach(&dnszone);
- }
-
- isc_ht_iter_destroy(&it);
-
- result = ISC_R_SUCCESS;
+ dns_catz_zone_for_each_entry2(zone, catz_changeview, pview,
+ view);
}
dns_catz_zone_resetdefoptions(zone);
}
if (old != NULL) {
- dns_catz_attach_catzs(pview->catzs, &view->catzs);
- dns_catz_detach_catzs(&pview->catzs);
+ dns_catz_zones_attach(pview->catzs, &view->catzs);
+ dns_catz_zones_detach(&pview->catzs);
dns_catz_prereconfig(view->catzs);
} else {
- dns_catz_new_zones(view->mctx, named_g_loopmgr, &view->catzs,
- &ns_catz_zonemodmethods);
+ view->catzs = dns_catz_zones_new(view->mctx, named_g_loopmgr,
+ &ns_catz_zonemodmethods);
}
while (zone_element != NULL) {
}
if (view->catzs != NULL &&
- dns_catz_get_zone(view->catzs, origin) != NULL)
+ dns_catz_zone_get(view->catzs, origin) != NULL)
{
zone_is_catz = true;
}
opts->in_memory = defaults->in_memory;
}
-static void
-catz_coo_new(isc_mem_t *mctx, const dns_name_t *domain,
- dns_catz_coo_t **ncoop) {
- dns_catz_coo_t *ncoo;
-
+static dns_catz_coo_t *
+catz_coo_new(isc_mem_t *mctx, const dns_name_t *domain) {
REQUIRE(mctx != NULL);
REQUIRE(domain != NULL);
- REQUIRE(ncoop != NULL && *ncoop == NULL);
- ncoo = isc_mem_get(mctx, sizeof(*ncoo));
+ dns_catz_coo_t *ncoo = isc_mem_get(mctx, sizeof(*ncoo));
+ *ncoo = (dns_catz_coo_t){
+ .magic = DNS_CATZ_COO_MAGIC,
+ };
dns_name_init(&ncoo->name, NULL);
dns_name_dup(domain, mctx, &ncoo->name);
isc_refcount_init(&ncoo->references, 1);
- ncoo->magic = DNS_CATZ_COO_MAGIC;
- *ncoop = ncoo;
+
+ return (ncoo);
}
static void
}
}
-void
-dns_catz_entry_new(isc_mem_t *mctx, const dns_name_t *domain,
- dns_catz_entry_t **nentryp) {
- dns_catz_entry_t *nentry;
+static void
+catz_coo_add(dns_catz_zone_t *catz, dns_catz_entry_t *entry,
+ const dns_name_t *domain) {
+ REQUIRE(DNS_CATZ_ZONE_VALID(catz));
+ REQUIRE(DNS_CATZ_ENTRY_VALID(entry));
+ REQUIRE(domain != NULL);
+
+ /* We are write locked, so the add must succeed if not found */
+ dns_catz_coo_t *coo = NULL;
+ isc_result_t result = isc_ht_find(catz->coos, entry->name.ndata,
+ entry->name.length, (void **)&coo);
+ if (result != ISC_R_SUCCESS) {
+ coo = catz_coo_new(catz->catzs->mctx, domain);
+ result = isc_ht_add(catz->coos, entry->name.ndata,
+ entry->name.length, coo);
+ }
+ INSIST(result == ISC_R_SUCCESS);
+}
+dns_catz_entry_t *
+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(*nentry));
+ dns_catz_entry_t *nentry = isc_mem_get(mctx, sizeof(*nentry));
+ *nentry = (dns_catz_entry_t){
+ .magic = DNS_CATZ_ENTRY_MAGIC,
+ };
dns_name_init(&nentry->name, NULL);
if (domain != NULL) {
dns_catz_options_init(&nentry->opts);
isc_refcount_init(&nentry->references, 1);
- nentry->magic = DNS_CATZ_ENTRY_MAGIC;
- *nentryp = nentry;
+
+ return (nentry);
}
dns_name_t *
return (&entry->name);
}
-void
-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;
-
+dns_catz_entry_t *
+dns_catz_entry_copy(dns_catz_zone_t *catz, const dns_catz_entry_t *entry) {
REQUIRE(DNS_CATZ_ZONE_VALID(catz));
REQUIRE(DNS_CATZ_ENTRY_VALID(entry));
- REQUIRE(nentryp != NULL && *nentryp == NULL);
- dns_catz_entry_new(catz->catzs->mctx, &entry->name, &nentry);
+ dns_catz_entry_t *nentry = dns_catz_entry_new(catz->catzs->mctx,
+ &entry->name);
dns_catz_options_copy(catz->catzs->mctx, &entry->opts, &nentry->opts);
- *nentryp = nentry;
+
+ return (nentry);
}
void
return (result);
}
-void
-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;
-
+dns_catz_zones_t *
+dns_catz_zones_new(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
+ dns_catz_zonemodmethods_t *zmm) {
REQUIRE(mctx != NULL);
REQUIRE(loopmgr != NULL);
- REQUIRE(catzsp != NULL && *catzsp == NULL);
REQUIRE(zmm != NULL);
- catzs = isc_mem_get(mctx, sizeof(*catzs));
+ dns_catz_zones_t *catzs = isc_mem_get(mctx, sizeof(*catzs));
*catzs = (dns_catz_zones_t){ .loopmgr = loopmgr,
.zmm = zmm,
.magic = DNS_CATZ_ZONES_MAGIC };
isc_ht_init(&catzs->zones, mctx, 4, ISC_HT_CASE_SENSITIVE);
isc_mem_attach(mctx, &catzs->mctx);
- *catzsp = catzs;
+ return (catzs);
}
void
catzs->view = view;
}
-isc_result_t
-dns_catz_new_zone(dns_catz_zones_t *catzs, dns_catz_zone_t **catzp,
- const dns_name_t *name) {
- dns_catz_zone_t *catz;
-
+dns_catz_zone_t *
+dns_catz_zone_new(dns_catz_zones_t *catzs, const dns_name_t *name) {
REQUIRE(DNS_CATZ_ZONES_VALID(catzs));
- REQUIRE(catzp != NULL && *catzp == NULL);
REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC));
- catz = isc_mem_get(catzs->mctx, sizeof(*catz));
+ dns_catz_zone_t *catz = isc_mem_get(catzs->mctx, sizeof(*catz));
*catz = (dns_catz_zone_t){ .active = true,
.version = DNS_CATZ_VERSION_UNDEFINED,
.magic = DNS_CATZ_ZONE_MAGIC };
dns_name_init(&catz->name, NULL);
dns_name_dup(name, catzs->mctx, &catz->name);
- *catzp = catz;
-
- return (ISC_R_SUCCESS);
+ return (catz);
}
static void
isc_timer_destroy(&catz->updatetimer);
catz->loop = NULL;
- dns_catz_detach_catz(&catz);
+ dns_catz_zone_detach(&catz);
}
isc_result_t
-dns_catz_add_zone(dns_catz_zones_t *catzs, const dns_name_t *name,
+dns_catz_zone_add(dns_catz_zones_t *catzs, const dns_name_t *name,
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(catzp != NULL && *catzp == NULL);
+ dns_catz_zone_t *catz = NULL;
+ isc_result_t result;
+ char zname[DNS_NAME_FORMATSIZE];
+
dns_name_format(name, zname, DNS_NAME_FORMATSIZE);
isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
- ISC_LOG_DEBUG(3), "catz: dns_catz_add_zone %s", zname);
+ ISC_LOG_DEBUG(3), "catz: dns_catz_zone_add %s", zname);
LOCK(&catzs->lock);
- result = dns_catz_new_zone(catzs, &catz, name);
- if (result != ISC_R_SUCCESS) {
- goto cleanup;
- }
-
- result = isc_ht_add(catzs->zones, catz->name.ndata, catz->name.length,
- catz);
- if (result != ISC_R_SUCCESS) {
- dns_catz_detach_catz(&catz);
- if (result != ISC_R_EXISTS) {
- goto cleanup;
- }
- }
-
- if (result == ISC_R_EXISTS) {
- tresult = isc_ht_find(catzs->zones, name->ndata, name->length,
- (void **)&catz);
- INSIST(tresult == ISC_R_SUCCESS && !catz->active);
+ result = isc_ht_find(catzs->zones, name->ndata, name->length,
+ (void **)&catz);
+ switch (result) {
+ case ISC_R_SUCCESS:
+ INSIST(!catz->active);
catz->active = true;
+ result = ISC_R_EXISTS;
+ break;
+ case ISC_R_NOTFOUND:
+ catz = dns_catz_zone_new(catzs, name);
+
+ result = isc_ht_add(catzs->zones, catz->name.ndata,
+ catz->name.length, catz);
+ INSIST(result == ISC_R_SUCCESS);
+ break;
+ default:
+ UNREACHABLE();
}
- *catzp = catz;
-
-cleanup:
UNLOCK(&catzs->lock);
+ *catzp = catz;
+
return (result);
}
dns_catz_zone_t *
-dns_catz_get_zone(dns_catz_zones_t *catzs, const dns_name_t *name) {
+dns_catz_zone_get(dns_catz_zones_t *catzs, const dns_name_t *name) {
isc_result_t result;
dns_catz_zone_t *found = NULL;
}
static void
-dns__catz_shutdown(dns_catz_zone_t *catz) {
+dns__catz_zone_shutdown(dns_catz_zone_t *catz) {
/* lock must be locked */
if (catz->updatetimer != NULL) {
/* Don't wait for timer to trigger for shutdown */
isc_async_run(catz->loop, dns__catz_timer_stop, catz);
} else {
- dns_catz_detach_catz(&catz);
+ dns_catz_zone_detach(&catz);
}
}
}
void
-dns_catz_shutdown_catzs(dns_catz_zones_t *catzs) {
+dns_catz_zones_shutdown(dns_catz_zones_t *catzs) {
REQUIRE(DNS_CATZ_ZONES_VALID(catzs));
if (!atomic_compare_exchange_strong(&catzs->shuttingdown,
dns_catz_zone_t *catz = NULL;
isc_ht_iter_current(iter, (void **)&catz);
result = isc_ht_iter_delcurrent_next(iter);
- dns__catz_shutdown(catz);
+ dns__catz_zone_shutdown(catz);
}
INSIST(result == ISC_R_NOMORE);
isc_ht_iter_destroy(&iter);
dns_rdata_t rdata;
dns_rdata_ptr_t ptr;
dns_catz_entry_t *entry = NULL;
- dns_catz_coo_t *ncoo = NULL;
- dns_catz_coo_t *ocoo = NULL;
REQUIRE(DNS_CATZ_ZONE_VALID(catz));
REQUIRE(mhash != NULL);
goto cleanup;
}
- 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(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(catz, &ncoo);
- }
+ catz_coo_add(catz, entry, &ptr.ptr);
cleanup:
dns_rdata_freestruct(&ptr);
dns_name_dup(&ptr.ptr, catz->catzs->mctx, &entry->name);
}
} else {
- dns_catz_entry_new(catz->catzs->mctx, &ptr.ptr, &entry);
+ entry = dns_catz_entry_new(catz->catzs->mctx, &ptr.ptr);
result = isc_ht_add(catz->entries, mhash->base, mhash->length,
entry);
- if (result != ISC_R_SUCCESS) {
- dns_rdata_freestruct(&ptr);
- dns_catz_entry_detach(catz, &entry);
- return (result);
- }
}
+ INSIST(result == ISC_R_SUCCESS);
dns_rdata_freestruct(&ptr);
result = isc_ht_find(catz->entries, mhash->base, mhash->length,
(void **)&entry);
if (result != ISC_R_SUCCESS) {
- dns_catz_entry_new(catz->catzs->mctx, NULL, &entry);
+ entry = dns_catz_entry_new(catz->catzs->mctx, NULL);
result = isc_ht_add(catz->entries, mhash->base, mhash->length,
entry);
- if (result != ISC_R_SUCCESS) {
- dns_catz_entry_detach(catz, &entry);
- return (result);
- }
}
+ INSIST(result == ISC_R_SUCCESS);
dns_name_init(&prefix, NULL);
dns_name_split(name, suffix_labels, &prefix, NULL);
isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL, DNS_LOGMODULE_MASTER,
ISC_LOG_INFO, "catz: %s: reload start", domain);
- dns_catz_ref_catz(catz);
+ dns_catz_zone_ref(catz);
isc_work_enqueue(catz->loop, dns__catz_update_cb, dns__catz_done_cb,
catz);
"catz: updating catalog zone '%s' with serial %" PRIu32,
bname, vers);
- result = dns_catz_new_zone(catzs, &newcatz, &updb->origin);
- if (result != ISC_R_SUCCESS) {
- isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
- DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
- "catz: failed to create new zone - %s",
- isc_result_totext(result));
- goto exit;
- }
-
result = dns_db_createiterator(updb, DNS_DB_NONSEC3, &updbit);
if (result != ISC_R_SUCCESS) {
- dns_catz_detach_catz(&newcatz);
isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
"catz: failed to create DB iterator - %s",
result = dns_name_fromstring2(name, "version", &updb->origin, 0, NULL);
if (result != ISC_R_SUCCESS) {
dns_dbiterator_destroy(&updbit);
- dns_catz_detach_catz(&newcatz);
isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
"catz: failed to create name from string - %s",
isc_result_totext(result));
goto exit;
}
+
result = dns_dbiterator_seek(updbit, name);
if (result != ISC_R_SUCCESS) {
dns_dbiterator_destroy(&updbit);
isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
DNS_LOGMODULE_MASTER, ISC_LOG_ERROR,
- "catz: zone '%s' has no 'version' record (%s)",
+ "catz: zone '%s' has no 'version' record (%s) "
+ "and will not be processed",
bname, isc_result_totext(result));
- newcatz->broken = true;
- goto final;
+ goto exit;
}
+ newcatz = dns_catz_zone_new(catzs, &updb->origin);
name = dns_fixedname_initname(&fixname);
/*
oldcatz->version = catz_vers;
}
-final:
if (newcatz->broken) {
dns_name_format(name, cname, DNS_NAME_FORMATSIZE);
isc_log_write(dns_lctx, DNS_LOGCATEGORY_GENERAL,
"catz: new catalog zone '%s' is broken and "
"will not be processed",
bname);
- dns_catz_detach_catz(&newcatz);
+ dns_catz_zone_detach(&newcatz);
result = ISC_R_FAILURE;
goto exit;
}
* Finally merge new zone into old zone.
*/
result = dns__catz_zones_merge(oldcatz, newcatz);
- dns_catz_detach_catz(&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,
ISC_LOG_INFO, "catz: %s: reload done: %s", dname,
isc_result_totext(catz->updateresult));
- dns_catz_unref_catz(catz);
+ dns_catz_zone_unref(catz);
}
void
* Merge the old zone with an empty one to remove
* all members.
*/
- result = dns_catz_new_zone(catzs, &newcatz,
- &catz->name);
- INSIST(result == ISC_R_SUCCESS);
+ newcatz = dns_catz_zone_new(catzs, &catz->name);
dns__catz_zones_merge(catz, newcatz);
- dns_catz_detach_catz(&newcatz);
+ dns_catz_zone_detach(&newcatz);
/* Make sure that we have an empty catalog zone. */
INSIST(isc_ht_count(catz->entries) == 0);
result = isc_ht_iter_delcurrent_next(iter);
- dns_catz_detach_catz(&catz);
+ dns_catz_zone_detach(&catz);
} else {
result = isc_ht_iter_next(iter);
}
}
void
-dns_catz_get_iterator(dns_catz_zone_t *catz, isc_ht_iter_t **itp) {
+dns_catz_zone_for_each_entry2(dns_catz_zone_t *catz, dns_catz_entry_cb2 cb,
+ void *arg1, void *arg2) {
REQUIRE(DNS_CATZ_ZONE_VALID(catz));
- isc_ht_iter_create(catz->entries, itp);
+ isc_ht_iter_t *iter = NULL;
+ isc_result_t result;
+
+ LOCK(&catz->catzs->lock);
+ isc_ht_iter_create(catz->entries, &iter);
+ for (result = isc_ht_iter_first(iter); result == ISC_R_SUCCESS;
+ result = isc_ht_iter_next(iter))
+ {
+ dns_catz_entry_t *entry = NULL;
+
+ isc_ht_iter_current(iter, (void **)&entry);
+ cb(entry, arg1, arg2);
+ }
+ isc_ht_iter_destroy(&iter);
+ UNLOCK(&catz->catzs->lock);
}
* \li domain name for entry.
*/
-void
-dns_catz_entry_new(isc_mem_t *mctx, const dns_name_t *domain,
- dns_catz_entry_t **nentryp);
+dns_catz_entry_t *
+dns_catz_entry_new(isc_mem_t *mctx, const dns_name_t *domain);
/*%<
* Allocate a new catz_entry on 'mctx', with the name 'domain'
*
* Requires:
* \li 'mctx' to be a valid memory context.
* \li 'domain' to be valid dns_name or NULL.
- * \li 'nentryp' to be non NULL, *nentryp to be NULL.
*
* Returns:
* \li ISC_R_SUCCESS on success
* \li ISC_R_NOMEMORY on allocation failure
*/
-void
-dns_catz_entry_copy(dns_catz_zone_t *catz, const dns_catz_entry_t *entry,
- dns_catz_entry_t **nentryp);
+dns_catz_entry_t *
+dns_catz_entry_copy(dns_catz_zone_t *catz, const dns_catz_entry_t *entry);
/*%<
* Allocate a new catz_entry and deep copy 'entry' into 'nentryp'.
*
* Requires:
* \li 'mctx' to be a valid memory context.
* \li 'entry' to be non NULL.
- * \li 'nentryp' to be non NULL, *nentryp to be NULL.
*
* Returns:
* \li ISC_R_SUCCESS on success
* \li 'false' if the entries differ.
*/
-isc_result_t
-dns_catz_new_zone(dns_catz_zones_t *catzs, dns_catz_zone_t **catzp,
- const dns_name_t *name);
+dns_catz_zone_t *
+dns_catz_zone_new(dns_catz_zones_t *catzs, const dns_name_t *name);
/*%<
* Allocate a new catz zone on catzs mctx
*
void *udata;
};
-void
-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 *
+dns_catz_zones_new(isc_mem_t *mctx, isc_loopmgr_t *loopmgr,
+ dns_catz_zonemodmethods_t *zmm);
/*%<
* Allocate a new catz_zones object, a collection storing all catalog zones
* for a view.
*/
isc_result_t
-dns_catz_add_zone(dns_catz_zones_t *catzs, const dns_name_t *name,
+dns_catz_zone_add(dns_catz_zones_t *catzs, const dns_name_t *name,
dns_catz_zone_t **catzp);
/*%<
* Allocate a new catz named 'name' and put it in 'catzs' collection.
*/
dns_catz_zone_t *
-dns_catz_get_zone(dns_catz_zones_t *catzs, const dns_name_t *name);
+dns_catz_zone_get(dns_catz_zones_t *catzs, const dns_name_t *name);
/*%<
* Returns a zone named 'name' from collection 'catzs'
*
*/
void
-dns_catz_dbupdate_unregister(dns_db_t *db, dns_catz_zones_t *catzs);
+dns_catz_dbupdate_register(dns_db_t *db, dns_catz_zones_t *catzs);
/*%<
* Register the catalog zone database update notify callback.
*
*/
void
-dns_catz_dbupdate_register(dns_db_t *db, dns_catz_zones_t *catzs);
+dns_catz_dbupdate_unregister(dns_db_t *db, dns_catz_zones_t *catzs);
/*%<
* Unregister the catalog zone database update notify callback.
*
*/
void
-dns_catz_get_iterator(dns_catz_zone_t *catz, isc_ht_iter_t **itp);
+dns_catz_zones_shutdown(dns_catz_zones_t *catzs);
/*%<
- * Get the hashtable iterator on catalog zone members, point '*itp' to it.
+ * Shut down the catalog zones.
*
* Requires:
* \li 'catzs' is a valid dns_catz_zones_t.
- * \li 'itp' is not NULL and '*itp' is NULL.
*
*/
+typedef void (*dns_catz_entry_cb2)(dns_catz_entry_t *entry, void *arg1,
+ void *arg2);
+
void
-dns_catz_shutdown_catzs(dns_catz_zones_t *catzs);
+dns_catz_zone_for_each_entry2(dns_catz_zone_t *catz, dns_catz_entry_cb2 cb,
+ void *arg1, void *arg2);
/*%<
- * Shut down the catalog zones.
+ * Iterate on the catalog zone members, call 'cb' on each 'entry'.
*
* Requires:
- * \li 'catzs' is a valid dns_catz_zones_t.
+ * \li 'catz' is a valid dns_catz_zones_t.
*
*/
#ifdef DNS_CATZ_TRACE
/* Compatibility macros */
-#define dns_catz_attach_catz(catz, catzp) \
+#define dns_catz_zone_attach(catz, catzp) \
dns_catz_zone__attach(catz, catzp, __func__, __FILE__, __LINE__)
-#define dns_catz_detach_catz(catzp) \
+#define dns_catz_zone_detach(catzp) \
dns_catz_zone__detach(catzp, __func__, __FILE__, __LINE__)
-#define dns_catz_ref_catz(ptr) \
+#define dns_catz_zone_ref(ptr) \
dns_catz_zone__ref(ptr, __func__, __FILE__, __LINE__)
-#define dns_catz_unref_catz(ptr) \
+#define dns_catz_zone_unref(ptr) \
dns_catz_zone__unref(ptr, __func__, __FILE__, __LINE__)
-#define dns_catz_attach_catzs(catzs, catzsp) \
+#define dns_catz_zones_attach(catzs, catzsp) \
dns_catz_zones__attach(catzs, catzsp, __func__, __FILE__, __LINE__)
-#define dns_catz_detach_catzs(catzsp) \
+#define dns_catz_zones_detach(catzsp) \
dns_catz_zones__detach(catzsp, __func__, __FILE__, __LINE__)
-#define dns_catz_ref_catzs(ptr) \
+#define dns_catz_zones_ref(ptr) \
dns_catz_zones__ref(ptr, __func__, __FILE__, __LINE__)
-#define dns_catz_unref_catzs(ptr) \
+#define dns_catz_zones_unref(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 */
projects / thirdparty / bind9.git / commitdiff
