#include <inttypes.h>
#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
#include <isc/async.h>
#include <isc/hex.h>
struct dns_catz_coo {
unsigned int magic;
dns_name_t name;
- isc_refcount_t refs;
+ isc_refcount_t references;
};
/*%
unsigned int magic;
dns_name_t name;
dns_catz_options_t opts;
- isc_refcount_t refs;
+ isc_refcount_t references;
};
/*%
};
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);
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;
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));
}
}
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) {
}
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;
}
}
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;
}
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));
}
}
}
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;
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);
/*
* 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;
}
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) {
* 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);
}
/* 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
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;
}
"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;
}
* 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);
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))
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 "
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 "
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;
}
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
}
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,
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;
}
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);
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);
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) {
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));
}
}
}
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));
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;
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);
}
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);
}
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 .*/
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:
}
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;
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);
}
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) {
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);
}
}
}
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;
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) {
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);
}
if (result != ISC_R_SUCCESS) {
goto cleanup;
}
- zone->version = tversion;
+ catz->version = tversion;
result = ISC_R_SUCCESS;
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;
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));
}
/* 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;
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;
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);
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]);
ipkl->keys[i] = keyname;
} else { /* A/AAAA */
memmove(&ipkl->addrs[i], &sockaddr,
- sizeof(isc_sockaddr_t));
+ sizeof(sockaddr));
}
ipkl->count++;
}
}
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;
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));
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))
{
}
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;
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));
* 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);
}
* 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);
}
}
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);
}
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) {
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));
* 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);
}
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;
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);
}
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);
}
}
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;
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;
}
* }
*/
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;
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);
* 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);
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;
}
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;
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:
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];
* 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,
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,
"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",
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",
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",
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;
}
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,
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];
}
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");
/*
* 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,
* 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;
}
}
}
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);
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));
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,
* 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);
}
projects / thirdparty / bind9.git / commitdiff
