free_db(dns_db_t **dbp, dns_dbnode_t **nodep, dns_dbversion_t **versionp) {
if (*dbp != NULL) {
if (*nodep != NULL) {
- dns_db_detachnode(*dbp, nodep);
+ dns_db_detachnode(nodep);
}
if (versionp != NULL && *versionp != NULL) {
dns_db_closeversion(*dbp, versionp, false);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (db != NULL) {
dns_db_detach(&db);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (db != NULL) {
dns_db_detach(&db);
result = dns_db_findnode(gdb, wild, false, &node);
if (result == ISC_R_SUCCESS) {
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
return;
}
result = dns_db_findrdataset(db, node, NULL,
dns_rdatatype_ds, 0, 0,
dsset, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result == ISC_R_SUCCESS) {
vbprintf(2, "found DS records\n");
dsset->ttl = ttl;
result = dns_db_findrdataset(db, node, NULL, dns_rdatatype_dnskey, 0, 0,
&keyset, NULL);
if (result != ISC_R_SUCCESS) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
dns_db_detach(&db);
return result;
}
check_result(result, "dns_db_findrdataset");
dns_rdataset_disassociate(&keyset);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
dns_db_detach(&db);
return result;
}
cleanup:
dns_rdataset_disassociate(&rdataset);
if (node != NULL) {
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
}
dns_rdata_reset(&rdata);
check_dns_dbiterator_current(result);
signname(node, true, name);
dumpnode(name, node);
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
result = dns_dbiterator_first(gdbiter);
if (result == ISC_R_NOMORE) {
atomic_store(&finished, true);
* The origin was handled by signapex().
*/
if (dns_name_equal(name, gorigin)) {
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
goto next;
}
/*
if (!found) {
dumpnode(name, node);
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
}
next:
* Write a node to the output file, and restart the worker task.
*/
lock_and_dumpnode(dns_fixedname_name(&fname), node);
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
isc_async_current(assignwork, NULL);
}
"rrsig)");
}
dns_rdatasetiter_destroy(&rdsiter);
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
}
dns_dbiterator_destroy(&dbiter);
} else {
check_result(result, "dns_dbiterator_next()");
}
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
continue;
}
check_dns_dbiterator_current(result);
active = active_node(nextnode);
if (!active) {
- dns_db_detachnode(gdb, &nextnode);
+ dns_db_detachnode(&nextnode);
result = dns_dbiterator_next(dbiter);
continue;
}
remove_sigs(nextnode, false, 0);
remove_records(nextnode, dns_rdatatype_nsec,
false);
- dns_db_detachnode(gdb, &nextnode);
+ dns_db_detachnode(&nextnode);
result = dns_dbiterator_next(dbiter);
continue;
}
- dns_db_detachnode(gdb, &nextnode);
+ dns_db_detachnode(&nextnode);
break;
}
if (result == ISC_R_NOMORE) {
result = dns_nsec_build(gdb, gversion, node, nextname,
zone_soa_min_ttl);
check_result(result, "dns_nsec_build()");
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
}
dns_dbiterator_destroy(&dbiter);
result = ISC_R_SUCCESS;
}
check_result(result, "addnsec3param: dns_db_addrdataset()");
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
}
static void
result = ISC_R_SUCCESS;
}
check_result(result, "addnsec3: dns_db_addrdataset()");
- dns_db_detachnode(gdb, &nsec3node);
+ dns_db_detachnode(&nsec3node);
}
/*%
dns_rdataset_disassociate(&rdataset);
}
dns_rdatasetiter_destroy(&rdsiter);
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
}
result = dns_diff_applysilently(&del, gdb, gversion);
} else {
check_result(result, "dns_dbiterator_next()");
}
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
continue;
}
check_dns_dbiterator_current(result);
active = active_node(nextnode);
if (!active) {
- dns_db_detachnode(gdb, &nextnode);
+ dns_db_detachnode(&nextnode);
result = dns_dbiterator_next(dbiter);
continue;
}
dns_name_issubdomain(nextname, zonecut)))
{
remove_sigs(nextnode, false, 0);
- dns_db_detachnode(gdb, &nextnode);
+ dns_db_detachnode(&nextnode);
result = dns_dbiterator_next(dbiter);
continue;
}
if (OPTOUT(nsec3flags) &&
!secure(nextname, nextnode))
{
- dns_db_detachnode(gdb, &nextnode);
+ dns_db_detachnode(&nextnode);
result = dns_dbiterator_next(dbiter);
continue;
}
} else if (has_dname(gdb, gversion, nextnode)) {
zonecut = savezonecut(&fzonecut, nextname);
}
- dns_db_detachnode(gdb, &nextnode);
+ dns_db_detachnode(&nextnode);
break;
}
if (result == ISC_R_NOMORE) {
dns_name_downcase(name, name);
hashlist_add_dns_name(hashlist, name, hashalg, iterations, salt,
salt_len, false);
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
/*
* Add hashes for empty nodes. Use closest encloser logic.
* The closest encloser either has data or is a empty
check_dns_dbiterator_current(result);
nsec3clean(name, node, hashalg, iterations, salt, salt_len,
hashlist);
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
}
dns_dbiterator_destroy(&dbiter);
} else {
check_result(result, "dns_dbiterator_next()");
}
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
continue;
}
check_dns_dbiterator_current(result);
active = active_node(nextnode);
if (!active) {
- dns_db_detachnode(gdb, &nextnode);
+ dns_db_detachnode(&nextnode);
result = dns_dbiterator_next(dbiter);
continue;
}
(zonecut != NULL &&
dns_name_issubdomain(nextname, zonecut)))
{
- dns_db_detachnode(gdb, &nextnode);
+ dns_db_detachnode(&nextnode);
result = dns_dbiterator_next(dbiter);
continue;
}
if (OPTOUT(nsec3flags) &&
!secure(nextname, nextnode))
{
- dns_db_detachnode(gdb, &nextnode);
+ dns_db_detachnode(&nextnode);
result = dns_dbiterator_next(dbiter);
continue;
}
} else if (has_dname(gdb, gversion, nextnode)) {
zonecut = savezonecut(&fzonecut, nextname);
}
- dns_db_detachnode(gdb, &nextnode);
+ dns_db_detachnode(&nextnode);
break;
}
if (result == ISC_R_NOMORE) {
dns_dbiterator_pause(dbiter);
addnsec3(name, node, salt, salt_len, iterations, hashlist,
zone_soa_min_ttl);
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
/*
* Add NSEC3's for empty nodes. Use closest encloser logic.
*/
if (dns_rdataset_isassociated(&soasigs)) {
dns_rdataset_disassociate(&soasigs);
}
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
dns_db_closeversion(gdb, ¤tversion, false);
}
isc_result_totext(result));
}
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
dns_db_closeversion(gdb, &ver, true);
dns_diff_clear(&diff);
dns_rdata_freestruct(&dnskey);
}
dns_rdataset_disassociate(&rdataset);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
dns_db_closeversion(db, ¤tversion, false);
if (!have_non_ksk && !ignore_kskflag) {
if (disable_zone_check) {
dns_rdataset_disassociate(&rdataset);
}
if (node != NULL) {
- dns_db_detachnode(gdb, &node);
+ dns_db_detachnode(&node);
}
dns_db_closeversion(gdb, &ver, false);
}
} bdb_t;
struct bdbnode {
- unsigned int magic;
+ DBNODE_FIELDS;
+
isc_refcount_t references;
bdb_t *bdb;
ISC_LIST(dns_rdatalist_t) lists;
ISC_LIST(isc_buffer_t) buffers;
- dns_name_t *name;
ISC_LINK(bdbnode_t) link;
dns_rdatacallbacks_t callbacks;
};
dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset DNS__DB_FLARG);
+/*
+ * Node methods forward declarations
+ */
static void
-attachnode(dns_db_t *db, dns_dbnode_t *source,
- dns_dbnode_t **targetp DNS__DB_FLARG);
-
+bdbnode_attachnode(dns_dbnode_t *source, dns_dbnode_t **targetp DNS__DB_FLARG);
static void
-detachnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG);
+bdbnode_detachnode(dns_dbnode_t **nodep DNS__DB_FLARG);
+
+/*
+ * Node methods structure
+ */
+static dns_dbnode_methods_t bdbnode_methods = (dns_dbnode_methods_t){
+ .attachnode = bdbnode_attachnode,
+ .detachnode = bdbnode_detachnode,
+};
/*
* Helper functions to convert text to wire forma.
static void
disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) {
dns_dbnode_t *node = rdataset->rdlist.node;
- bdbnode_t *bdbnode = (bdbnode_t *)node;
- dns_db_t *db = (dns_db_t *)bdbnode->bdb;
- detachnode(db, &node DNS__DB_FLARG_PASS);
+ bdbnode_detachnode(&node DNS__DB_FLARG_PASS);
dns_rdatalist_disassociate(rdataset DNS__DB_FLARG_PASS);
}
static void
rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG) {
dns_dbnode_t *node = source->rdlist.node;
- bdbnode_t *bdbnode = (bdbnode_t *)node;
- dns_db_t *db = (dns_db_t *)bdbnode->bdb;
dns_rdatalist_clone(source, target DNS__DB_FLARG_PASS);
- attachnode(db, node, &target->rdlist.node DNS__DB_FLARG_PASS);
+ bdbnode_attachnode(node, &target->rdlist.node DNS__DB_FLARG_PASS);
}
static dns_rdatasetmethods_t bdb_rdataset_methods = {
};
static void
-new_rdataset(dns_rdatalist_t *rdatalist, dns_db_t *db, dns_dbnode_t *node,
- dns_rdataset_t *rdataset) {
+new_rdataset(dns_rdatalist_t *rdatalist, dns_db_t *db ISC_ATTR_UNUSED,
+ dns_dbnode_t *node, dns_rdataset_t *rdataset) {
dns_rdatalist_tordataset(rdatalist, rdataset);
rdataset->methods = &bdb_rdataset_methods;
- dns_db_attachnode(db, node, &rdataset->rdlist.node);
+ dns_db_attachnode(node, &rdataset->rdlist.node);
}
/*
static void
rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) {
bdb_rdatasetiter_t *bdbiterator = (bdb_rdatasetiter_t *)(*iteratorp);
- detachnode(bdbiterator->common.db,
- &bdbiterator->common.node DNS__DB_FLARG_PASS);
+ bdbnode_detachnode(&bdbiterator->common.node DNS__DB_FLARG_PASS);
isc_mem_put(bdbiterator->common.db->mctx, bdbiterator,
sizeof(bdb_rdatasetiter_t));
*iteratorp = NULL;
isc_refcount_init(&node->references, 1);
node->magic = BDBNODE_MAGIC;
+ node->methods = &bdbnode_methods;
*nodep = node;
return ISC_R_SUCCESS;
isc_buffer_free(&b);
}
- if (node->name != NULL) {
- dns_name_free(node->name, mctx);
- isc_mem_put(mctx, node->name, sizeof(dns_name_t));
- }
-
node->magic = 0;
isc_mem_put(mctx, node, sizeof(bdbnode_t));
dns_db_detach((dns_db_t **)(void *)&bdb);
if (nodep != NULL) {
*nodep = node;
} else if (node != NULL) {
- detachnode(db, &node DNS__DB_FLARG_PASS);
+ bdbnode_detachnode(&node DNS__DB_FLARG_PASS);
}
return result;
}
static void
-attachnode(dns_db_t *db, dns_dbnode_t *source,
- dns_dbnode_t **targetp DNS__DB_FLARG) {
- bdb_t *bdb = (bdb_t *)db;
+bdbnode_attachnode(dns_dbnode_t *source, dns_dbnode_t **targetp DNS__DB_FLARG) {
bdbnode_t *node = (bdbnode_t *)source;
- REQUIRE(VALID_BDB(bdb));
-
isc_refcount_increment(&node->references);
*targetp = source;
}
static void
-detachnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
- bdb_t *bdb = (bdb_t *)db;
+bdbnode_detachnode(dns_dbnode_t **nodep DNS__DB_FLARG) {
bdbnode_t *node = NULL;
- REQUIRE(VALID_BDB(bdb));
REQUIRE(nodep != NULL && *nodep != NULL);
node = (bdbnode_t *)(*nodep);
.common.magic = DNS_RDATASETITER_MAGIC,
};
- attachnode(db, node, &iterator->common.node DNS__DB_FLARG_PASS);
+ bdbnode_attachnode(node, &iterator->common.node DNS__DB_FLARG_PASS);
*iteratorp = (dns_rdatasetiter_t *)iterator;
.currentversion = currentversion,
.attachversion = attachversion,
.closeversion = closeversion,
- .attachnode = attachnode,
- .detachnode = detachnode,
.findrdataset = findrdataset,
.allrdatasets = allrdatasets,
.getoriginnode = getoriginnode,
cleanup:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
cleanup:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
/* Free resources which are not of interest */
if (resp->node != NULL) {
- dns_db_detachnode(resp->db, &resp->node);
+ dns_db_detachnode(&resp->node);
}
if (resp->db != NULL) {
dns_db_detach(&resp->db);
dns_rdataset_disassociate(&privset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (version != NULL) {
dns_db_closeversion(db, &version, false);
dns_rdataset_disassociate(&rdataset);
}
if (apexnode != NULL) {
- dns_db_detachnode(db, &apexnode);
+ dns_db_detachnode(&apexnode);
}
if (dbversion != NULL) {
dns_db_closeversion(db, &dbversion, false);
sigrdataset DNS__DB_FLARG_PASS);
}
-static void
-attachnode(dns_db_t *db, dns_dbnode_t *source,
- dns_dbnode_t **targetp DNS__DB_FLARG) {
- sampledb_t *sampledb = (sampledb_t *)db;
-
- REQUIRE(VALID_SAMPLEDB(sampledb));
-
- dns__db_attachnode(sampledb->db, source, targetp DNS__DB_FLARG_PASS);
-}
-
-static void
-detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) {
- sampledb_t *sampledb = (sampledb_t *)db;
-
- REQUIRE(VALID_SAMPLEDB(sampledb));
-
- dns__db_detachnode(sampledb->db, targetp DNS__DB_FLARG_PASS);
-}
-
static isc_result_t
createiterator(dns_db_t *db, unsigned int options,
dns_dbiterator_t **iteratorp) {
CHECK(dns__db_addrdataset(sampledb->db, node, version, now, rdataset,
options, addedrdataset DNS__DB_FLARG_PASS));
if (dns_rdatatype_isaddr(rdataset->type)) {
- CHECK(dns_db_nodefullname(sampledb->db, node,
- dns_fixedname_name(&name)));
+ CHECK(dns_db_nodefullname(node, dns_fixedname_name(&name)));
CHECK(syncptrs(sampledb->inst, dns_fixedname_name(&name),
rdataset, DNS_DIFFOP_ADD));
}
}
if (dns_rdatatype_isaddr(rdataset->type)) {
- CHECK(dns_db_nodefullname(sampledb->db, node,
- dns_fixedname_name(&name)));
+ CHECK(dns_db_nodefullname(node, dns_fixedname_name(&name)));
CHECK(syncptrs(sampledb->inst, dns_fixedname_name(&name),
rdataset, DNS_DIFFOP_DEL));
}
return dns_db_setcachestats(sampledb->db, stats);
}
-static isc_result_t
-nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name) {
- sampledb_t *sampledb = (sampledb_t *)db;
-
- REQUIRE(VALID_SAMPLEDB(sampledb));
-
- return dns_db_nodefullname(sampledb->db, node, name);
-}
-
/*
* DB interface definition. Database driver uses this structure to
* determine which implementation of dns_db_*() function to call.
.findnode = findnode,
.find = find,
.findzonecut = findzonecut,
- .attachnode = attachnode,
- .detachnode = detachnode,
.createiterator = createiterator,
.findrdataset = findrdataset,
.allrdatasets = allrdatasets,
.findnodeext = findnodeext,
.findext = findext,
.setcachestats = setcachestats,
- .nodefullname = nodefullname,
};
/* Auxiliary driver functions. */
CHECK(dns_db_addrdataset(db, node, version, 0, &rdataset, 0, NULL));
cleanup:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
CHECK(dns_db_addrdataset(db, node, version, 0, &rdataset, 0, NULL));
cleanup:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
CHECK(dns_db_addrdataset(db, node, version, 0, &rdataset, 0, NULL));
cleanup:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
* Cleanup things we don't care about.
*/
if (resp->node != NULL) {
- dns_db_detachnode(resp->db, &resp->node);
+ dns_db_detachnode(&resp->node);
}
if (resp->db != NULL) {
dns_db_detach(&resp->db);
if (result != ISC_R_SUCCESS && answer == ISC_R_SUCCESS) {
answer = result;
}
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
result = dns_dbiterator_next(iter);
}
answer = result;
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (iter != NULL) {
dns_dbiterator_destroy(&iter);
}
if (top != NULL) {
- dns_db_detachnode(db, &top);
+ dns_db_detachnode(&top);
}
return answer;
goto cleanup_db;
}
result = clearnode(cache->db, node);
- dns_db_detachnode(cache->db, &node);
+ dns_db_detachnode(&node);
}
cleanup_db:
vers_node = node;
} else if (node == vers_node) {
/* Skip the already processed version node */
- dns_db_detachnode(updb, &node);
+ dns_db_detachnode(&node);
result = dns_dbiterator_next(updbit);
continue;
}
DNS_LOGMODULE_CATZ, ISC_LOG_ERROR,
"catz: failed to fetch rrdatasets - %s",
isc_result_totext(result));
- dns_db_detachnode(updb, &node);
+ dns_db_detachnode(&node);
break;
}
dns_rdatasetiter_destroy(&rdsiter);
- dns_db_detachnode(updb, &node);
+ dns_db_detachnode(&node);
if (!is_vers_processed) {
is_vers_processed = true;
*/
if (node != NULL) {
INSIST(db != NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (db != NULL) {
dns_db_detach(&db);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (db != NULL) {
dns_db_detach(&db);
}
void
-dns__db_attachnode(dns_db_t *db, dns_dbnode_t *source,
- dns_dbnode_t **targetp DNS__DB_FLARG) {
+dns__db_attachnode(dns_dbnode_t *source, dns_dbnode_t **targetp DNS__DB_FLARG) {
/*
* Attach *targetp to source.
*/
- REQUIRE(DNS_DB_VALID(db));
REQUIRE(source != NULL);
REQUIRE(targetp != NULL && *targetp == NULL);
+ REQUIRE(source->methods != NULL && source->methods->attachnode != NULL);
- (db->methods->attachnode)(db, source, targetp DNS__DB_FLARG_PASS);
+ (source->methods->attachnode)(source, targetp DNS__DB_FLARG_PASS);
}
void
-dns__db_detachnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
+dns__db_detachnode(dns_dbnode_t **nodep DNS__DB_FLARG) {
/*
* Detach *nodep from its node.
*/
- REQUIRE(DNS_DB_VALID(db));
REQUIRE(nodep != NULL && *nodep != NULL);
+ dns_dbnode_t *node = *nodep;
+ REQUIRE(node->methods != NULL && node->methods->detachnode != NULL);
- (db->methods->detachnode)(db, nodep DNS__DB_FLARG_PASS);
+ (node->methods->detachnode)(nodep DNS__DB_FLARG_PASS);
ENSURE(*nodep == NULL);
}
dns_rdataset_disassociate(&rdataset);
freenode:
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
}
void
-dns_db_locknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type) {
- if (db->methods->locknode != NULL) {
- (db->methods->locknode)(db, node, type);
+dns_db_locknode(dns_dbnode_t *node, isc_rwlocktype_t type) {
+ REQUIRE(node != NULL && node->methods != NULL);
+ if (node->methods->locknode != NULL) {
+ (node->methods->locknode)(node, type);
}
}
void
-dns_db_unlocknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type) {
- if (db->methods->unlocknode != NULL) {
- (db->methods->unlocknode)(db, node, type);
+dns_db_unlocknode(dns_dbnode_t *node, isc_rwlocktype_t type) {
+ REQUIRE(node != NULL && node->methods != NULL);
+ if (node->methods->unlocknode != NULL) {
+ (node->methods->unlocknode)(node, type);
}
}
void
-dns_db_expiredata(dns_db_t *db, dns_dbnode_t *node, void *data) {
- if (db->methods->expiredata != NULL) {
- (db->methods->expiredata)(db, node, data);
+dns_db_expiredata(dns_dbnode_t *node, void *data) {
+ REQUIRE(node != NULL && node->methods != NULL);
+ if (node->methods->expiredata != NULL) {
+ (node->methods->expiredata)(node, data);
}
}
void
-dns_db_deletedata(dns_db_t *db, dns_dbnode_t *node, void *data) {
- if (db->methods->deletedata != NULL) {
- (db->methods->deletedata)(db, node, data);
+dns_db_deletedata(dns_dbnode_t *node, void *data) {
+ REQUIRE(node != NULL && node->methods != NULL);
+ if (node->methods->deletedata != NULL) {
+ (node->methods->deletedata)(node, data);
}
}
isc_result_t
-dns_db_nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name) {
- REQUIRE(db != NULL);
- REQUIRE(node != NULL);
+dns_db_nodefullname(dns_dbnode_t *node, dns_name_t *name) {
+ REQUIRE(node != NULL && node->methods != NULL);
REQUIRE(name != NULL);
- if (db->methods->nodefullname != NULL) {
- return (db->methods->nodefullname)(db, node, name);
+ if (node->methods != NULL && node->methods->nodefullname != NULL) {
+ return node->methods->nodefullname(node, name);
}
return ISC_R_NOTIMPLEMENTED;
}
}
CHECK(result);
}
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (dns_rdataset_isassociated(&ardataset)) {
dns_rdataset_disassociate(&ardataset);
}
failure:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
***** Types
*****/
-typedef struct dns_dbmethods {
+typedef struct dns_dbnode_methods {
+ isc_result_t (*nodefullname)(dns_dbnode_t *node, dns_name_t *name);
+
+ void (*attachnode)(dns_dbnode_t *source,
+ dns_dbnode_t **targetp DNS__DB_FLARG);
+ void (*detachnode)(dns_dbnode_t **targetp DNS__DB_FLARG);
+
+ void (*locknode)(dns_dbnode_t *node, isc_rwlocktype_t t);
+ void (*unlocknode)(dns_dbnode_t *node, isc_rwlocktype_t t);
+
+ void (*deletedata)(dns_dbnode_t *node, void *data);
+ void (*expiredata)(dns_dbnode_t *node, void *data);
+} dns_dbnode_methods_t;
+
+typedef struct dns_db_methods {
void (*destroy)(dns_db_t *db);
isc_result_t (*beginload)(dns_db_t *db,
dns_rdatacallbacks_t *callbacks);
dns_name_t *dcname,
dns_rdataset_t *rdataset,
dns_rdataset_t *sigrdataset DNS__DB_FLARG);
- void (*attachnode)(dns_db_t *db, dns_dbnode_t *source,
- dns_dbnode_t **targetp DNS__DB_FLARG);
- void (*detachnode)(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG);
isc_result_t (*createiterator)(dns_db_t *db, unsigned int options,
dns_dbiterator_t **iteratorp);
isc_result_t (*findrdataset)(dns_db_t *db, dns_dbnode_t *node,
isc_result_t (*setservestalerefresh)(dns_db_t *db, uint32_t interval);
isc_result_t (*getservestalerefresh)(dns_db_t *db, uint32_t *interval);
isc_result_t (*setgluecachestats)(dns_db_t *db, isc_stats_t *stats);
- void (*locknode)(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t t);
- void (*unlocknode)(dns_db_t *db, dns_dbnode_t *node,
- isc_rwlocktype_t t);
void (*addglue)(dns_db_t *db, dns_dbversion_t *version,
dns_rdataset_t *rdataset, dns_message_t *msg);
- void (*expiredata)(dns_db_t *db, dns_dbnode_t *node, void *data);
- void (*deletedata)(dns_db_t *db, dns_dbnode_t *node, void *data);
- isc_result_t (*nodefullname)(dns_db_t *db, dns_dbnode_t *node,
- dns_name_t *name);
void (*setmaxrrperset)(dns_db_t *db, uint32_t value);
void (*setmaxtypepername)(dns_db_t *db, uint32_t value);
isc_result_t (*getzoneversion)(dns_db_t *db, isc_buffer_t *b);
#define DNS_DB_MAGIC ISC_MAGIC('D', 'N', 'S', 'D')
#define DNS_DB_VALID(db) ISC_MAGIC_VALID(db, DNS_DB_MAGIC)
+#define DBNODE_FIELDS \
+ unsigned int magic; \
+ uint16_t locknum; \
+ dns_dbnode_methods_t *methods; \
+ isc_mem_t *mctx; \
+ dns_name_t name;
+
+struct dns_dbnode {
+ DBNODE_FIELDS;
+};
+
/*%
* This structure is actually just the common prefix of a DNS db
* implementation's version of a dns_db_t.
* errors.
*/
-#define dns_db_attachnode(db, source, targetp) \
- dns__db_attachnode(db, source, targetp DNS__DB_FILELINE)
+#define dns_db_attachnode(source, targetp) \
+ dns__db_attachnode(source, targetp DNS__DB_FILELINE)
void
-dns__db_attachnode(dns_db_t *db, dns_dbnode_t *source,
- dns_dbnode_t **targetp DNS__DB_FLARG);
+dns__db_attachnode(dns_dbnode_t *source, dns_dbnode_t **targetp DNS__DB_FLARG);
/*%<
* Attach *targetp to source.
*
* \li *targetp is attached to source.
*/
-#define dns_db_detachnode(db, nodep) \
- dns__db_detachnode(db, nodep DNS__DB_FILELINE)
+#define dns_db_detachnode(nodep) dns__db_detachnode(nodep DNS__DB_FILELINE)
void
-dns__db_detachnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG);
+dns__db_detachnode(dns_dbnode_t **nodep DNS__DB_FLARG);
/*%<
* Detach *nodep from its node.
*
*/
void
-dns_db_locknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type);
+dns_db_locknode(dns_dbnode_t *node, isc_rwlocktype_t type);
void
-dns_db_unlocknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type);
+dns_db_unlocknode(dns_dbnode_t *node, isc_rwlocktype_t type);
/*%<
* Lock/unlock a single node within a database so that data stored
* there can be manipulated directly.
*/
void
-dns_db_expiredata(dns_db_t *db, dns_dbnode_t *node, void *data);
+dns_db_expiredata(dns_dbnode_t *node, void *data);
/*%<
* Tell the database 'db' to mark a block of data 'data' stored at
* node 'node' as expired.
*/
void
-dns_db_deletedata(dns_db_t *db, dns_dbnode_t *node, void *data);
+dns_db_deletedata(dns_dbnode_t *node, void *data);
/*%<
- * Tell the database 'db' to prepare to delete the block of data 'data'
+ * Tell the database to prepare to delete the block of data 'data'
* stored at node 'node. This may include, for example, removing the
* data from an LRU list or a heap.
*/
isc_result_t
-dns_db_nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name);
+dns_db_nodefullname(dns_dbnode_t *node, dns_name_t *name);
/*%<
* Get the name associated with a database node.
*
* this rdataset.
*/
- dns_db_t *db;
dns_dbnode_t *node;
/*%<
* The database and database node objects containing
typedef struct dns_compress dns_compress_t;
typedef enum dns_compress_flags dns_compress_flags_t;
typedef struct dns_compress_slot dns_compress_slot_t;
+typedef struct dns_dbnode dns_dbnode_t;
typedef struct dns_db dns_db_t;
typedef struct dns_dbimplementation dns_dbimplementation_t;
typedef struct dns_dbiterator dns_dbiterator_t;
typedef void dns_dbload_t;
-typedef struct dns_dbnode dns_dbnode_t; /* this is dummy struct for proper type
- checking */
-typedef struct dns_dbonupdatelistener dns_dbonupdatelistener_t;
-typedef struct dns_dbversion dns_dbversion_t;
-typedef struct dns_dlzimplementation dns_dlzimplementation_t;
-typedef struct dns_dlzdb dns_dlzdb_t;
+typedef struct dns_dbonupdatelistener dns_dbonupdatelistener_t;
+typedef struct dns_dbversion dns_dbversion_t;
+typedef struct dns_dlzimplementation dns_dlzimplementation_t;
+typedef struct dns_dlzdb dns_dlzdb_t;
typedef ISC_LIST(dns_dlzdb_t) dns_dlzdblist_t;
typedef struct dns_dyndbctx dns_dyndbctx_t;
typedef struct dns_sdlzimplementation dns_sdlzimplementation_t;
dns_difftuple_create(mctx, op, zonename, rdataset.ttl, &rdata, tp);
dns_rdataset_disassociate(&rdataset);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
freenode:
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
nonode:
UNEXPECTED_ERROR("missing SOA");
return result;
result = ISC_R_SUCCESS;
cleanup_node:
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
result = dns_db_allrdatasets(dctx->db, node, dctx->version,
options, dctx->now, &rdsiter);
if (result != ISC_R_SUCCESS) {
- dns_db_detachnode(dctx->db, &node);
+ dns_db_detachnode(&node);
goto cleanup;
}
result = (dctx->dumpsets)(dctx->mctx, name, rdsiter,
&dctx->tctx, &buffer, dctx->f);
dns_rdatasetiter_destroy(&rdsiter);
if (result != ISC_R_SUCCESS) {
- dns_db_detachnode(dctx->db, &node);
+ dns_db_detachnode(&node);
goto cleanup;
}
- dns_db_detachnode(dctx->db, &node);
+ dns_db_detachnode(&node);
}
if (result == ISC_R_NOMORE) {
result = dns_db_findrdataset(db, node, version, dns_rdatatype_dnskey, 0,
0, &rdataset, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result == ISC_R_NOTFOUND) {
*answer = false;
dns_rdatasetiter_destroy(&iter);
cleanup_node:
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
failure:
dns_rdataset_disassociate(&rdataset);
cleanup_node:
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
result = dns_db_findrdataset(db, node, version,
dns_rdatatype_nsec3, 0,
(isc_stdtime_t)0, &rdataset, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result != ISC_R_SUCCESS) {
continue;
}
CHECK(dns_nsec3_buildrdata(db, version, node, hash, flags, iterations,
salt, salt_length, nexthash, next_length,
nsec3buf, &rdata));
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
/*
* Delete the old NSEC3 and record the change.
CHECK(do_one_tuple(&tuple, db, version, diff));
INSIST(tuple == NULL);
dns_rdata_reset(&rdata);
- dns_db_detachnode(db, &newnode);
+ dns_db_detachnode(&newnode);
/*
* Add missing NSEC3 records for empty nodes
result = find_nsec3(&nsec3, &rdataset, nsec3param);
dns_rdataset_disassociate(&rdataset);
if (result == ISC_R_SUCCESS) {
- dns_db_detachnode(db, &newnode);
+ dns_db_detachnode(&newnode);
break;
}
} else if (result == ISC_R_NOTFOUND) {
result = dns_db_findrdataset(
db, node, version, dns_rdatatype_nsec3, 0,
(isc_stdtime_t)0, &rdataset, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result != ISC_R_SUCCESS) {
continue;
}
CHECK(do_one_tuple(&tuple, db, version, diff));
INSIST(tuple == NULL);
dns_rdata_reset(&rdata);
- dns_db_detachnode(db, &newnode);
+ dns_db_detachnode(&newnode);
} while (1);
/* result cannot be ISC_R_NOMORE here */
dns_rdataset_disassociate(&rdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (newnode != NULL) {
- dns_db_detachnode(db, &newnode);
+ dns_db_detachnode(&newnode);
}
return result;
}
result = dns_db_findrdataset(db, node, version,
dns_rdatatype_nsec3param, 0, 0, &rdataset,
NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result == ISC_R_NOTFOUND) {
return ISC_R_SUCCESS;
}
dns_rdataset_disassociate(&rdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
failure:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
if (dns_rdataset_isassociated(&rdataset)) {
dns_rdataset_disassociate(&rdataset);
}
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
dns_rdataset_disassociate(&prdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
CHECK(dns_dbiterator_pause(dbit));
result = dns_db_findrdataset(db, node, version, dns_rdatatype_nsec3, 0,
(isc_stdtime_t)0, &rdataset, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result == ISC_R_NOTFOUND) {
goto cleanup_orphaned_ents;
}
result = dns_db_findrdataset(db, node, version,
dns_rdatatype_nsec3, 0,
(isc_stdtime_t)0, &rdataset, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result != ISC_R_SUCCESS) {
continue;
}
result = dns_db_findrdataset(db, node, version,
dns_rdatatype_nsec3, 0,
(isc_stdtime_t)0, &rdataset, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result == ISC_R_NOTFOUND) {
goto success;
}
result = dns_db_findrdataset(
db, node, version, dns_rdatatype_nsec3, 0,
(isc_stdtime_t)0, &rdataset, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result != ISC_R_SUCCESS) {
continue;
}
dns_rdataset_disassociate(&rdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
dns_rdataset_disassociate(&rdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
if (result != ISC_R_SUCCESS) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
try_private:
if (privatetype == 0 || complete) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
*answer = false;
return ISC_R_SUCCESS;
}
result = dns_db_findrdataset(db, node, version, privatetype, 0, 0,
&rdataset, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result == ISC_R_NOTFOUND) {
*answer = false;
return ISC_R_SUCCESS;
dns_resolver_destroyfetch(&resp->fetch);
if (resp->node != NULL) {
- dns_db_detachnode(resp->db, &resp->node);
+ dns_db_detachnode(&resp->node);
}
if (resp->db != NULL) {
dns_db_detach(&resp->db);
dns_rdataset_disassociate(&privateset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
*/
#define DNS_QPDB_EXPIRE_TTL_COUNT 10
+/*%
+ * Forward declarations
+ */
+typedef struct qpcache qpcache_t;
+
/*%
* This is the structure that is used for each node in the qp trie of
* trees.
*/
typedef struct qpcnode qpcnode_t;
struct qpcnode {
- dns_name_t name;
- isc_mem_t *mctx;
+ DBNODE_FIELDS;
+
+ qpcache_t *qpdb;
uint8_t : 0;
unsigned int delegating : 1;
unsigned int havensec : 1;
uint8_t : 0;
- uint16_t locknum;
-
/*
* 'erefs' counts external references held by a caller: for
* example, it could be incremented by dns_db_findnode(),
} qpcache_bucket_t;
-typedef struct qpcache qpcache_t;
struct qpcache {
/* Unlocked. */
dns_db_t common;
ISC_REFCOUNT_STATIC_DECL(qpcnode);
#endif
+/*
+ * Node methods forward declarations
+ */
+static void
+qpcnode_attachnode(dns_dbnode_t *source, dns_dbnode_t **targetp DNS__DB_FLARG);
+static void
+qpcnode_detachnode(dns_dbnode_t **nodep DNS__DB_FLARG);
+static void
+qpcnode_locknode(dns_dbnode_t *node, isc_rwlocktype_t type);
+static void
+qpcnode_unlocknode(dns_dbnode_t *node, isc_rwlocktype_t type);
+static void
+qpcnode_deletedata(dns_dbnode_t *node, void *data);
+static void
+qpcnode_expiredata(dns_dbnode_t *node, void *data);
+
+static dns_dbnode_methods_t qpcnode_methods = (dns_dbnode_methods_t){
+ .attachnode = qpcnode_attachnode,
+ .detachnode = qpcnode_detachnode,
+ .locknode = qpcnode_locknode,
+ .unlocknode = qpcnode_unlocknode,
+ .deletedata = qpcnode_deletedata,
+ .expiredata = qpcnode_expiredata,
+};
+
/* QP methods */
static void
qp_attach(void *uctx, void *pval, uint32_t ival);
uint_least16_t newattributes = 0;
dns_stats_t *stats = NULL;
+ qpcache_t *qpdb = HEADERNODE(header)->qpdb;
/*
* If we are already ancient there is nothing to do.
*/
* Decrement and increment the stats counter for the appropriate
* RRtype.
*/
- stats = dns_db_getrrsetstats(header->db);
+ stats = dns_db_getrrsetstats(&qpdb->common);
if (stats != NULL) {
update_rrsetstats(stats, header->type, attributes, false);
update_rrsetstats(stats, header->type, newattributes, true);
mark_ancient(header);
if (isc_refcount_current(&HEADERNODE(header)->erefs) == 0) {
- qpcache_t *qpdb = (qpcache_t *)header->db;
+ qpcache_t *qpdb = HEADERNODE(header)->qpdb;
/*
* If no one else is using the node, we can clean it up now.
}
static void
-expiredata(dns_db_t *db, dns_dbnode_t *node, void *data) {
- qpcache_t *qpdb = (qpcache_t *)db;
+qpcnode_expiredata(dns_dbnode_t *node, void *data) {
qpcnode_t *qpnode = (qpcnode_t *)node;
+ qpcache_t *qpdb = (qpcache_t *)qpnode->qpdb;
+
dns_slabheader_t *header = data;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
- isc_rwlock_t *nlock = &qpdb->buckets[qpnode->locknum].lock;
+ isc_rwlock_t *nlock = &qpdb->buckets[qpnode->locknum].lock;
NODE_WRLOCK(nlock, &nlocktype);
expireheader(header, &nlocktype, &tlocktype,
dns_expire_flush DNS__DB_FILELINE);
new_qpcnode(qpcache_t *qpdb, const dns_name_t *name, dns_namespace_t nspace) {
qpcnode_t *newdata = isc_mem_get(qpdb->common.mctx, sizeof(*newdata));
*newdata = (qpcnode_t){
+ .methods = &qpcnode_methods,
+ .qpdb = qpdb,
.name = DNS_NAME_INITEMPTY,
.nspace = nspace,
.references = ISC_REFCOUNT_INITIALIZER(1),
return result;
}
-static void
-qpcache_attachnode(dns_db_t *db, dns_dbnode_t *source,
- dns_dbnode_t **targetp DNS__DB_FLARG) {
- REQUIRE(VALID_QPDB((qpcache_t *)db));
- REQUIRE(targetp != NULL && *targetp == NULL);
-
- qpcache_t *qpdb = (qpcache_t *)db;
- qpcnode_t *node = (qpcnode_t *)source;
-
- qpcnode_acquire(qpdb, node, isc_rwlocktype_none,
- isc_rwlocktype_none DNS__DB_FLARG_PASS);
-
- *targetp = source;
-}
-
-static void
-qpcache_detachnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
- qpcache_t *qpdb = (qpcache_t *)db;
- qpcnode_t *node = NULL;
- isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
- isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
- isc_rwlock_t *nlock = NULL;
-
- REQUIRE(VALID_QPDB(qpdb));
- REQUIRE(nodep != NULL && *nodep != NULL);
-
- node = (qpcnode_t *)(*nodep);
- *nodep = NULL;
- nlock = &qpdb->buckets[node->locknum].lock;
-
- /*
- * We can't destroy qpcache while holding a nodelock, so we need to
- * reference it before acquiring the lock and release it afterward.
- * Additionally, we must ensure that we don't destroy the database while
- * the NODE_LOCK is locked.
- */
- qpcache_ref(qpdb);
-
- rcu_read_lock();
- NODE_RDLOCK(nlock, &nlocktype);
- qpcnode_release(qpdb, node, &nlocktype, &tlocktype DNS__DB_FLARG_PASS);
- NODE_UNLOCK(nlock, &nlocktype);
- rcu_read_unlock();
-
- qpcache_detach(&qpdb);
-}
-
static isc_result_t
qpcache_createiterator(dns_db_t *db, unsigned int options ISC_ATTR_UNUSED,
dns_dbiterator_t **iteratorp) {
return prio_type(header->type);
}
+static void
+qpcnode_attachnode(dns_dbnode_t *source, dns_dbnode_t **targetp DNS__DB_FLARG) {
+ REQUIRE(targetp != NULL && *targetp == NULL);
+
+ qpcnode_t *node = (qpcnode_t *)source;
+ qpcache_t *qpdb = (qpcache_t *)node->qpdb;
+
+ qpcnode_acquire(qpdb, node, isc_rwlocktype_none,
+ isc_rwlocktype_none DNS__DB_FLARG_PASS);
+
+ *targetp = source;
+}
+
+static void
+qpcnode_detachnode(dns_dbnode_t **nodep DNS__DB_FLARG) {
+ qpcnode_t *node = NULL;
+ isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
+ isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
+ isc_rwlock_t *nlock = NULL;
+
+ REQUIRE(nodep != NULL && *nodep != NULL);
+
+ node = (qpcnode_t *)(*nodep);
+ qpcache_t *qpdb = (qpcache_t *)node->qpdb;
+ *nodep = NULL;
+ nlock = &qpdb->buckets[node->locknum].lock;
+
+ REQUIRE(VALID_QPDB(qpdb));
+
+ /*
+ * We can't destroy qpcache while holding a nodelock, so we need to
+ * reference it before acquiring the lock and release it afterward.
+ * Additionally, we must ensure that we don't destroy the database while
+ * the NODE_LOCK is locked.
+ */
+ qpcache_ref(qpdb);
+
+ rcu_read_lock();
+ NODE_RDLOCK(nlock, &nlocktype);
+ qpcnode_release(qpdb, node, &nlocktype, &tlocktype DNS__DB_FLARG_PASS);
+ NODE_UNLOCK(nlock, &nlocktype);
+ rcu_read_unlock();
+
+ qpcache_detach(&qpdb);
+}
+
static isc_result_t
add(qpcache_t *qpdb, qpcnode_t *qpnode,
const dns_name_t *nodename ISC_ATTR_UNUSED, dns_slabheader_t *newheader,
REQUIRE(VALID_QPDB(qpdb));
REQUIRE(version == NULL);
- result = dns_rdataslab_fromrdataset(rdataset, qpdb->common.mctx,
- ®ion, qpdb->maxrrperset);
+ result = dns_rdataslab_fromrdataset(rdataset, qpnode->mctx, ®ion,
+ qpdb->maxrrperset);
if (result != ISC_R_SUCCESS) {
if (result == DNS_R_TOOMANYRECORDS) {
dns__db_logtoomanyrecords((dns_db_t *)qpdb,
DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_OPTOUT);
}
if (rdataset->attributes.noqname) {
- result = addnoqname(qpdb->common.mctx, newheader,
- qpdb->maxrrperset, rdataset);
+ result = addnoqname(qpnode->mctx, newheader, qpdb->maxrrperset,
+ rdataset);
if (result != ISC_R_SUCCESS) {
dns_slabheader_destroy(&newheader);
return result;
}
}
if (rdataset->attributes.closest) {
- result = addclosest(qpdb->common.mctx, newheader,
- qpdb->maxrrperset, rdataset);
+ result = addclosest(qpnode->mctx, newheader, qpdb->maxrrperset,
+ rdataset);
if (result != ISC_R_SUCCESS) {
dns_slabheader_destroy(&newheader);
return result;
}
static void
-locknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type) {
- qpcache_t *qpdb = (qpcache_t *)db;
+qpcnode_locknode(dns_dbnode_t *node, isc_rwlocktype_t type) {
qpcnode_t *qpnode = (qpcnode_t *)node;
+ qpcache_t *qpdb = qpnode->qpdb;
RWLOCK(&qpdb->buckets[qpnode->locknum].lock, type);
}
static void
-unlocknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type) {
- qpcache_t *qpdb = (qpcache_t *)db;
+qpcnode_unlocknode(dns_dbnode_t *node, isc_rwlocktype_t type) {
qpcnode_t *qpnode = (qpcnode_t *)node;
+ qpcache_t *qpdb = qpnode->qpdb;
RWUNLOCK(&qpdb->buckets[qpnode->locknum].lock, type);
}
iterator = (qpc_rditer_t *)(*iteratorp);
- dns__db_detachnode(iterator->common.db,
- &iterator->common.node DNS__DB_FLARG_PASS);
+ dns__db_detachnode(&iterator->common.node DNS__DB_FLARG_PASS);
isc_mem_put(iterator->common.db->mctx, iterator, sizeof(*iterator));
*iteratorp = NULL;
}
static void
-deletedata(dns_db_t *db ISC_ATTR_UNUSED, dns_dbnode_t *node ISC_ATTR_UNUSED,
- void *data) {
+qpcnode_deletedata(dns_dbnode_t *node ISC_ATTR_UNUSED, void *data) {
dns_slabheader_t *header = data;
- qpcache_t *qpdb = (qpcache_t *)header->db;
+ qpcache_t *qpdb = HEADERNODE(header)->qpdb;
+
int idx = HEADERNODE(header)->locknum;
if (header->heap != NULL && header->heap_index != 0) {
}
if (header->noqname != NULL) {
- dns_slabheader_freeproof(db->mctx, &header->noqname);
+ dns_slabheader_freeproof(qpdb->common.mctx, &header->noqname);
}
if (header->closest != NULL) {
- dns_slabheader_freeproof(db->mctx, &header->closest);
+ dns_slabheader_freeproof(qpdb->common.mctx, &header->closest);
}
}
.findnode = qpcache_findnode,
.find = qpcache_find,
.findzonecut = qpcache_findzonecut,
- .attachnode = qpcache_attachnode,
- .detachnode = qpcache_detachnode,
.createiterator = qpcache_createiterator,
.findrdataset = qpcache_findrdataset,
.allrdatasets = qpcache_allrdatasets,
.getservestalettl = getservestalettl,
.setservestalerefresh = setservestalerefresh,
.getservestalerefresh = getservestalerefresh,
- .locknode = locknode,
- .unlocknode = unlocknode,
- .expiredata = expiredata,
- .deletedata = deletedata,
.setmaxrrperset = setmaxrrperset,
.setmaxtypepername = setmaxtypepername,
};
ISC_REFCOUNT_STATIC_DECL(qpz_heap);
struct qpznode {
- dns_name_t name;
- isc_mem_t *mctx;
+ DBNODE_FIELDS;
qpz_heap_t *heap;
-
+ qpzonedb_t *qpdb;
/*
* 'erefs' counts external references held by a caller: for
* example, it could be incremented by dns_db_findnode(),
isc_refcount_t references;
isc_refcount_t erefs;
- uint16_t locknum;
_Atomic(dns_namespace_t) nspace;
atomic_bool havensec;
atomic_bool wild;
} qpz_load_t;
static dns_dbmethods_t qpdb_zonemethods;
+static dns_dbnode_methods_t qpznode_methods;
#if DNS_DB_NODETRACE
#define qpznode_ref(ptr) qpznode__ref(ptr, __func__, __FILE__, __LINE__)
new_qpznode(qpzonedb_t *qpdb, const dns_name_t *name, dns_namespace_t nspace) {
qpznode_t *newdata = isc_mem_get(qpdb->common.mctx, sizeof(*newdata));
*newdata = (qpznode_t){
+ .methods = &qpznode_methods,
.name = DNS_NAME_INITEMPTY,
.nspace = nspace,
.heap = qpdb->heap,
.references = ISC_REFCOUNT_INITIALIZER(1),
+ .qpdb = qpdb,
.locknum = qpzone_get_locknum(),
};
}
static void
-resigndelete(qpzonedb_t *qpdb, qpz_version_t *version,
+resigndelete(qpzonedb_t *qpdb ISC_ATTR_UNUSED, qpz_version_t *version,
dns_slabheader_t *header DNS__DB_FLARG) {
if (header == NULL || header->heap_index == 0) {
return;
static qpz_changed_t *
add_changed(dns_slabheader_t *header, qpz_version_t *version DNS__DB_FLARG) {
qpz_changed_t *changed = NULL;
- qpzonedb_t *qpdb = (qpzonedb_t *)header->db;
- qpznode_t *node = (qpznode_t *)header->node;
+ qpznode_t *node = HEADERNODE(header);
+ qpzonedb_t *qpdb = node->qpdb;
changed = isc_mem_get(qpdb->common.mctx, sizeof(*changed));
}
loading_addnode(loadctx, name, rdataset->type, rdataset->covers, &node);
- result = dns_rdataslab_fromrdataset(rdataset, qpdb->common.mctx,
- ®ion, qpdb->maxrrperset);
+ result = dns_rdataslab_fromrdataset(rdataset, node->mctx, ®ion,
+ qpdb->maxrrperset);
if (result != ISC_R_SUCCESS) {
if (result == DNS_R_TOOMANYRECORDS) {
dns__db_logtoomanyrecords((dns_db_t *)qpdb, name,
}
static void
-qpzone_attachnode(dns_db_t *db, dns_dbnode_t *source,
- dns_dbnode_t **targetp DNS__DB_FLARG) {
- qpzonedb_t *qpdb = (qpzonedb_t *)db;
+qpzone_attachnode(dns_dbnode_t *source, dns_dbnode_t **targetp DNS__DB_FLARG) {
qpznode_t *node = (qpznode_t *)source;
+ qpzonedb_t *qpdb = node->qpdb;
REQUIRE(VALID_QPZONE(qpdb));
REQUIRE(targetp != NULL && *targetp == NULL);
}
static void
-qpzone_detachnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
- qpzonedb_t *qpdb = (qpzonedb_t *)db;
+qpzone_detachnode(dns_dbnode_t **nodep DNS__DB_FLARG) {
qpznode_t *node = NULL;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
isc_rwlock_t *nlock = NULL;
+ qpzonedb_t *qpdb;
- REQUIRE(VALID_QPZONE(qpdb));
REQUIRE(nodep != NULL && *nodep != NULL);
node = (qpznode_t *)(*nodep);
+ qpdb = node->qpdb;
+
+ REQUIRE(VALID_QPZONE(qpdb));
*nodep = NULL;
nlock = qpzone_get_lock(node);
}
static void
-locknode(dns_db_t *db ISC_ATTR_UNUSED, dns_dbnode_t *dbnode,
- isc_rwlocktype_t type) {
+locknode(dns_dbnode_t *dbnode, isc_rwlocktype_t type) {
qpznode_t *node = (qpznode_t *)dbnode;
RWLOCK(qpzone_get_lock(node), type);
}
static void
-unlocknode(dns_db_t *db ISC_ATTR_UNUSED, dns_dbnode_t *dbnode,
- isc_rwlocktype_t type) {
+unlocknode(dns_dbnode_t *dbnode, isc_rwlocktype_t type) {
qpznode_t *node = (qpznode_t *)dbnode;
RWUNLOCK(qpzone_get_lock(node), type);
}
static void
-deletedata(dns_db_t *db ISC_ATTR_UNUSED, dns_dbnode_t *node ISC_ATTR_UNUSED,
- void *data) {
+deletedata(dns_dbnode_t *node ISC_ATTR_UNUSED, void *data) {
dns_slabheader_t *header = data;
if (header->heap_index != 0) {
closeversion(qrditer->common.db, &qrditer->common.version,
false DNS__DB_FLARG_PASS);
}
- dns__db_detachnode(qrditer->common.db,
- &qrditer->common.node DNS__DB_FLARG_PASS);
+ dns__db_detachnode(&qrditer->common.node DNS__DB_FLARG_PASS);
isc_mem_put(qrditer->common.db->mctx, qrditer, sizeof(*qrditer));
*iteratorp = NULL;
rdataset->type != dns_rdatatype_nsec3 &&
rdataset->covers != dns_rdatatype_nsec3));
- result = dns_rdataslab_fromrdataset(rdataset, qpdb->common.mctx,
- ®ion, qpdb->maxrrperset);
+ result = dns_rdataslab_fromrdataset(rdataset, node->mctx, ®ion,
+ qpdb->maxrrperset);
if (result != ISC_R_SUCCESS) {
if (result == DNS_R_TOOMANYRECORDS) {
dns__db_logtoomanyrecords((dns_db_t *)qpdb, &node->name,
rdataset->covers != dns_rdatatype_nsec3));
dns_name_copy(&node->name, nodename);
- result = dns_rdataslab_fromrdataset(rdataset, qpdb->common.mctx,
- ®ion, 0);
+ result = dns_rdataslab_fromrdataset(rdataset, node->mctx, ®ion, 0);
if (result != ISC_R_SUCCESS) {
return result;
}
}
static isc_result_t
-nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name) {
- qpzonedb_t *qpdb = (qpzonedb_t *)db;
+nodefullname(dns_dbnode_t *node, dns_name_t *name) {
qpznode_t *qpnode = (qpznode_t *)node;
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
isc_rwlock_t *nlock = NULL;
- REQUIRE(VALID_QPZONE(qpdb));
REQUIRE(node != NULL);
REQUIRE(name != NULL);
}
if (node_a != NULL) {
- dns__db_detachnode(ctx->db,
- (dns_dbnode_t **)&node_a DNS__DB_FLARG_PASS);
+ dns__db_detachnode((dns_dbnode_t **)&node_a DNS__DB_FLARG_PASS);
}
if (node_aaaa != NULL) {
dns__db_detachnode(
- ctx->db,
(dns_dbnode_t **)&node_aaaa DNS__DB_FLARG_PASS);
}
.closeversion = closeversion,
.findnode = qpzone_findnode,
.find = qpzone_find,
- .attachnode = qpzone_attachnode,
- .detachnode = qpzone_detachnode,
.createiterator = qpzone_createiterator,
.findrdataset = qpzone_findrdataset,
.allrdatasets = qpzone_allrdatasets,
.getsigningtime = getsigningtime,
.getsize = getsize,
.setgluecachestats = setgluecachestats,
- .locknode = locknode,
- .unlocknode = unlocknode,
.addglue = addglue,
- .deletedata = deletedata,
- .nodefullname = nodefullname,
.setmaxrrperset = setmaxrrperset,
.setmaxtypepername = setmaxtypepername,
};
+static dns_dbnode_methods_t qpznode_methods = (dns_dbnode_methods_t){
+ .nodefullname = nodefullname,
+ .attachnode = qpzone_attachnode,
+ .detachnode = qpzone_detachnode,
+ .locknode = locknode,
+ .unlocknode = unlocknode,
+ .deletedata = deletedata,
+};
+
static void
destroy_qpznode(qpznode_t *node) {
dns_slabheader_t *current = NULL, *next = NULL;
ISC_LINK_INIT(h, link);
h->heap_index = 0;
h->heap = NULL;
- h->db = db;
h->node = node;
h->visited = false;
*headerp = NULL;
- isc_mem_t *mctx = header->db->mctx;
-
- dns_db_deletedata(header->db, header->node, header);
+ isc_mem_t *mctx = header->node->mctx;
+ dns_db_deletedata(header->node, header);
if (NONEXISTENT(header)) {
size = sizeof(*header);
static void
rdataset_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) {
- dns_db_t *db = rdataset->slab.db;
dns_dbnode_t *node = rdataset->slab.node;
- dns__db_detachnode(db, &node DNS__DB_FLARG_PASS);
+ dns__db_detachnode(&node DNS__DB_FLARG_PASS);
}
static isc_result_t
static void
rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG) {
- dns_db_t *db = source->slab.db;
dns_dbnode_t *node = source->slab.node;
dns_dbnode_t *cloned_node = NULL;
- dns__db_attachnode(db, node, &cloned_node DNS__DB_FLARG_PASS);
+ dns__db_attachnode(node, &cloned_node DNS__DB_FLARG_PASS);
INSIST(!ISC_LINK_LINKED(target, link));
*target = *source;
ISC_LINK_INIT(target, link);
* getownercase methods from affecting the case of NSEC/NSEC3
* owner names.
*/
- dns__db_attachnode(db, node,
- &(dns_dbnode_t *){ NULL } DNS__DB_FLARG_PASS);
+ dns__db_attachnode(node, &(dns_dbnode_t *){ NULL } DNS__DB_FLARG_PASS);
*nsec = (dns_rdataset_t){
.methods = &dns_rdataslab_rdatasetmethods,
.rdclass = db->rdclass,
};
nsec->attributes.keepcase = true;
- dns__db_attachnode(db, node,
- &(dns_dbnode_t *){ NULL } DNS__DB_FLARG_PASS);
+ dns__db_attachnode(node, &(dns_dbnode_t *){ NULL } DNS__DB_FLARG_PASS);
*nsecsig = (dns_rdataset_t){
.methods = &dns_rdataslab_rdatasetmethods,
.rdclass = db->rdclass,
* following an dns_slabheader, but in this case it points to a bare
* rdataslab belonging to the dns_slabheader's `closest` field.
*/
- dns__db_attachnode(db, node,
- &(dns_dbnode_t *){ NULL } DNS__DB_FLARG_PASS);
+ dns__db_attachnode(node, &(dns_dbnode_t *){ NULL } DNS__DB_FLARG_PASS);
*nsec = (dns_rdataset_t){
.methods = &dns_rdataslab_rdatasetmethods,
.rdclass = db->rdclass,
};
nsec->attributes.keepcase = true;
- dns__db_attachnode(db, node,
- &(dns_dbnode_t *){ NULL } DNS__DB_FLARG_PASS);
+ dns__db_attachnode(node, &(dns_dbnode_t *){ NULL } DNS__DB_FLARG_PASS);
*nsecsig = (dns_rdataset_t){
.methods = &dns_rdataslab_rdatasetmethods,
.rdclass = db->rdclass,
rdataset_settrust(dns_rdataset_t *rdataset, dns_trust_t trust) {
dns_slabheader_t *header = dns_rdataset_getheader(rdataset);
- dns_db_locknode(header->db, header->node, isc_rwlocktype_write);
+ dns_db_locknode(header->node, isc_rwlocktype_write);
header->trust = rdataset->trust = trust;
- dns_db_unlocknode(header->db, header->node, isc_rwlocktype_write);
+ dns_db_unlocknode(header->node, isc_rwlocktype_write);
}
static void
rdataset_expire(dns_rdataset_t *rdataset DNS__DB_FLARG) {
dns_slabheader_t *header = dns_rdataset_getheader(rdataset);
- dns_db_expiredata(header->db, header->node, header);
+ dns_db_expiredata(header->node, header);
}
static void
rdataset_clearprefetch(dns_rdataset_t *rdataset) {
dns_slabheader_t *header = dns_rdataset_getheader(rdataset);
- dns_db_locknode(header->db, header->node, isc_rwlocktype_write);
+ dns_db_locknode(header->node, isc_rwlocktype_write);
DNS_SLABHEADER_CLRATTR(header, DNS_SLABHEADERATTR_PREFETCH);
- dns_db_unlocknode(header->db, header->node, isc_rwlocktype_write);
+ dns_db_unlocknode(header->node, isc_rwlocktype_write);
}
static void
DNS_SLABHEADER_CLRATTR(header, DNS_SLABHEADERATTR_CASEFULLYLOWER);
- dns_db_locknode(header->db, header->node, isc_rwlocktype_write);
+ dns_db_locknode(header->node, isc_rwlocktype_write);
dns_slabheader_setownercase(header, name);
- dns_db_unlocknode(header->db, header->node, isc_rwlocktype_write);
+ dns_db_unlocknode(header->node, isc_rwlocktype_write);
}
static void
return;
}
- dns_db_locknode(header->db, header->node, isc_rwlocktype_read);
+ dns_db_locknode(header->node, isc_rwlocktype_read);
if (CASESET(header)) {
uint8_t *nd = name->ndata;
for (size_t i = 0; i < name->length; i++) {
: isc_ascii_tolower(nd[i]);
}
}
- dns_db_unlocknode(header->db, header->node, isc_rwlocktype_read);
+ dns_db_unlocknode(header->node, isc_rwlocktype_read);
}
static dns_slabheader_t *
dns_rdataset_init(&sigrdataset);
if (resp->node != NULL) {
- dns_db_attachnode(resp->db, resp->node, &node);
- dns_db_detachnode(resp->db, &resp->node);
+ dns_db_attachnode(resp->node, &node);
+ dns_db_detachnode(&resp->node);
}
if (resp->db != NULL) {
dns_db_attach(resp->db, &db);
dns_db_attach(db, &resp->db);
}
if (node != NULL) {
- dns_db_attachnode(db, node,
- &resp->node);
+ dns_db_attachnode(node, &resp->node);
}
dns_name_copy(fname, resp->foundname);
clone_results(fctx);
dns_db_attach(db, &resp->db);
}
if (node != NULL) {
- dns_db_attachnode(db, node,
- &resp->node);
+ dns_db_attachnode(node, &resp->node);
}
dns_name_copy(fname, resp->foundname);
if (result == DNS_R_CNAME &&
cleanup:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (db != NULL) {
dns_db_detach(&db);
resp->result = hresp->result;
dns_name_copy(hresp->foundname, resp->foundname);
dns_db_attach(hresp->db, &resp->db);
- dns_db_attachnode(hresp->db, hresp->node, &resp->node);
+ dns_db_attachnode(hresp->node, &resp->node);
INSIST(hresp->rdataset != NULL && resp->rdataset != NULL);
if (dns_rdataset_isassociated(hresp->rdataset)) {
* detach it before returning.
*/
if (nodep != NULL && *nodep != NULL) {
- dns_db_attachnode(fctx->cache, *nodep, &node);
+ dns_db_attachnode(*nodep, &node);
} else {
result = dns_db_findnode(fctx->cache, name, true, &node);
}
if (nodep != NULL && *nodep == NULL) {
*nodep = node;
} else if (node != NULL) {
- dns_db_detachnode(fctx->cache, &node);
+ dns_db_detachnode(&node);
}
return result;
}
if (node != NULL) {
- dns_db_detachnode(fctx->cache, &node);
+ dns_db_detachnode(&node);
}
}
cleanup_unlocked:
if (node != NULL) {
- dns_db_detachnode(fctx->cache, &node);
+ dns_db_detachnode(&node);
}
if (nextval != NULL) {
cleanup:
if (node != NULL) {
- dns_db_detachnode(fctx->cache, &node);
+ dns_db_detachnode(&node);
}
return result;
UNLOCK(&fctx->lock);
if (node != NULL) {
- dns_db_detachnode(fctx->cache, &node);
+ dns_db_detachnode(&node);
}
done:
FCTXTRACE("resume_dslookup");
if (resp->node != NULL) {
- dns_db_detachnode(resp->db, &resp->node);
+ dns_db_detachnode(&resp->node);
}
if (resp->db != NULL) {
dns_db_detach(&resp->db);
}
if (resp->node != NULL) {
- dns_db_detachnode(resp->db, &resp->node);
+ dns_db_detachnode(&resp->node);
}
if (resp->db != NULL) {
dns_db_detach(&resp->db);
goto cleanup;
}
dns_rdatasetiter_destroy(&rdsiter);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
cleanup:
dns_rdatasetiter_destroy(&rdsiter);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (dbiter != NULL) {
dns_dbiterator_destroy(&dbiter);
"rpz: %s: failed to fetch "
"rrdatasets - %s",
domain, isc_result_totext(result));
- dns_db_detachnode(rpz->updb, &node);
+ dns_db_detachnode(&node);
goto cleanup;
}
result = dns_rdatasetiter_first(rdsiter);
dns_rdatasetiter_destroy(&rdsiter);
- dns_db_detachnode(rpz->updb, &node);
+ dns_db_detachnode(&node);
if (result != ISC_R_SUCCESS) { /* skip empty non-terminal */
if (result != ISC_R_NOMORE) {
dns_rdatasetiter_destroy(&it->rdatasetit);
}
if (it->node != NULL) {
- dns_db_detachnode(it->db, &it->node);
+ dns_db_detachnode(&it->node);
}
it->result = dns_dbiterator_first(it->dbit);
* This node is empty. Try next node.
*/
dns_rdatasetiter_destroy(&it->rdatasetit);
- dns_db_detachnode(it->db, &it->node);
+ dns_db_detachnode(&it->node);
it->result = dns_dbiterator_next(it->dbit);
continue;
}
*/
while (it->result == ISC_R_NOMORE) {
dns_rdatasetiter_destroy(&it->rdatasetit);
- dns_db_detachnode(it->db, &it->node);
+ dns_db_detachnode(&it->node);
it->result = dns_dbiterator_next(it->dbit);
if (it->result == ISC_R_NOMORE) {
/* We are at the end of the entire database. */
dns_rdatasetiter_destroy(&it->rdatasetit);
}
if (it->node != NULL) {
- dns_db_detachnode(it->db, &it->node);
+ dns_db_detachnode(&it->node);
}
dns_dbiterator_destroy(&it->dbit);
}
struct dns_sdlzlookup {
/* Unlocked */
- unsigned int magic;
+ DBNODE_FIELDS;
+
dns_sdlz_db_t *sdlz;
ISC_LIST(dns_rdatalist_t) lists;
ISC_LIST(isc_buffer_t) buffers;
- dns_name_t name;
ISC_LINK(dns_sdlzlookup_t) link;
dns_rdatacallbacks_t callbacks;
list_tordataset(dns_rdatalist_t *rdatalist, dns_db_t *db, dns_dbnode_t *node,
dns_rdataset_t *rdataset);
+/*
+ * Node methods forward declarations
+ */
static void
-detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG);
+sdlznode_attachnode(dns_dbnode_t *source, dns_dbnode_t **targetp DNS__DB_FLARG);
+static void
+sdlznode_detachnode(dns_dbnode_t **targetp DNS__DB_FLARG);
+
+static dns_dbnode_methods_t sdlznode_methods = (dns_dbnode_methods_t){
+ .attachnode = sdlznode_attachnode,
+ .detachnode = sdlznode_detachnode,
+};
static void
dbiterator_destroy(dns_dbiterator_t **iteratorp DNS__DB_FLARG);
rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) {
sdlz_rdatasetiter_t *sdlziterator = (sdlz_rdatasetiter_t *)(*iteratorp);
- detachnode(sdlziterator->common.db,
- &sdlziterator->common.node DNS__DB_FLARG_PASS);
+ sdlznode_detachnode(&sdlziterator->common.node DNS__DB_FLARG_PASS);
isc_mem_put(sdlziterator->common.db->mctx, sdlziterator,
sizeof(sdlz_rdatasetiter_t));
*iteratorp = NULL;
node = isc_mem_get(sdlz->common.mctx, sizeof(dns_sdlznode_t));
+ node->methods = &sdlznode_methods;
node->sdlz = NULL;
dns_db_attach((dns_db_t *)sdlz, (dns_db_t **)&node->sdlz);
ISC_LIST_INIT(node->lists);
}
static void
-attachnode(dns_db_t *db, dns_dbnode_t *source,
- dns_dbnode_t **targetp DNS__DB_FLARG) {
- dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)db;
+sdlznode_attachnode(dns_dbnode_t *source,
+ dns_dbnode_t **targetp DNS__DB_FLARG) {
dns_sdlznode_t *node = (dns_sdlznode_t *)source;
uint_fast32_t refs;
- REQUIRE(VALID_SDLZDB(sdlz));
-
- UNUSED(sdlz);
-
refs = isc_refcount_increment(&node->references);
#if DNS_DB_NODETRACE
fprintf(stderr, "incr:node:%s:%s:%u:%p->references = %" PRIuFAST32 "\n",
}
static void
-detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) {
- dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)db;
+sdlznode_detachnode(dns_dbnode_t **targetp DNS__DB_FLARG) {
dns_sdlznode_t *node;
uint_fast32_t refs;
- REQUIRE(VALID_SDLZDB(sdlz));
REQUIRE(targetp != NULL && *targetp != NULL);
- UNUSED(sdlz);
-
node = (dns_sdlznode_t *)(*targetp);
*targetp = NULL;
* and try again.
*/
if (i < nlabels) {
- detachnode(db, &node DNS__DB_FLARG_PASS);
+ sdlznode_detachnode(&node DNS__DB_FLARG_PASS);
node = NULL;
continue;
}
if (nodep != NULL) {
*nodep = node;
} else if (node != NULL) {
- detachnode(db, &node DNS__DB_FLARG_PASS);
+ sdlznode_detachnode(&node DNS__DB_FLARG_PASS);
}
return result;
iterator->common.methods = &rdatasetiter_methods;
iterator->common.db = db;
iterator->common.node = NULL;
- attachnode(db, node, &iterator->common.node DNS__DB_FLARG_PASS);
+ sdlznode_attachnode((dns_dbnode_t *)node,
+ &iterator->common.node DNS__DB_FLARG_PASS);
iterator->common.version = version;
iterator->common.options = options;
iterator->common.now = now;
.closeversion = closeversion,
.findnode = findnode,
.find = find,
- .attachnode = attachnode,
- .detachnode = detachnode,
.createiterator = createiterator,
.findrdataset = findrdataset,
.allrdatasets = allrdatasets,
dns_name_t *name DNS__DB_FLARG) {
sdlz_dbiterator_t *sdlziter = (sdlz_dbiterator_t *)iterator;
- attachnode(iterator->db, (dns_dbnode_t *)sdlziter->current,
- nodep DNS__DB_FLARG_PASS);
+ sdlznode_attachnode((dns_dbnode_t *)sdlziter->current,
+ nodep DNS__DB_FLARG_PASS);
if (name != NULL) {
dns_name_copy(&sdlziter->current->name, name);
return ISC_R_SUCCESS;
static void
disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) {
dns_dbnode_t *node = rdataset->rdlist.node;
- dns_sdlznode_t *sdlznode = (dns_sdlznode_t *)node;
- dns_db_t *db = (dns_db_t *)sdlznode->sdlz;
-
- detachnode(db, &node DNS__DB_FLARG_PASS);
+ sdlznode_detachnode(&node DNS__DB_FLARG_PASS);
dns_rdatalist_disassociate(rdataset DNS__DB_FLARG_PASS);
}
static void
rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG) {
dns_dbnode_t *node = source->rdlist.node;
- dns_sdlznode_t *sdlznode = (dns_sdlznode_t *)node;
- dns_db_t *db = (dns_db_t *)sdlznode->sdlz;
dns_rdatalist_clone(source, target DNS__DB_FLARG_PASS);
- attachnode(db, node, &target->rdlist.node DNS__DB_FLARG_PASS);
+ sdlznode_attachnode(node, &target->rdlist.node DNS__DB_FLARG_PASS);
}
static dns_rdatasetmethods_t rdataset_methods = {
};
static void
-list_tordataset(dns_rdatalist_t *rdatalist, dns_db_t *db, dns_dbnode_t *node,
- dns_rdataset_t *rdataset) {
+list_tordataset(dns_rdatalist_t *rdatalist, dns_db_t *db ISC_ATTR_UNUSED,
+ dns_dbnode_t *node, dns_rdataset_t *rdataset) {
/*
* The sdlz rdataset is an rdatalist, but additionally holds
* a database node reference.
dns_rdatalist_tordataset(rdatalist, rdataset);
rdataset->methods = &rdataset_methods;
- dns_db_attachnode(db, node, &rdataset->rdlist.node);
+ dns_db_attachnode(node, &rdataset->rdlist.node);
}
/*
dns_rdatasetiter_destroy(&iter);
cleanup_node:
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
cleanup_rdataset:
dns_rdataset_disassociate(&rdataset);
cleanup_node:
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
{
dns_dbnode_t *node = NULL;
CHECK(dns_dbiterator_current(dbit, &node, child));
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (!dns_name_issubdomain(child, name)) {
break;
}
}
}
CHECK(dns_dbiterator_current(dbit, &node, newname));
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
/*
* The iterator may hold the tree lock, and
CHECK(dns_db_findnode(db, name, false, &node));
dns_rdata_init(&rdata);
CHECK(dns_nsec_buildrdata(db, ver, node, target, buffer, &rdata));
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
/*
* Delete the old NSEC and record the change.
failure:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
}
CHECK(dns_db_findrdataset(db, node, ver, type, 0, (isc_stdtime_t)0,
&rdataset, NULL));
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
#define REVOKE(x) ((dst_key_flags(x) & DNS_KEYFLAG_REVOKE) != 0)
#define KSK(x) ((dst_key_flags(x) & DNS_KEYFLAG_KSK) != 0)
dns_rdataset_disassociate(&rdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
result = dns_db_findrdataset(db, node, ver, dns_rdatatype_rrsig,
dns_rdatatype_dnskey, (isc_stdtime_t)0,
&rdataset, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result == ISC_R_NOTFOUND) {
return ISC_R_SUCCESS;
failure:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
dns_rdatasetiter_destroy(&iter);
cleanup_node:
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
CHECK(dns_rdata_tostruct(&rdata, &soa, NULL));
state->nsecttl = ISC_MIN(rdataset.ttl, soa.minimum);
dns_rdataset_disassociate(&rdataset);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
/*
* Find all RRsets directly affected by the update, and
failure:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
dns_diff_clear(&state->sig_diff);
/* Free resources which are not of interest. */
if (resp->node != NULL) {
- dns_db_detachnode(resp->db, &resp->node);
+ dns_db_detachnode(&resp->node);
}
if (resp->db != NULL) {
dns_db_detach(&resp->db);
/* Free resources which are not of interest. */
if (resp->node != NULL) {
- dns_db_detachnode(resp->db, &resp->node);
+ dns_db_detachnode(&resp->node);
}
if (resp->db != NULL) {
dns_db_detach(&resp->db);
dns_rdataset_disassociate(sigrdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (!is_cache) {
dns_db_detach(&db);
dns_db_detach(&db);
}
dns_db_attach(zdb, &db);
- dns_db_attachnode(db, znode, &node);
+ dns_db_attachnode(znode, &node);
goto cleanup;
}
}
}
if (db != NULL) {
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
dns_db_detach(&db);
}
* Cleanup if non-standard hints are used.
*/
if (db == NULL && node != NULL) {
- dns_db_detachnode(view->hints, &node);
+ dns_db_detachnode(&node);
}
}
if (zdb != NULL) {
if (znode != NULL) {
- dns_db_detachnode(zdb, &znode);
+ dns_db_detachnode(&znode);
}
dns_db_detach(&zdb);
}
if (nodep != NULL) {
*nodep = node;
} else {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
}
if (dbp != NULL) {
dns_rdataset_disassociate(&rdataset);
}
dns_rdatasetiter_destroy(&rdsit);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
dns_dbiterator_destroy(&dbiterator);
}
next:
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (has_a) {
cleanup:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
dns_dbiterator_destroy(&dbiterator);
cleanup:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (version != NULL) {
dns_db_closeversion(db, &version, false);
cleanup:
if (db != NULL) {
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (version != NULL) {
dns_db_closeversion(db, &version, false);
cleanup:
if (db != NULL) {
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (version != NULL) {
dns_db_closeversion(db, &version, false);
dns_rdataset_disassociate(&rdataset);
}
dns_db_closeversion(db, &version, false);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
result = dns_db_findrdataset(db, node, version, dns_rdatatype_txt,
dns_rdatatype_none, 0, &rdataset, NULL);
dns_db_closeversion(db, &version, false);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result == ISC_R_SUCCESS) {
dns_rdataset_disassociate(&rdataset);
}
}
}
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
closeversion:
dns_db_closeversion(db, &version, false);
failure:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
dns_rdataset_disassociate(&keyset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
ISC_LIST_FOREACH (dnskeys, key, link) {
ISC_LIST_UNLINK(dnskeys, key, link);
}
result = dns_db_findrdataset(db, node, ver, dns_rdatatype_rrsig, type,
(isc_stdtime_t)0, &rdataset, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result == ISC_R_NOTFOUND) {
INSIST(!dns_rdataset_isassociated(&rdataset));
}
failure:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
}
result = dns_db_findrdataset(db, node, ver, type, 0, (isc_stdtime_t)0,
&rdataset, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result == ISC_R_NOTFOUND) {
INSIST(!dns_rdataset_isassociated(&rdataset));
return ISC_R_SUCCESS;
dns_rdataset_disassociate(&rdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
if (bottom && dns_name_issubdomain(newname, oldname) &&
!dns_name_equal(newname, oldname))
{
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
continue;
}
/*
*/
CHECK(dns_db_allrdatasets(db, node, version, 0, 0, &rdsit));
result = dns_rdatasetiter_first(rdsit);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
dns_rdatasetiter_destroy(&rdsit);
if (result != ISC_R_NOMORE) {
break;
} while (1);
failure:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (dbit != NULL) {
dns_dbiterator_destroy(&dbit);
result = ISC_R_SUCCESS;
failure:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
dns_rdataset_disassociate(&rdataset);
}
if (node != NULL) {
- dns_db_detachnode(signing->db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
CHECK(update_one_rr(db, ver, diff, DNS_DIFFOP_ADD, name, ttl, &rdata));
failure:
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (dns_rdataset_isassociated(&rdataset)) {
dns_rdataset_disassociate(&rdataset);
}
&rdataset, NULL);
if (result == ISC_R_SUCCESS) {
dns_rdataset_disassociate(&rdataset);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
if (result != ISC_R_NOTFOUND) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
0, &rdataset, NULL);
if (result == ISC_R_NOTFOUND) {
*answer = true;
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return ISC_R_SUCCESS;
}
if (result != ISC_R_SUCCESS) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
if (dns_rdataset_isassociated(&rdataset)) {
dns_rdataset_disassociate(&rdataset);
}
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
*/
next_addnode:
first = false;
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
do {
result = dns_dbiterator_next(nsec3chain->dbiterator);
} else if (delegation) {
dns_dbiterator_current(nsec3chain->dbiterator,
&node, nextname);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (!dns_name_issubdomain(nextname, name)) {
break;
}
next_removenode:
first = false;
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
do {
result = dns_dbiterator_next(nsec3chain->dbiterator);
if (result == ISC_R_NOMORE && buildnsecchain) {
} else if (delegation) {
dns_dbiterator_current(nsec3chain->dbiterator,
&node, nextname);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (!dns_name_issubdomain(nextname, name)) {
break;
}
dns_rdataset_disassociate(&rdataset);
}
dns_rdatasetiter_destroy(&iterator);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (rebuild_nsec) {
if (nsec3chain != NULL) {
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (version != NULL) {
dns_db_closeversion(db, &version, false);
*/
next_node:
first = false;
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
do {
result = dns_dbiterator_next(signing->dbiterator);
if (result == ISC_R_NOMORE) {
} else if (is_bottom_of_zone) {
dns_dbiterator_current(signing->dbiterator,
&node, nextname);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (!dns_name_issubdomain(nextname, name)) {
break;
}
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (version != NULL) {
/* Free resources which are not of interest */
if (resp->node != NULL) {
- dns_db_detachnode(resp->db, &resp->node);
+ dns_db_detachnode(&resp->node);
}
if (resp->db != NULL) {
dns_db_detach(&resp->db);
dns_name_free(&primary, zone->mctx);
}
cleanup2:
- dns_db_detachnode(zonedb, &node);
+ dns_db_detachnode(&node);
cleanup1:
dns_db_closeversion(zonedb, &version, false);
dns_db_detach(&zonedb);
"dns_db_addrdataset() failed: %s",
isc_result_totext(result));
}
- dns_db_detachnode(stub->db, &node);
+ dns_db_detachnode(&node);
cleanup:
if (msg != NULL) {
goto done;
}
result = dns_db_addrdataset(db, node, version, 0, nsrdataset, 0, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result != ISC_R_SUCCESS) {
goto done;
}
}
result = dns_db_addrdataset(db, node, version, 0,
rdataset, 0, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result != ISC_R_SUCCESS) {
goto done;
}
}
result = dns_db_addrdataset(db, node, version, 0,
rdataset, 0, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result != ISC_R_SUCCESS) {
goto done;
}
result = dns_db_addrdataset(stub->db, node, stub->version, 0,
soardataset, 0, NULL);
- dns_db_detachnode(stub->db, &node);
+ dns_db_detachnode(&node);
if (result != ISC_R_SUCCESS) {
dns_zone_log(zone, ISC_LOG_INFO,
"refreshing stub: "
soa_cleanup:
if (node != NULL) {
- dns_db_detachnode(zonedb, &node);
+ dns_db_detachnode(&node);
}
if (version != NULL) {
dns_db_closeversion(zonedb, &version, false);
if (dns_rdataset_isassociated(&rdataset)) {
dns_rdataset_disassociate(&rdataset);
}
- dns_db_detachnode(secdb, &node);
+ dns_db_detachnode(&node);
}
ISC_LIST_FOREACH (diff->tuples, tuple, link) {
failure:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (version != NULL) {
dns_db_closeversion(db, &version, false);
dns_rdatasetiter_destroy(&rdsit);
}
if (rawnode) {
- dns_db_detachnode(rawdb, &rawnode);
+ dns_db_detachnode(&rawnode);
}
if (node) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
failure:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
failure:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
/* Free resources which are not of interest */
if (resp->node != NULL) {
- dns_db_detachnode(resp->db, &resp->node);
+ dns_db_detachnode(&resp->node);
}
if (resp->db != NULL) {
dns_db_detach(&resp->db);
dns_rdataset_disassociate(&cdnskeyset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (db != NULL) {
dns_db_detach(&db);
return result;
}
result = zone_count_ns_rr(zone, db, node, version, NULL, errors, false);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
if (dns_rdataset_isassociated(&cdnskey)) {
dns_rdataset_disassociate(&cdnskey);
}
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
}
if (db != NULL) {
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (oldver != NULL) {
dns_db_closeversion(db, &oldver, false);
dns_rdataset_disassociate(&nrdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (oldver != NULL) {
dns_db_closeversion(db, &oldver, false);
dns_rdataset_disassociate(&rdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (version != NULL) {
dns_db_closeversion(db, &version, false);
dns_rdataset_disassociate(&rdataset);
}
if (node != NULL) {
- dns_db_detachnode(vctx->db, &node);
+ dns_db_detachnode(&node);
}
return result;
dns_rdataset_disassociate(&rdataset);
}
if (node != NULL) {
- dns_db_detachnode(vctx->db, &node);
+ dns_db_detachnode(&node);
}
return result;
result = ISC_R_SUCCESS;
done:
- dns_db_detachnode(vctx->db, &node);
+ dns_db_detachnode(&node);
return result;
}
if (!dns_name_issubdomain(name, vctx->origin)) {
result = check_no_nsec(vctx, name, node);
if (result != ISC_R_SUCCESS) {
- dns_db_detachnode(vctx->db, &node);
+ dns_db_detachnode(&node);
goto done;
}
- dns_db_detachnode(vctx->db, &node);
+ dns_db_detachnode(&node);
result = dns_dbiterator_next(dbiter);
if (result == ISC_R_NOMORE) {
done = true;
"dns_dbiterator_current():"
" %s",
isc_result_totext(result));
- dns_db_detachnode(vctx->db, &node);
+ dns_db_detachnode(&node);
goto done;
}
if (!dns_name_issubdomain(nextname, vctx->origin) ||
result = check_no_nsec(vctx, nextname,
nextnode);
if (result != ISC_R_SUCCESS) {
- dns_db_detachnode(vctx->db, &node);
- dns_db_detachnode(vctx->db, &nextnode);
+ dns_db_detachnode(&node);
+ dns_db_detachnode(&nextnode);
goto done;
}
- dns_db_detachnode(vctx->db, &nextnode);
+ dns_db_detachnode(&nextnode);
result = dns_dbiterator_next(dbiter);
continue;
}
result = is_empty(vctx, nextnode);
- dns_db_detachnode(vctx->db, &nextnode);
+ dns_db_detachnode(&nextnode);
switch (result) {
case ISC_R_SUCCESS:
break;
result = dns_dbiterator_next(dbiter);
continue;
default:
- dns_db_detachnode(vctx->db, &node);
+ dns_db_detachnode(&node);
}
break;
}
"iterating through the database "
"failed: %s",
isc_result_totext(result));
- dns_db_detachnode(vctx->db, &node);
+ dns_db_detachnode(&node);
goto done;
}
result = verifynode(vctx, name, node, isdelegation, dstkeys,
nkeys, &vctx->nsecset, &vctx->nsec3paramset,
nextname, &tvresult);
if (result != ISC_R_SUCCESS) {
- dns_db_detachnode(vctx->db, &node);
+ dns_db_detachnode(&node);
goto done;
}
if (*vresult == ISC_R_UNSET) {
vctx, name, prevname, isdelegation,
&vctx->nsec3paramset, &tvresult);
if (result != ISC_R_SUCCESS) {
- dns_db_detachnode(vctx->db, &node);
+ dns_db_detachnode(&node);
goto done;
}
} else {
if (*vresult == ISC_R_SUCCESS) {
*vresult = tvresult;
}
- dns_db_detachnode(vctx->db, &node);
+ dns_db_detachnode(&node);
}
dns_dbiterator_destroy(&dbiter);
if (result != ISC_R_SUCCESS) {
zoneverify_log_error(vctx, "verifynode: %s",
isc_result_totext(result));
- dns_db_detachnode(vctx->db, &node);
+ dns_db_detachnode(&node);
goto done;
}
result = record_found(vctx, name, node, &vctx->nsec3paramset);
- dns_db_detachnode(vctx->db, &node);
+ dns_db_detachnode(&node);
if (result != ISC_R_SUCCESS) {
goto done;
}
ns_client_putrdataset(client, &client->query.redirect.sigrdataset);
if (client->query.redirect.db != NULL) {
if (client->query.redirect.node != NULL) {
- dns_db_detachnode(client->query.redirect.db,
- &client->query.redirect.node);
+ dns_db_detachnode(&client->query.redirect.node);
}
dns_db_detach(&client->query.redirect.db);
}
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
dns_rdataset_disassociate(sigrdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
dns_db_detach(&db);
ns_client_releasename(client, &fname);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (db != NULL) {
dns_db_detach(&db);
NULL);
(void)dns_db_addrdataset(db, node, NULL, client->inner.now, sigrdataset,
0, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
/*
result = dns_db_findrdataset(
db, node, NULL, dns_rdatatype_dnskey, 0,
client->inner.now, keyrdataset, NULL);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
if (result != ISC_R_SUCCESS) {
return false;
}
dns_resolver_destroyfetch(&fresp->fetch);
}
if (fresp->node != NULL) {
- dns_db_detachnode(fresp->db, &fresp->node);
+ dns_db_detachnode(&fresp->node);
}
if (fresp->db != NULL) {
dns_db_detach(&fresp->db);
qctx.fname, &cm, &ci, qctx.rdataset,
qctx.sigrdataset);
if (qctx.node != NULL) {
- dns_db_detachnode(db, &qctx.node);
+ dns_db_detachnode(&qctx.node);
}
dns_db_detach(&db);
dns_rdataset_t **rdatasetp) {
if (nodep != NULL && *nodep != NULL) {
REQUIRE(dbp != NULL && *dbp != NULL);
- dns_db_detachnode(*dbp, nodep);
+ dns_db_detachnode(nodep);
}
if (dbp != NULL && *dbp != NULL) {
dns_db_detach(dbp);
if (dns_rdataset_isassociated(*rdatasetp)) {
dns_rdataset_disassociate(*rdatasetp);
}
- dns_db_detachnode(*dbp, nodep);
+ dns_db_detachnode(nodep);
if (dns_rdatatype_issig(qtype)) {
result = DNS_R_NXRRSET;
dns_rdataset_disassociate(&rdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return ttl;
}
dns_rdataset_disassociate(&trdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
dns_db_detach(&db);
return ISC_R_NOTFOUND;
}
nxrrset:
if (*nodep != NULL) {
- dns_db_detachnode(*dbp, nodep);
+ dns_db_detachnode(nodep);
}
dns_db_detach(dbp);
- dns_db_attachnode(db, node, nodep);
+ dns_db_attachnode(node, nodep);
dns_db_attach(db, dbp);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
dns_db_detach(&db);
*versionp = dbversion->version;
dns_rdataset_disassociate(&trdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
dns_db_detach(&db);
/*
dns_rdataset_disassociate(&trdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
dns_db_detach(&db);
return ISC_R_NOTFOUND;
}
nxrrset:
if (*nodep != NULL) {
- dns_db_detachnode(*dbp, nodep);
+ dns_db_detachnode(nodep);
}
dns_db_detach(dbp);
- dns_db_attachnode(db, node, nodep);
+ dns_db_attachnode(node, nodep);
dns_db_attach(db, dbp);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
dns_db_detach(&db);
*is_zonep = is_zone;
*versionp = version;
dns_rdataset_disassociate(qctx->sigrdataset);
}
if (qctx->db != NULL && qctx->node != NULL) {
- dns_db_detachnode(qctx->db, &qctx->node);
+ dns_db_detachnode(&qctx->node);
}
if (qctx->client != NULL && qctx->client->query.gluedb != NULL) {
dns_db_detach(&qctx->client->query.gluedb);
ns_client_putrdataset(qctx->client, &qctx->zsigrdataset);
ns_client_putrdataset(qctx->client, &qctx->zrdataset);
ns_client_releasename(qctx->client, &qctx->zfname);
- dns_db_detachnode(qctx->zdb, &qctx->znode);
+ dns_db_detachnode(&qctx->znode);
dns_db_detach(&qctx->zdb);
qctx->zversion = NULL;
}
qctx->qtype = qctx->rpz_st->q.qtype;
if (qctx->fresp->node != NULL) {
- dns_db_detachnode(qctx->fresp->db, &qctx->fresp->node);
+ dns_db_detachnode(&qctx->fresp->node);
}
SAVE(qctx->rpz_st->r.db, qctx->fresp->db);
qctx->rpz_st->r.r_type = qctx->fresp->qtype;
ns_client_putrdataset(qctx->client, &qctx->fresp->rdataset);
ns_client_putrdataset(qctx->client, &qctx->fresp->sigrdataset);
if (qctx->fresp->node != NULL) {
- dns_db_detachnode(qctx->fresp->db, &qctx->fresp->node);
+ dns_db_detachnode(&qctx->fresp->node);
}
if (qctx->fresp->db != NULL) {
dns_db_detach(&qctx->fresp->db);
SAVE(qctx->client->query.dns64_aaaa, qctx->rdataset);
SAVE(qctx->client->query.dns64_sigaaaa, qctx->sigrdataset);
ns_client_releasename(qctx->client, &qctx->fname);
- dns_db_detachnode(qctx->db, &qctx->node);
+ dns_db_detachnode(&qctx->node);
qctx->type = qctx->qtype = dns_rdatatype_a;
qctx->dns64_exclude = qctx->dns64 = true;
&qctx->fname);
}
if (qctx->node != NULL) {
- dns_db_detachnode(qctx->db, &qctx->node);
+ dns_db_detachnode(&qctx->node);
}
if (qctx->db != NULL) {
dns_db_detach(&qctx->db);
}
qctx->version = NULL;
- dns_db_detachnode(qctx->db, &qctx->node);
+ dns_db_detachnode(&qctx->node);
dns_db_detach(&qctx->db);
RESTORE(qctx->db, qctx->zdb);
RESTORE(qctx->node, qctx->znode);
SAVE(qctx->client->query.dns64_aaaa, qctx->rdataset);
SAVE(qctx->client->query.dns64_sigaaaa, qctx->sigrdataset);
ns_client_releasename(qctx->client, &qctx->fname);
- dns_db_detachnode(qctx->db, &qctx->node);
+ dns_db_detachnode(&qctx->node);
qctx->type = qctx->qtype = dns_rdatatype_a;
qctx->dns64 = true;
return query_lookup(qctx);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
soardataset = ns_client_newrdataset(qctx->client);
}
if (db != NULL) {
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
dns_db_detach(&db);
}
ns_client_releasename(qctx->client, &qctx->fname);
}
if (qctx->node != NULL) {
- dns_db_detachnode(qctx->db, &qctx->node);
+ dns_db_detachnode(&qctx->node);
}
ns_client_putrdataset(qctx->client, &qctx->rdataset);
if (qctx->sigrdataset != NULL) {
ns_client_releasename(client, &name);
}
if (node != NULL) {
- dns_db_detachnode(qctx->db, &node);
+ dns_db_detachnode(&node);
}
return eresult;
ns_client_releasename(client, &name);
}
if (node != NULL) {
- dns_db_detachnode(qctx->db, &node);
+ dns_db_detachnode(&node);
}
CTRACE(ISC_LOG_DEBUG(3), "query_addns: done");
}
if (USECACHE(client)) {
ns_client_keepname(client, fname, dbuf);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
SAVE(zdb, db);
SAVE(zfname, fname);
SAVE(zrdataset, rdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
dns_db_detach(&db);
ns_client_releasename(client, &fname);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (db != NULL) {
dns_db_detach(&db);
dns_rdatatype_nsec, options, 0, &node, fname,
&cm, &ci, rdataset, sigrdataset);
if (node != NULL) {
- dns_db_detachnode(qctx->db, &node);
+ dns_db_detachnode(&node);
}
if (!dns_rdataset_isassociated(rdataset)) {
dns_rdatasetiter_destroy(&iter);
cleanup_node:
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
cleanup_rdataset:
dns_rdataset_disassociate(&rdataset);
cleanup_node:
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
if (dns_rdatatype_issig(type)) {
covers = dns_rdata_covers(&t->rdata);
} else if (type == dns_rdatatype_any) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
dns_diff_clear(&trash);
return DNS_R_NXRRSET;
} else {
covers, (isc_stdtime_t)0,
&rdataset, NULL);
if (result != ISC_R_SUCCESS) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
dns_diff_clear(&trash);
return DNS_R_NXRRSET;
}
dns_diff_clear(&u_rrs);
dns_diff_clear(&trash);
dns_rdataset_disassociate(&rdataset);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
return result;
}
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
dns_diff_clear(&trash);
failure:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
return result;
}
failure:
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
if (dns_rdataset_isassociated(&rdataset)) {
dns_rdataset_disassociate(&rdataset);
result = dns_db_getoriginnode(db, &node);
assert_int_equal(result, ISC_R_SUCCESS);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
result = dns_db_getoriginnode(db, &node);
assert_int_equal(result, ISC_R_SUCCESS);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
dns_db_detach(&db);
isc_loopmgr_shutdown();
NULL);
assert_int_equal(result, ISC_R_SUCCESS);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
dns_rdataset_disassociate(&rdataset);
result = dns_db_find(db, example, NULL, dns_rdatatype_a, 0, 0,
assert_in_range(count, 1, 21); /* loop sanity */
assert_int_equal(rdataset.attributes.stale, false);
assert_true(rdataset.ttl > 0);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
dns_rdataset_disassociate(&rdataset);
usleep(100000); /* 100 ms */
assert_int_equal(result, ISC_R_SUCCESS);
assert_int_equal(rdataset.attributes.stale,
true);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
dns_rdataset_disassociate(&rdataset);
usleep(100000); /* 100 ms */
foundname, &rdataset, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
dns_rdataset_disassociate(&rdataset);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
dns_db_closeversion(db, &ver, false);
/* Open new version for writing */
assert_int_equal(result, ISC_R_SUCCESS);
dns_rdataset_disassociate(&rdataset);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
/* This should fail now */
result = dns_db_find(db, name, new, dns_rdatatype_a, 0, 0, &node,
result = dns_db_find(db, name, ver, dns_rdatatype_a, 0, 0, &node,
foundname, &rdataset, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
/* Now we create a node with an empty parent */
result = dns_db_newversion(db, &new);
/* look up the ENT; it should be empty */
dns_test_namefromstring("ent.name.test.test.", &fname);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
result = dns_db_find(db, name, new, dns_rdatatype_a, 0, 0, &node,
foundname, &rdataset, NULL);
assert_int_equal(result, DNS_R_EMPTYNAME);
dns_rdataset_disassociate(&rdataset);
}
if (node != NULL) {
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
dns_db_closeversion(db, &ver, false);
DNS_DBITERATOR_FOREACH (iter) {
result = dns_dbiterator_current(iter, &node, name);
assert_int_equal(result, ISC_R_SUCCESS);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
i++;
}
{
result = dns_dbiterator_current(iter, &node, name);
assert_int_equal(result, ISC_R_SUCCESS);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
i++;
}
while (result == ISC_R_SUCCESS) {
result = dns_dbiterator_current(iter, &node, name);
assert_int_equal(result, ISC_R_SUCCESS);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
result = dns_dbiterator_next(iter);
i++;
}
while (result == ISC_R_SUCCESS) {
result = dns_dbiterator_current(iter, &node, name);
assert_int_equal(result, ISC_R_SUCCESS);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
result = dns_dbiterator_prev(iter);
i++;
}
dns_rdatasetiter_destroy(&iterator);
assert_null(iterator);
- dns_db_detachnode(db1, &node);
+ dns_db_detachnode(&node);
assert_null(node);
}
check_assertion(dns_db_findrdataset(db1, node, v2, dns_rdatatype_soa, 0,
0, &rdataset, NULL));
- dns_db_detachnode(db1, &node);
+ dns_db_detachnode(&node);
assert_null(node);
}
check_assertion(
dns_db_deleterdataset(db1, node, v2, dns_rdatatype_soa, 0));
- dns_db_detachnode(db1, &node);
+ dns_db_detachnode(&node);
assert_null(node);
}
check_assertion(
dns_db_subtractrdataset(db1, node, v2, &rdataset, 0, NULL));
- dns_db_detachnode(db1, &node);
+ dns_db_detachnode(&node);
assert_null(node);
}
check_assertion(
dns_db_addrdataset(db1, node, v2, 0, &rdataset, 0, NULL));
- dns_db_detachnode(db1, &node);
+ dns_db_detachnode(&node);
assert_null(node);
}
assert_int_equal(res, ISC_R_SUCCESS);
dns_db_closeversion(db1, &v1, true); /* commit */
assert_null(v1);
- dns_db_detachnode(db1, &node);
+ dns_db_detachnode(&node);
assert_null(node);
/* db2: Insert the first version ("text 1"), and commit */
assert_int_equal(res, ISC_R_SUCCESS);
dns_db_closeversion(db2, &v2, true); /* commit */
assert_null(v2);
- dns_db_detachnode(db2, &node);
+ dns_db_detachnode(&node);
assert_null(node);
/* Reopen the versions */
assert_int_equal(res, ISC_R_SUCCESS);
dns_db_closeversion(db1, &v1, false); /* rollback */
assert_null(v1);
- dns_db_detachnode(db1, &node);
+ dns_db_detachnode(&node);
assert_null(node);
/* db2: Insert the second version ("text 2"), and commit */
assert_int_equal(res, ISC_R_SUCCESS);
dns_db_closeversion(db2, &v2, true); /* commit */
assert_null(v2);
- dns_db_detachnode(db2, &node);
+ dns_db_detachnode(&node);
assert_null(node);
/* db1: Look it up and check that the first version is found */
dns_db_closeversion(db1, &v1, true);
assert_null(v1);
- dns_db_detachnode(db1, &node);
+ dns_db_detachnode(&node);
assert_null(node);
/* db2: Look it up and check that the second version is found */
dns_db_closeversion(db2, &v2, true);
assert_null(v2);
- dns_db_detachnode(db2, &node);
+ dns_db_detachnode(&node);
assert_null(node);
}
result = dns_db_addrdataset(db, node, NULL, now, &rdataset, 0, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
- dns_db_detachnode(db, &node);
+ dns_db_detachnode(&node);
}
static void
.common.methods = &qpdb_zonemethods,
.common.mctx = isc_g_mctx,
};
- qpznode_t node = { .locknum = 0 };
+ qpznode_t node = { .methods = &qpznode_methods, .locknum = 0 };
dns_slabheader_t header = {
.node = (dns_dbnode_t *)&node,
- .db = (dns_db_t *)qpdb,
};
unsigned char *raw = (unsigned char *)(&header) + sizeof(header);
dns_rdataset_t rdataset = {
.common.methods = &qpdb_zonemethods,
.common.mctx = isc_g_mctx,
};
- qpznode_t node = { .locknum = 0 };
+ qpznode_t node = { .methods = &qpznode_methods, .locknum = 0 };
dns_slabheader_t header = {
.node = (dns_dbnode_t *)&node,
- .db = (dns_db_t *)qpdb,
};
unsigned char *raw = (unsigned char *)(&header) + sizeof(header);
dns_rdataset_t rdataset = {
projects / thirdparty / bind9.git / commitdiff
