reduce memory consumption of the remaining QP databases

use dynamically allocated names instead of fixednames in
forward.c, keytable.c, nametree.c, and nta.c

diff --git a/lib/dns/forward.c b/lib/dns/forward.c
index f48a3dc0767c70eb1b6988c22342da1ba2b348b7..b186aacee49f9da6339a28e3d001b86af4fca128 100644 (file)
--- a/lib/dns/forward.c
+++ b/lib/dns/forward.c
@@ -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

diff --git a/lib/dns/include/dns/forward.h b/lib/dns/include/dns/forward.h
index e300a9555cfb0c1dac8feb55ab11884d4d443ca7..4da882943ae2750c33d24463e89143747aed3b22 100644 (file)
--- a/lib/dns/include/dns/forward.h
+++ b/lib/dns/include/dns/forward.h
@@ -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

diff --git a/lib/dns/keytable.c b/lib/dns/keytable.c
index 7284140951344894a27fb67038b28b1594f10063..7429e68c6e423ecd8b957bbf27ad525045382e34 100644 (file)
--- a/lib/dns/keytable.c
+++ b/lib/dns/keytable.c
@@ -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

diff --git a/lib/dns/nametree.c b/lib/dns/nametree.c
index f2b323272677f667d60544870b220332d1be01fc..77ecd309b8b9965dea08591b124decfc696f1890 100644 (file)
--- a/lib/dns/nametree.c
+++ b/lib/dns/nametree.c
@@ -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

diff --git a/lib/dns/nta.c b/lib/dns/nta.c
index ce00b25d8a19e61346c037c2e7baf878673f7399..dad45a1ec0fe0ebf4dd09b63bfe64e27c2452a62 100644 (file)
--- a/lib/dns/nta.c
+++ b/lib/dns/nta.c
@@ -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

diff --git a/lib/dns/resolver.c b/lib/dns/resolver.c
index 0570ff45a2ba37cb0a897d8e0b41e85137c8cb8b..4e1fc8ad90ccc64782af059c38613a881e54e092 100644 (file)
--- a/lib/dns/resolver.c
+++ b/lib/dns/resolver.c
@@ -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);