upstream/bind9
1
0
Fork 0
mirror of https://github.com/isc-projects/bind9.git synced 2026-06-09 10:32:13 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch '4614-qpdb-excess-memory' into 'main'

Browse source 
reduce memory consumption of QP zone and cache databases

Closes #4614

See merge request isc-projects/bind9!8849
This commit is contained in:
Evan Hunt 2024-03-14 18:06:54 +00:00
commit 120b4a9ef9
10 changed files with 84 additions and 96 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
CHANGES
View file

@ -1,3 +1,6 @@
6362. [bug] Reduce memory consumption of QP-trie based databases
by dynamically allocating the nodenames. [GL #4614]
6361. [bug] Some invalid ISO 8601 durations were accepted
erroneously. [GL #4624]

7
lib/dns/forward.c
View file

@ -75,13 +75,13 @@ new_forwarders(isc_mem_t *mctx, const dns_name_t *name,
forwarders = isc_mem_get(mctx, sizeof(*forwarders));
*forwarders = (dns_forwarders_t){
.fwdpolicy = fwdpolicy,
.name = DNS_NAME_INITEMPTY,
.fwdrs = ISC_LIST_INITIALIZER,
};
isc_mem_attach(mctx, &forwarders->mctx);
isc_refcount_init(&forwarders->references, 1);
forwarders->name = dns_fixedname_initname(&forwarders->fn);
dns_name_copy(name, forwarders->name);
dns_name_dupwithoffsets(name, mctx, &forwarders->name);
return (forwarders);
}
@ -212,6 +212,7 @@ destroy_forwarders(dns_forwarders_t *forwarders) {
}
isc_mem_put(forwarders->mctx, fwd, sizeof(*fwd));
}
dns_name_free(&forwarders->name, forwarders->mctx);
isc_mem_putanddetach(&forwarders->mctx, forwarders,
sizeof(*forwarders));
}
@ -240,7 +241,7 @@ static size_t
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
dns_forwarders_t *fwd = pval;
return (dns_qpkey_fromname(key, fwd->name));
return (dns_qpkey_fromname(key, &fwd->name));
}
static void

3
lib/dns/include/dns/forward.h
View file

@ -42,8 +42,7 @@ struct dns_forwarders {
dns_fwdpolicy_t fwdpolicy;
isc_mem_t *mctx;
isc_refcount_t references;
dns_fixedname_t fn;
dns_name_t *name;
dns_name_t name;
};
void

24
lib/dns/keytable.c
View file

@ -51,8 +51,7 @@ struct dns_keynode {
isc_mem_t *mctx;
isc_refcount_t references;
isc_rwlock_t rwlock;
dns_fixedname_t fn;
dns_name_t *name;
dns_name_t name;
dns_rdatalist_t *dslist;
dns_rdataset_t dsset;
bool managed;
@ -119,6 +118,7 @@ destroy_keynode(dns_keynode_t *knode) {
knode->dslist = NULL;
}
dns_name_free(&knode->name, knode->mctx);
isc_mem_putanddetach(&knode->mctx, knode, sizeof(dns_keynode_t));
}
@ -272,7 +272,7 @@ delete_ds(dns_qp_t *qp, dns_keytable_t *keytable, dns_keynode_t *knode,
/*
* Replace knode with a new instance without the DS.
*/
newnode = new_keynode(knode->name, NULL, keytable, knode->managed,
newnode = new_keynode(&knode->name, NULL, keytable, knode->managed,
knode->initial);
for (rdata = ISC_LIST_HEAD(knode->dslist->rdata); rdata != NULL;
rdata = ISC_LIST_NEXT(rdata, link))
@ -285,7 +285,7 @@ delete_ds(dns_qp_t *qp, dns_keytable_t *keytable, dns_keynode_t *knode,
}
}
result = dns_qp_deletename(qp, knode->name, &pval, NULL);
result = dns_qp_deletename(qp, &knode->name, &pval, NULL);
INSIST(result == ISC_R_SUCCESS);
INSIST(pval == knode);
@ -312,14 +312,14 @@ new_keynode(const dns_name_t *name, dns_rdata_ds_t *ds,
REQUIRE(!initial || managed);
knode = isc_mem_get(keytable->mctx, sizeof(dns_keynode_t));
*knode = (dns_keynode_t){ .magic = KEYNODE_MAGIC };
*knode = (dns_keynode_t){ .name = DNS_NAME_INITEMPTY,
.magic = KEYNODE_MAGIC };
dns_rdataset_init(&knode->dsset);
isc_refcount_init(&knode->references, 1);
isc_rwlock_init(&knode->rwlock);
knode->name = dns_fixedname_initname(&knode->fn);
dns_name_copy(name, knode->name);
dns_name_dupwithoffsets(name, keytable->mctx, &knode->name);
/*
* If a DS was supplied, initialize an rdatalist.
@ -522,7 +522,7 @@ dns_keytable_finddeepestmatch(dns_keytable_t *keytable, const dns_name_t *name,
keynode = pval;
if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) {
dns_name_copy(keynode->name, foundname);
dns_name_copy(&keynode->name, foundname);
result = ISC_R_SUCCESS;
}
@ -551,7 +551,7 @@ dns_keytable_issecuredomain(dns_keytable_t *keytable, const dns_name_t *name,
if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) {
keynode = pval;
if (foundname != NULL) {
dns_name_copy(keynode->name, foundname);
dns_name_copy(&keynode->name, foundname);
}
*wantdnssecp = true;
result = ISC_R_SUCCESS;
@ -618,7 +618,7 @@ keynode_dslist_totext(dns_keynode_t *keynode, isc_buffer_t **text) {
return (ISC_R_SUCCESS);
}
dns_name_format(keynode->name, namebuf, sizeof(namebuf));
dns_name_format(&keynode->name, namebuf, sizeof(namebuf));
for (result = dns_rdataset_first(&dsset); result == ISC_R_SUCCESS;
result = dns_rdataset_next(&dsset))
@ -694,7 +694,7 @@ dns_keytable_forall(dns_keytable_t *keytable,
while (dns_qpiter_next(&iter, NULL, &pval, NULL) == ISC_R_SUCCESS) {
dns_keynode_t *knode = pval;
(*func)(keytable, knode, knode->name, arg);
(*func)(keytable, knode, &knode->name, arg);
}
dns_qpread_destroy(keytable->table, &qpr);
@ -844,7 +844,7 @@ static size_t
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
dns_keynode_t *keynode = pval;
return (dns_qpkey_fromname(key, keynode->name));
return (dns_qpkey_fromname(key, &keynode->name));
}
static void

25
lib/dns/nametree.c
View file

@ -41,8 +41,7 @@ struct dns_nametree {
struct dns_ntnode {
isc_mem_t *mctx;
isc_refcount_t references;
dns_fixedname_t fn;
dns_name_t *name;
dns_name_t name;
bool set;
uint8_t *bits;
};
@ -70,6 +69,7 @@ destroy_ntnode(dns_ntnode_t *node) {
isc_mem_cput(node->mctx, node->bits, node->bits[0],
sizeof(char));
}
dns_name_free(&node->name, node->mctx);
isc_mem_putanddetach(&node->mctx, node, sizeof(dns_ntnode_t));
}
@ -104,20 +104,8 @@ dns_nametree_create(isc_mem_t *mctx, dns_nametree_type_t type, const char *name,
static void
destroy_nametree(dns_nametree_t *nametree) {
/* dns_qpread_t qpr; */
/* dns_qpiter_t iter; */
/* void *pval = NULL; */
nametree->magic = 0;
/* dns_qpmulti_query(nametree->table, &qpr); */
/* dns_qpiter_init(&qpr, &iter); */
/* while (dns_qpiter_next(&iter, &pval, NULL) == ISC_R_SUCCESS) { */
/* dns_ntnode_t *n = pval; */
/* dns_ntnode_detach(&n); */
/* } */
/* dns_qpread_destroy(nametree->table, &qpr); */
dns_qpmulti_destroy(&nametree->table);
isc_mem_putanddetach(&nametree->mctx, nametree, sizeof(*nametree));
@ -132,12 +120,13 @@ ISC_REFCOUNT_IMPL(dns_nametree, destroy_nametree);
static dns_ntnode_t *
newnode(isc_mem_t *mctx, const dns_name_t *name) {
dns_ntnode_t *node = isc_mem_get(mctx, sizeof(*node));
*node = (dns_ntnode_t){ 0 };
*node = (dns_ntnode_t){
.name = DNS_NAME_INITEMPTY,
};
isc_mem_attach(mctx, &node->mctx);
isc_refcount_init(&node->references, 1);
node->name = dns_fixedname_initname(&node->fn);
dns_name_copy(name, node->name);
dns_name_dupwithoffsets(name, mctx, &node->name);
return (node);
}
@ -327,7 +316,7 @@ static size_t
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
dns_ntnode_t *ntnode = pval;
return (dns_qpkey_fromname(key, ntnode->name));
return (dns_qpkey_fromname(key, &ntnode->name));
}
static void

32
lib/dns/nta.c
View file

@ -60,8 +60,7 @@ struct dns__nta {
dns_fetch_t *fetch;
dns_rdataset_t rdataset;
dns_rdataset_t sigrdataset;
dns_fixedname_t fn;
dns_name_t *name;
dns_name_t name;
isc_stdtime_t expiry;
bool shuttingdown;
};
@ -104,6 +103,7 @@ dns__nta_destroy(dns__nta_t *nta) {
dns_resolver_destroyfetch(&nta->fetch);
}
isc_loop_detach(&nta->loop);
dns_name_free(&nta->name, nta->mctx);
isc_mem_putanddetach(&nta->mctx, nta, sizeof(*nta));
}
@ -240,9 +240,9 @@ checkbogus(void *arg) {
dns__nta_ref(nta); /* for dns_resolver_createfetch */
result = dns_resolver_createfetch(
resolver, nta->name, dns_rdatatype_nsec, NULL, NULL, NULL, NULL,
0, DNS_FETCHOPT_NONTA, 0, NULL, nta->loop, fetch_done, nta,
&nta->rdataset, &nta->sigrdataset, &nta->fetch);
resolver, &nta->name, dns_rdatatype_nsec, NULL, NULL, NULL,
NULL, 0, DNS_FETCHOPT_NONTA, 0, NULL, nta->loop, fetch_done,
nta, &nta->rdataset, &nta->sigrdataset, &nta->fetch);
if (result != ISC_R_SUCCESS) {
dns__nta_detach(&nta); /* for dns_resolver_createfetch() */
}
@ -278,6 +278,7 @@ nta_create(dns_ntatable_t *ntatable, const dns_name_t *name,
nta = isc_mem_get(ntatable->mctx, sizeof(dns__nta_t));
*nta = (dns__nta_t){
.ntatable = ntatable,
.name = DNS_NAME_INITEMPTY,
.magic = NTA_MAGIC,
};
isc_mem_attach(ntatable->mctx, &nta->mctx);
@ -288,8 +289,7 @@ nta_create(dns_ntatable_t *ntatable, const dns_name_t *name,
isc_refcount_init(&nta->references, 1);
nta->name = dns_fixedname_initname(&nta->fn);
dns_name_copy(name, nta->name);
dns_name_dupwithoffsets(name, nta->mctx, &nta->name);
*target = nta;
}
@ -316,7 +316,7 @@ dns_ntatable_add(dns_ntatable_t *ntatable, const dns_name_t *name, bool force,
result = dns_qp_insert(qp, nta, 0);
switch (result) {
case ISC_R_EXISTS:
result = dns_qp_getname(qp, nta->name, &pval, NULL);
result = dns_qp_getname(qp, &nta->name, &pval, NULL);
if (result == ISC_R_SUCCESS) {
/*
* an NTA already existed: throw away the
@ -379,16 +379,16 @@ delete_expired(void *arg) {
RWLOCK(&ntatable->rwlock, isc_rwlocktype_write);
dns_qpmulti_write(ntatable->table, &qp);
result = dns_qp_getname(qp, nta->name, &pval, NULL);
result = dns_qp_getname(qp, &nta->name, &pval, NULL);
if (result == ISC_R_SUCCESS &&
((dns__nta_t *)pval)->expiry == nta->expiry && !nta->shuttingdown)
{
char nb[DNS_NAME_FORMATSIZE];
dns_name_format(nta->name, nb, sizeof(nb));
dns_name_format(&nta->name, nb, sizeof(nb));
isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_NTA, ISC_LOG_INFO,
"deleting expired NTA at %s", nb);
dns_qp_deletename(qp, nta->name, NULL, NULL);
dns_qp_deletename(qp, &nta->name, NULL, NULL);
dns__nta_shutdown(nta);
dns__nta_unref(nta);
}
@ -425,7 +425,7 @@ dns_ntatable_covered(dns_ntatable_t *ntatable, isc_stdtime_t now,
* Found a NTA that's an ancestor of 'name'; we
* now have to make sure 'anchor' isn't below it.
*/
if (!dns_name_issubdomain(nta->name, anchor)) {
if (!dns_name_issubdomain(&nta->name, anchor)) {
goto done;
}
/* Ancestor match */
@ -487,7 +487,7 @@ dns_ntatable_totext(dns_ntatable_t *ntatable, const char *view,
sizeof("expired: \n")];
isc_time_t t;
dns_name_format(n->name, nbuf, sizeof(nbuf));
dns_name_format(&n->name, nbuf, sizeof(nbuf));
if (n->expiry != 0xffffffffU) {
/* Normal NTA entries */
@ -549,7 +549,7 @@ dns_ntatable_save(dns_ntatable_t *ntatable, FILE *fp) {
}
isc_buffer_init(&b, nbuf, sizeof(nbuf));
result = dns_name_totext(n->name, 0, &b);
result = dns_name_totext(&n->name, 0, &b);
if (result != ISC_R_SUCCESS) {
continue;
}
@ -586,7 +586,7 @@ dns__nta_shutdown_cb(void *arg) {
if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(3))) {
char nb[DNS_NAME_FORMATSIZE];
dns_name_format(nta->name, nb, sizeof(nb));
dns_name_format(&nta->name, nb, sizeof(nb));
isc_log_write(dns_lctx, DNS_LOGCATEGORY_DNSSEC,
DNS_LOGMODULE_NTA, ISC_LOG_DEBUG(3),
"shutting down NTA %p at %s", nta, nb);
@ -650,7 +650,7 @@ static size_t
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
dns__nta_t *nta = pval;
return (dns_qpkey_fromname(key, nta->name));
return (dns_qpkey_fromname(key, &nta->name));
}
static void

37
lib/dns/qpcache.c
View file

@ -216,13 +216,7 @@ struct dns_qpdata {
unsigned int : 0; /* end of bitfields c/o tree lock */
/*@}*/
/*%
* This is needed for hashing.
*/
unsigned int hashval;
dns_fixedname_t fn;
dns_name_t *name;
dns_name_t name;
isc_mem_t *mctx;
/*%
@ -409,7 +403,7 @@ static size_t
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
dns_qpdata_t *data = pval;
return (dns_qpkey_fromname(key, data->name));
return (dns_qpkey_fromname(key, &data->name));
}
static void
@ -672,7 +666,7 @@ delete_node(dns_qpdb_t *qpdb, dns_qpdata_t *node) {
if (isc_log_wouldlog(dns_lctx, ISC_LOG_DEBUG(1))) {
char printname[DNS_NAME_FORMATSIZE];
dns_name_format(node->name, printname, sizeof(printname));
dns_name_format(&node->name, printname, sizeof(printname));
isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_CACHE, ISC_LOG_DEBUG(1),
"delete_node(): %p %s (bucket %d)", node,
@ -685,7 +679,7 @@ delete_node(dns_qpdb_t *qpdb, dns_qpdata_t *node) {
* Delete the corresponding node from the auxiliary NSEC
* tree before deleting from the main tree.
*/
result = dns_qp_deletename(qpdb->nsec, node->name, NULL, NULL);
result = dns_qp_deletename(qpdb->nsec, &node->name, NULL, NULL);
if (result != ISC_R_SUCCESS) {
isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
@ -695,13 +689,14 @@ delete_node(dns_qpdb_t *qpdb, dns_qpdata_t *node) {
}
/* FALLTHROUGH */
case DNS_DB_NSEC_NORMAL:
result = dns_qp_deletename(qpdb->tree, node->name, NULL, NULL);
result = dns_qp_deletename(qpdb->tree, &node->name, NULL, NULL);
break;
case DNS_DB_NSEC_NSEC:
result = dns_qp_deletename(qpdb->nsec, node->name, NULL, NULL);
result = dns_qp_deletename(qpdb->nsec, &node->name, NULL, NULL);
break;
case DNS_DB_NSEC_NSEC3:
result = dns_qp_deletename(qpdb->nsec3, node->name, NULL, NULL);
result = dns_qp_deletename(qpdb->nsec3, &node->name, NULL,
NULL);
break;
}
if (result != ISC_R_SUCCESS) {
@ -1486,7 +1481,7 @@ find_deepest_zonecut(qpdb_search_t *search, dns_qpdata_t *node,
* anything else.
*/
if (foundname != NULL) {
dns_name_copy(node->name, foundname);
dns_name_copy(&node->name, foundname);
}
result = DNS_R_DELEGATION;
if (nodep != NULL) {
@ -2860,13 +2855,12 @@ new_qpdata(dns_qpdb_t *qpdb, const dns_name_t *name) {
dns_qpdata_t *newdata = isc_mem_get(qpdb->common.mctx,
sizeof(*newdata));
*newdata = (dns_qpdata_t){
.name = DNS_NAME_INITEMPTY,
.references = ISC_REFCOUNT_INITIALIZER(1),
};
newdata->hashval = dns_name_hash(name);
newdata->locknum = newdata->hashval % qpdb->node_lock_count;
newdata->name = dns_fixedname_initname(&newdata->fn);
dns_name_copy(name, newdata->name);
newdata->locknum = dns_name_hash(name) % qpdb->node_lock_count;
isc_mem_attach(qpdb->common.mctx, &newdata->mctx);
dns_name_dupwithoffsets(name, newdata->mctx, &newdata->name);
ISC_LINK_INIT(newdata, deadlink);
@ -3594,7 +3588,7 @@ addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
}
name = dns_fixedname_initname(&fixed);
dns_name_copy(qpnode->name, name);
dns_name_copy(&qpnode->name, name);
dns_rdataset_getownercase(rdataset, name);
newheader = (dns_slabheader_t *)region.base;
@ -4491,7 +4485,7 @@ dbiterator_seek(dns_dbiterator_t *iterator,
if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) {
qpdbiter->new_origin = true;
dns_name_copy(qpdbiter->node->name, qpdbiter->name);
dns_name_copy(&qpdbiter->node->name, qpdbiter->name);
reference_iter_node(qpdbiter DNS__DB_FLARG_PASS);
} else {
qpdbiter->node = NULL;
@ -4642,7 +4636,7 @@ dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep,
}
if (name != NULL) {
dns_name_copy(qpdbiter->node->name, name);
dns_name_copy(&qpdbiter->node->name, name);
if (qpdbiter->common.relative_names && qpdbiter->new_origin) {
result = DNS_R_NEWORIGIN;
@ -4807,6 +4801,7 @@ qpdata_destroy(dns_qpdata_t *data) {
dns_slabheader_destroy(&current);
}
dns_name_free(&data->name, data->mctx);
isc_mem_putanddetach(&data->mctx, data, sizeof(dns_qpdata_t));
}

29
lib/dns/qpzone.c
View file

@ -45,6 +45,7 @@
#include <dns/fixedname.h>
#include <dns/log.h>
#include <dns/masterdump.h>
#include <dns/name.h>
#include <dns/nsec.h>
#include <dns/nsec3.h>
#include <dns/qp.h>
@ -150,8 +151,7 @@ struct qpdb_version {
typedef ISC_LIST(qpdb_version_t) qpdb_versionlist_t;
struct qpdata {
dns_fixedname_t fn;
dns_name_t *name;
dns_name_t name;
isc_mem_t *mctx;
isc_refcount_t references;
isc_refcount_t erefs;
@ -597,11 +597,11 @@ static qpdata_t *
new_qpdata(qpzonedb_t *qpdb, const dns_name_t *name) {
qpdata_t *newdata = isc_mem_get(qpdb->common.mctx, sizeof(*newdata));
*newdata = (qpdata_t){
.name = DNS_NAME_INITEMPTY,
.references = ISC_REFCOUNT_INITIALIZER(1),
};
newdata->locknum = dns_name_hash(name) % qpdb->node_lock_count;
newdata->name = dns_fixedname_initname(&newdata->fn);
dns_name_copy(name, newdata->name);
dns_name_dupwithoffsets(name, qpdb->common.mctx, &newdata->name);
isc_mem_attach(qpdb->common.mctx, &newdata->mctx);
#if DNS_DB_NODETRACE
@ -2517,7 +2517,7 @@ getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset,
rdataset DNS__DB_FLARG_PASS);
if (foundname != NULL) {
dns_name_copy(HEADERNODE(header)->name, foundname);
dns_name_copy(&HEADERNODE(header)->name, foundname);
}
NODE_UNLOCK(&qpdb->node_locks[locknum].lock, &nlocktype);
@ -2922,7 +2922,7 @@ find_wildcard(qpdb_search_t *search, qpdata_t **nodep,
* Construct the wildcard name for this level.
*/
result = dns_name_concatenate(dns_wildcardname,
node->name, wname, NULL);
&node->name, wname, NULL);
if (result != ISC_R_SUCCESS) {
break;
}
@ -3355,7 +3355,7 @@ check_zonecut(qpdata_t *node, void *arg DNS__DB_FLARG) {
* is, we need to remember the node name.
*/
zcname = dns_fixedname_name(&search->zonecut_name);
dns_name_copy(node->name, zcname);
dns_name_copy(&node->name, zcname);
search->copy_name = true;
}
} else {
@ -4604,7 +4604,7 @@ dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep,
REQUIRE(qpdbiter->node != NULL);
if (name != NULL) {
dns_name_copy(qpdbiter->node->name, name);
dns_name_copy(&qpdbiter->node->name, name);
}
newref(qpdb, node DNS__DB_FLARG_PASS);
@ -4785,7 +4785,7 @@ addrdataset(dns_db_t *db, dns_dbnode_t *dbnode, dns_dbversion_t *dbversion,
return (result);
}
dns_name_copy(node->name, name);
dns_name_copy(&node->name, name);
dns_rdataset_getownercase(rdataset, name);
newheader = (dns_slabheader_t *)region.base;
@ -4923,7 +4923,7 @@ subtractrdataset(dns_db_t *db, dns_dbnode_t *dbnode, dns_dbversion_t *dbversion,
rdataset->type != dns_rdatatype_nsec3 &&
rdataset->covers != dns_rdatatype_nsec3)));
dns_name_copy(node->name, nodename);
dns_name_copy(&node->name, nodename);
result = dns_rdataslab_fromrdataset(rdataset, qpdb->common.mctx,
&region, sizeof(dns_slabheader_t));
if (result != ISC_R_SUCCESS) {
@ -5113,7 +5113,7 @@ deleterdataset(dns_db_t *db, dns_dbnode_t *dbnode, dns_dbversion_t *dbversion,
atomic_init(&newheader->attributes, DNS_SLABHEADERATTR_NONEXISTENT);
newheader->serial = version->serial;
dns_name_copy(node->name, nodename);
dns_name_copy(&node->name, nodename);
NODE_WRLOCK(&qpdb->node_locks[node->locknum].lock, &nlocktype);
result = add(qpdb, node, nodename, version, newheader, DNS_DBADD_FORCE,
@ -5133,7 +5133,7 @@ nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name) {
REQUIRE(name != NULL);
NODE_RDLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
dns_name_copy(qpnode->name, name);
dns_name_copy(&qpnode->name, name);
NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
return (ISC_R_SUCCESS);
}
@ -5372,7 +5372,7 @@ newglue(qpzonedb_t *qpdb, qpdb_version_t *version, qpdata_t *node,
* determining which NS records in the delegation are
* in-bailiwick).
*/
dns_name_copy(node->name, ctx.nodename);
dns_name_copy(&node->name, ctx.nodename);
(void)dns_rdataset_additionaldata(rdataset, dns_rootname,
glue_nsdname_cb, &ctx);
@ -5487,6 +5487,7 @@ destroy_qpdata(qpdata_t *node) {
dns_slabheader_destroy(&current);
}
dns_name_free(&node->name, node->mctx);
isc_mem_putanddetach(&node->mctx, node, sizeof(qpdata_t));
}
@ -5514,7 +5515,7 @@ static size_t
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
qpdata_t *data = pval;
return (dns_qpkey_fromname(key, data->name));
return (dns_qpkey_fromname(key, &data->name));
}
static void

10
lib/dns/resolver.c
View file

@ -3459,12 +3459,12 @@ fctx_getaddresses(fetchctx_t *fctx, bool badcache) {
if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) {
fwd = ISC_LIST_HEAD(forwarders->fwdrs);
fctx->fwdpolicy = forwarders->fwdpolicy;
dns_name_copy(forwarders->name, fctx->fwdname);
dns_name_copy(&forwarders->name, fctx->fwdname);
if (fctx->fwdpolicy == dns_fwdpolicy_only &&
isstrictsubdomain(forwarders->name, fctx->domain))
isstrictsubdomain(&forwarders->name, fctx->domain))
{
fcount_decr(fctx);
dns_name_copy(forwarders->name, fctx->domain);
dns_name_copy(&forwarders->name, fctx->domain);
result = fcount_incr(fctx, true);
if (result != ISC_R_SUCCESS) {
dns_forwarders_detach(&forwarders);
@ -4565,7 +4565,7 @@ fctx_create(dns_resolver_t *res, isc_loop_t *loop, const dns_name_t *name,
&forwarders);
if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) {
fctx->fwdpolicy = forwarders->fwdpolicy;
dns_name_copy(forwarders->name, fctx->fwdname);
dns_name_copy(&forwarders->name, fctx->fwdname);
dns_forwarders_detach(&forwarders);
}
@ -6555,7 +6555,7 @@ name_external(const dns_name_t *name, dns_rdatatype_t type, fetchctx_t *fctx) {
* See if the forwarder declaration is better.
*/
if (result == ISC_R_SUCCESS || result == DNS_R_PARTIALMATCH) {
bool better = !dns_name_equal(forwarders->name,
bool better = !dns_name_equal(&forwarders->name,
fctx->fwdname);
dns_forwarders_detach(&forwarders);
return (better);

10
lib/dns/rpz.c
View file

@ -174,8 +174,7 @@ struct dns_rpz_nm_zbits {
*/
typedef struct nmdata nmdata_t;
struct nmdata {
dns_fixedname_t fn;
dns_name_t *name;
dns_name_t name;
isc_mem_t *mctx;
isc_refcount_t references;
dns_rpz_nm_zbits_t set;
@ -1408,10 +1407,10 @@ new_nmdata(isc_mem_t *mctx, const dns_name_t *name, const nmdata_t *data) {
*newdata = (nmdata_t){
.set = data->set,
.wild = data->wild,
.name = DNS_NAME_INITEMPTY,
.references = ISC_REFCOUNT_INITIALIZER(1),
};
newdata->name = dns_fixedname_initname(&newdata->fn);
dns_name_copy(name, newdata->name);
dns_name_dupwithoffsets(name, mctx, &newdata->name);
isc_mem_attach(mctx, &newdata->mctx);
#ifdef DNS_RPZ_TRACE
@ -2683,6 +2682,7 @@ dns_rpz_decode_cname(dns_rpz_zone_t *rpz, dns_rdataset_t *rdataset,
static void
destroy_nmdata(nmdata_t *data) {
dns_name_free(&data->name, data->mctx);
isc_mem_putanddetach(&data->mctx, data, sizeof(nmdata_t));
}
@ -2710,7 +2710,7 @@ static size_t
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
nmdata_t *data = pval;
return (dns_qpkey_fromname(key, data->name));
return (dns_qpkey_fromname(key, &data->name));
}
static void