Replace dns_rbtnode_t with dns_qpdata_t

This for now has almost the same structure contents except for
dns_qpdata_t has 'fn' and 'name' to store the domain name.

diff --git a/lib/dns/include/dns/types.h b/lib/dns/include/dns/types.h
index c09aba40edd7b3476a7d99230c8d4762e7b27159..b938d13752bb7a476ec8e6817191017062cdd4c2 100644 (file)
--- a/lib/dns/include/dns/types.h
+++ b/lib/dns/include/dns/types.h
@@ -149,11 +149,12 @@ typedef struct dns_requestmgr     dns_requestmgr_t;
 typedef struct dns_resolver    dns_resolver_t;
 typedef struct dns_rpsdb       dns_rpsdb_t;
 typedef struct dns_qpdata      dns_qpdata_t;
-typedef struct dns_qpnode      dns_qpnode_t;
-typedef uint8_t                        dns_secalg_t;
-typedef uint8_t                        dns_secproto_t;
-typedef struct dns_signature   dns_signature_t;
-typedef struct dns_slabheader  dns_slabheader_t;
+typedef ISC_LIST(dns_qpdata_t) dns_qpdatalist_t;
+typedef struct dns_qpnode     dns_qpnode_t;
+typedef uint8_t                      dns_secalg_t;
+typedef uint8_t                      dns_secproto_t;
+typedef struct dns_signature  dns_signature_t;
+typedef struct dns_slabheader dns_slabheader_t;
 typedef ISC_LIST(dns_slabheader_t) dns_slabheaderlist_t;
 typedef struct dns_sortlist_arg          dns_sortlist_arg_t;
 typedef struct dns_ssurule       dns_ssurule_t;

diff --git a/lib/dns/qp-cachedb.c b/lib/dns/qp-cachedb.c
index b063ad7a2afa354e18b602326ee8c8569c6903d4..4f522399ca590249340eb751dd63608ed3fe4dcb 100644 (file)
--- a/lib/dns/qp-cachedb.c
+++ b/lib/dns/qp-cachedb.c
@@ -266,7 +266,7 @@ setup_delegation(qpdb_search_t *search, dns_dbnode_t **nodep,
                 dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
        dns_name_t *zcname = NULL;
        dns_typepair_t type;
-       dns_rbtnode_t *node = NULL;
+       dns_qpdata_t *node = NULL;
 
        REQUIRE(search != NULL);
        REQUIRE(search->zonecut != NULL);
@@ -323,7 +323,7 @@ setup_delegation(qpdb_search_t *search, dns_dbnode_t **nodep,
 }
 
 static bool
-check_stale_header(dns_rbtnode_t *node, dns_slabheader_t *header,
+check_stale_header(dns_qpdata_t *node, dns_slabheader_t *header,
                   isc_rwlocktype_t *nlocktypep, isc_rwlock_t *lock,
                   qpdb_search_t *search, dns_slabheader_t **header_prev) {
        if (!ACTIVE(header, search->now)) {
@@ -430,7 +430,7 @@ check_stale_header(dns_rbtnode_t *node, dns_slabheader_t *header,
 }
 
 static isc_result_t
-check_zonecut(dns_rbtnode_t *node, void *arg DNS__DB_FLARG) {
+check_zonecut(dns_qpdata_t *node, void *arg DNS__DB_FLARG) {
        qpdb_search_t *search = arg;
        dns_slabheader_t *header = NULL;
        dns_slabheader_t *header_prev = NULL, *header_next = NULL;
@@ -493,7 +493,7 @@ check_zonecut(dns_rbtnode_t *node, void *arg DNS__DB_FLARG) {
 }
 
 static isc_result_t
-find_deepest_zonecut(qpdb_search_t *search, dns_rbtnode_t *node,
+find_deepest_zonecut(qpdb_search_t *search, dns_qpdata_t *node,
                     dns_dbnode_t **nodep, dns_name_t *foundname,
                     dns_rdataset_t *rdataset,
                     dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
@@ -620,7 +620,7 @@ find_coveringnsec(qpdb_search_t *search, const dns_name_t *name,
                  dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
        dns_fixedname_t fpredecessor, fixed;
        dns_name_t *predecessor = NULL, *fname = NULL;
-       dns_rbtnode_t *node = NULL;
+       dns_qpdata_t *node = NULL;
        dns_qpiter_t iter;
        isc_result_t result;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
@@ -717,7 +717,7 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
           dns_dbnode_t **nodep, dns_name_t *foundname,
           dns_rdataset_t *rdataset,
           dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
-       dns_rbtnode_t *node = NULL;
+       dns_qpdata_t *node = NULL;
        isc_result_t result;
        qpdb_search_t search;
        bool cname_ok = true;
@@ -774,7 +774,7 @@ cache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
 
        for (unsigned int i = 0; i < len; i++) {
                isc_result_t zcresult;
-               dns_rbtnode_t *encloser = NULL;
+               dns_qpdata_t *encloser = NULL;
 
                dns_qpchain_node(&search.chain, i, NULL, (void **)&encloser,
                                 NULL);
@@ -1163,7 +1163,7 @@ cache_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options,
                  dns_name_t *foundname, dns_name_t *dcname,
                  dns_rdataset_t *rdataset,
                  dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
-       dns_rbtnode_t *node = NULL;
+       dns_qpdata_t *node = NULL;
        isc_rwlock_t *lock = NULL;
        isc_result_t result;
        qpdb_search_t search;
@@ -1339,7 +1339,7 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
                   isc_stdtime_t now, dns_rdataset_t *rdataset,
                   dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
        dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
-       dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
+       dns_qpdata_t *qpnode = (dns_qpdata_t *)node;
        dns_slabheader_t *header = NULL, *header_next = NULL;
        dns_slabheader_t *found = NULL, *foundsig = NULL;
        dns_typepair_t matchtype, sigmatchtype, negtype;
@@ -1358,7 +1358,7 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
                now = isc_stdtime_now();
        }
 
-       lock = &qpdb->node_locks[rbtnode->locknum].lock;
+       lock = &qpdb->node_locks[qpnode->locknum].lock;
        NODE_RDLOCK(lock, &nlocktype);
 
        matchtype = DNS_TYPEPAIR_VALUE(type, covers);
@@ -1369,7 +1369,7 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
                sigmatchtype = 0;
        }
 
-       for (header = rbtnode->data; header != NULL; header = header_next) {
+       for (header = qpnode->data; header != NULL; header = header_next) {
                header_next = header->next;
                if (!ACTIVE(header, now)) {
                        if ((header->ttl + STALE_TTL(header, qpdb) <
@@ -1382,9 +1382,9 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
                                 * We update the node's status only when we
                                 * can get write access.
                                 *
-                                * We don't check if refcurrent(rbtnode) == 0
+                                * We don't check if refcurrent(qpnode) == 0
                                 * and try to free like we do in cache_find(),
-                                * because refcurrent(rbtnode) must be
+                                * because refcurrent(qpnode) must be
                                 * non-zero.  This is so because 'node' is an
                                 * argument to the function.
                                 */
@@ -1405,10 +1405,10 @@ cache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
                }
        }
        if (found != NULL) {
-               dns__qpdb_bindrdataset(qpdb, rbtnode, found, now, nlocktype,
+               dns__qpdb_bindrdataset(qpdb, qpnode, found, now, nlocktype,
                                       rdataset DNS__DB_FLARG_PASS);
                if (!NEGATIVE(found) && foundsig != NULL) {
-                       dns__qpdb_bindrdataset(qpdb, rbtnode, foundsig, now,
+                       dns__qpdb_bindrdataset(qpdb, qpnode, foundsig, now,
                                               nlocktype,
                                               sigrdataset DNS__DB_FLARG_PASS);
                }
@@ -1522,15 +1522,15 @@ getservestalerefresh(dns_db_t *db, uint32_t *interval) {
 static void
 expiredata(dns_db_t *db, dns_dbnode_t *node, void *data) {
        dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
-       dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
+       dns_qpdata_t *qpnode = (dns_qpdata_t *)node;
        dns_slabheader_t *header = data;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
        isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
 
-       NODE_WRLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+       NODE_WRLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
        dns__qpcache_expireheader(header, &tlocktype,
-                                 dns_expire_flush DNS__DB_FLARG_PASS);
-       NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+                                 dns_expire_flush DNS__DB_FILELINE);
+       NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
        INSIST(tlocktype == isc_rwlocktype_none);
 }
 
@@ -1667,8 +1667,7 @@ dns__qpcache_overmem(dns_qpdb_t *qpdb, dns_slabheader_t *newheader,
        uint32_t locknum_start = qpdb->lru_sweep++ % qpdb->node_lock_count;
        uint32_t locknum = locknum_start;
        /* Size of added data, possible node and possible ENT node. */
-       size_t purgesize = rdataset_size(newheader) +
-                          2 * dns__rbtnode_getsize(QPDB_HEADERNODE(newheader));
+       size_t purgesize = rdataset_size(newheader) + 2 * sizeof(dns_qpdata_t);
        size_t purged = 0;
        isc_stdtime_t min_last_used = 0;
        size_t max_passes = 8;

diff --git a/lib/dns/qp-zonedb.c b/lib/dns/qp-zonedb.c
index 57fcaa5765005580045db94ae6cab85b1e3b292a..f5a14a33efbbc86c9f8a2abf86e9be1af1fbae48 100644 (file)
--- a/lib/dns/qp-zonedb.c
+++ b/lib/dns/qp-zonedb.c
@@ -103,14 +103,14 @@ findnsec3node(dns_db_t *db, const dns_name_t *name, bool create,
 }
 
 static isc_result_t
-check_zonecut(dns_rbtnode_t *node, void *arg DNS__DB_FLARG) {
+check_zonecut(dns_qpdata_t *node, void *arg DNS__DB_FLARG) {
        qpdb_search_t *search = arg;
        dns_slabheader_t *header = NULL, *header_next = NULL;
        dns_slabheader_t *dname_header = NULL, *sigdname_header = NULL;
        dns_slabheader_t *ns_header = NULL;
        dns_slabheader_t *found = NULL;
        isc_result_t result = DNS_R_CONTINUE;
-       dns_rbtnode_t *onode = NULL;
+       dns_qpdata_t *onode = NULL;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
 
        /*
@@ -256,7 +256,7 @@ setup_delegation(qpdb_search_t *search, dns_dbnode_t **nodep,
                 dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
        dns_name_t *zcname = NULL;
        dns_typepair_t type;
-       dns_rbtnode_t *node = NULL;
+       dns_qpdata_t *node = NULL;
 
        REQUIRE(search != NULL);
        REQUIRE(search->zonecut != NULL);
@@ -326,7 +326,7 @@ step(qpdb_search_t *search, dns_qpiter_t *iter, direction_t direction,
        dns_fixedname_t fnodename;
        dns_name_t *nodename = dns_fixedname_initname(&fnodename);
        dns_qpdb_t *qpdb = NULL;
-       dns_rbtnode_t *node = NULL;
+       dns_qpdata_t *node = NULL;
        isc_result_t result = ISC_R_SUCCESS;
        dns_slabheader_t *header = NULL;
 
@@ -464,7 +464,7 @@ wildcard_blocked(qpdb_search_t *search, const dns_name_t *qname,
 }
 
 static isc_result_t
-find_wildcard(qpdb_search_t *search, dns_rbtnode_t **nodep,
+find_wildcard(qpdb_search_t *search, dns_qpdata_t **nodep,
              const dns_name_t *qname) {
        dns_slabheader_t *header = NULL;
        isc_result_t result = ISC_R_NOTFOUND;
@@ -488,7 +488,7 @@ find_wildcard(qpdb_search_t *search, dns_rbtnode_t **nodep,
 
        qpdb = search->qpdb;
        for (int i = dns_qpchain_length(&search->chain) - 1; i >= 0; i--) {
-               dns_rbtnode_t *node = NULL;
+               dns_qpdata_t *node = NULL;
                isc_rwlock_t *lock = NULL;
                isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
 
@@ -516,7 +516,7 @@ find_wildcard(qpdb_search_t *search, dns_rbtnode_t **nodep,
                NODE_UNLOCK(lock, &nlocktype);
 
                if (wild) {
-                       dns_rbtnode_t *wnode = NULL;
+                       dns_qpdata_t *wnode = NULL;
                        dns_fixedname_t fwname;
                        dns_name_t *wname = NULL;
                        dns_qpiter_t witer;
@@ -638,11 +638,11 @@ matchparams(dns_slabheader_t *header, qpdb_search_t *search) {
 static isc_result_t
 previous_closest_nsec(dns_rdatatype_t type, qpdb_search_t *search,
                      dns_name_t *name, dns_name_t *origin,
-                     dns_rbtnode_t **nodep, dns_qpiter_t *nseciter,
+                     dns_qpdata_t **nodep, dns_qpiter_t *nseciter,
                      bool *firstp) {
        dns_fixedname_t ftarget;
        dns_name_t *target = NULL;
-       dns_rbtnode_t *nsecnode = NULL;
+       dns_qpdata_t *nsecnode = NULL;
        isc_result_t result;
 
        REQUIRE(nodep != NULL && *nodep == NULL);
@@ -741,7 +741,7 @@ find_closest_nsec(qpdb_search_t *search, dns_dbnode_t **nodep,
                  dns_name_t *foundname, dns_rdataset_t *rdataset,
                  dns_rdataset_t *sigrdataset, dns_qp_t *tree,
                  bool secure DNS__DB_FLARG) {
-       dns_rbtnode_t *node = NULL, *prevnode = NULL;
+       dns_qpdata_t *node = NULL, *prevnode = NULL;
        dns_slabheader_t *header = NULL, *header_next = NULL;
        dns_qpiter_t nseciter;
        bool empty_node;
@@ -933,7 +933,7 @@ zone_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
          isc_stdtime_t now ISC_ATTR_UNUSED, dns_dbnode_t **nodep,
          dns_name_t *foundname, dns_rdataset_t *rdataset,
          dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
-       dns_rbtnode_t *node = NULL;
+       dns_qpdata_t *node = NULL;
        isc_result_t result;
        qpdb_search_t search;
        bool cname_ok = true;
@@ -997,7 +997,7 @@ zone_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
 
        for (unsigned int i = 0; i < len; i++) {
                isc_result_t zcresult;
-               dns_rbtnode_t *encloser = NULL;
+               dns_qpdata_t *encloser = NULL;
 
                dns_qpchain_node(&search.chain, i, NULL, (void **)&encloser,
                                 NULL);
@@ -1471,7 +1471,7 @@ zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
                  isc_stdtime_t now, dns_rdataset_t *rdataset,
                  dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
        dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
-       dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
+       dns_qpdata_t *qpnode = (dns_qpdata_t *)node;
        dns_slabheader_t *header = NULL, *header_next = NULL;
        dns_slabheader_t *found = NULL, *foundsig = NULL;
        uint32_t serial;
@@ -1492,7 +1492,7 @@ zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
        serial = rbtversion->serial;
        now = 0;
 
-       NODE_RDLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+       NODE_RDLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
 
        matchtype = DNS_TYPEPAIR_VALUE(type, covers);
        if (covers == 0) {
@@ -1501,7 +1501,7 @@ zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
                sigmatchtype = 0;
        }
 
-       for (header = rbtnode->data; header != NULL; header = header_next) {
+       for (header = qpnode->data; header != NULL; header = header_next) {
                header_next = header->next;
                do {
                        if (header->serial <= serial && !IGNORE(header)) {
@@ -1536,17 +1536,17 @@ zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
                }
        }
        if (found != NULL) {
-               dns__qpdb_bindrdataset(qpdb, rbtnode, found, now,
+               dns__qpdb_bindrdataset(qpdb, qpnode, found, now,
                                       isc_rwlocktype_read,
                                       rdataset DNS__DB_FLARG_PASS);
                if (foundsig != NULL) {
-                       dns__qpdb_bindrdataset(qpdb, rbtnode, foundsig, now,
+                       dns__qpdb_bindrdataset(qpdb, qpnode, foundsig, now,
                                               isc_rwlocktype_read,
                                               sigrdataset DNS__DB_FLARG_PASS);
                }
        }
 
-       NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+       NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
 
        if (close_version) {
                dns__qpdb_closeversion(
@@ -1562,7 +1562,7 @@ zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
 }
 
 static bool
-delegating_type(dns_qpdb_t *qpdb, dns_rbtnode_t *node, dns_typepair_t type) {
+delegating_type(dns_qpdb_t *qpdb, dns_qpdata_t *node, dns_typepair_t type) {
        if (type == dns_rdatatype_dname ||
            (type == dns_rdatatype_ns &&
             (node != qpdb->origin_node || IS_STUB(qpdb))))
@@ -1576,10 +1576,10 @@ delegating_type(dns_qpdb_t *qpdb, dns_rbtnode_t *node, dns_typepair_t type) {
  * load a non-NSEC3 node in the main tree and optionally to the auxiliary NSEC
  */
 static isc_result_t
-loadnode(dns_qpdb_t *qpdb, const dns_name_t *name, dns_rbtnode_t **nodep,
+loadnode(dns_qpdb_t *qpdb, const dns_name_t *name, dns_qpdata_t **nodep,
         bool hasnsec) {
        isc_result_t noderesult, nsecresult;
-       dns_rbtnode_t *nsecnode = NULL, *node = NULL;
+       dns_qpdata_t *nsecnode = NULL, *node = NULL;
 
        noderesult = dns_qp_getname(qpdb->tree, name, (void **)&node, NULL);
        if (noderesult != ISC_R_SUCCESS) {
@@ -1643,7 +1643,7 @@ loading_addrdataset(void *arg, const dns_name_t *name,
                    dns_rdataset_t *rdataset DNS__DB_FLARG) {
        qpdb_load_t *loadctx = arg;
        dns_qpdb_t *qpdb = (dns_qpdb_t *)loadctx->db;
-       dns_rbtnode_t *node = NULL;
+       dns_qpdata_t *node = NULL;
        isc_result_t result;
        isc_region_t region;
        dns_slabheader_t *newheader = NULL;
@@ -2066,11 +2066,11 @@ glue_nsdname_cb(void *arg, const dns_name_t *name, dns_rdatatype_t qtype,
        dns_fixedname_t fixedname_a;
        dns_name_t *name_a = NULL;
        dns_rdataset_t rdataset_a, sigrdataset_a;
-       dns_rbtnode_t *node_a = NULL;
+       dns_qpdata_t *node_a = NULL;
        dns_fixedname_t fixedname_aaaa;
        dns_name_t *name_aaaa = NULL;
        dns_rdataset_t rdataset_aaaa, sigrdataset_aaaa;
-       dns_rbtnode_t *node_aaaa = NULL;
+       dns_qpdata_t *node_aaaa = NULL;
        dns_glue_t *glue = NULL;
 
        UNUSED(unused);
@@ -2266,7 +2266,7 @@ addglue_to_message(dns_glue_t *ge, dns_message_t *msg) {
 }
 
 static dns_glue_t *
-newglue(dns_qpdb_t *qpdb, dns_qpdb_version_t *rbtversion, dns_rbtnode_t *node,
+newglue(dns_qpdb_t *qpdb, dns_qpdb_version_t *rbtversion, dns_qpdata_t *node,
        dns_rdataset_t *rdataset) {
        dns_fixedname_t nodename;
        dns_glue_additionaldata_ctx_t ctx = {
@@ -2294,7 +2294,7 @@ addglue(dns_db_t *db, dns_dbversion_t *version, dns_rdataset_t *rdataset,
        dns_message_t *msg) {
        dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
        dns_qpdb_version_t *rbtversion = version;
-       dns_rbtnode_t *node = (dns_rbtnode_t *)rdataset->slab.node;
+       dns_qpdata_t *node = (dns_qpdata_t *)rdataset->slab.node;
        dns_slabheader_t *header = dns_slabheader_fromrdataset(rdataset);
 
        REQUIRE(rdataset->type == dns_rdatatype_ns);
@@ -2415,7 +2415,7 @@ dns__qpzone_wildcardmagic(dns_qpdb_t *qpdb, const dns_name_t *name, bool lock) {
        dns_name_t foundname;
        dns_offsets_t offsets;
        unsigned int n;
-       dns_rbtnode_t *node = NULL;
+       dns_qpdata_t *node = NULL;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
 
        dns_name_init(&foundname, offsets);
@@ -2457,7 +2457,7 @@ dns__qpzone_addwildcards(dns_qpdb_t *qpdb, const dns_name_t *name, bool lock) {
        l = dns_name_countlabels(&qpdb->common.origin);
        i = l + 1;
        while (i < n) {
-               dns_rbtnode_t *node = NULL;
+               dns_qpdata_t *node = NULL;
                dns_name_getlabelsequence(name, n - i, i, &foundname);
                if (dns_name_iswildcard(&foundname)) {
                        result = dns__qpzone_wildcardmagic(qpdb, &foundname,

diff --git a/lib/dns/qpdb.c b/lib/dns/qpdb.c
index b95e9804bd272270b28115f7dc14368b3cae8a4b..903356a3c46b6c98c8ac903cf085c177f5f07085 100644 (file)
--- a/lib/dns/qpdb.c
+++ b/lib/dns/qpdb.c
@@ -282,7 +282,7 @@ typedef struct qpdb_dbiterator {
        dns_qpiter_t iter;
        dns_qpiter_t nsec3iter;
        dns_qpiter_t *current;
-       dns_rbtnode_t *node;
+       dns_qpdata_t *node;
        enum { full, nonsec3, nsec3only } nsec3mode;
 } qpdb_dbiterator_t;
 
@@ -480,7 +480,7 @@ free_qpdb(dns_qpdb_t *qpdb, bool log) {
         * the overhead of unlinking all nodes here should be negligible.
         */
        for (i = 0; i < qpdb->node_lock_count; i++) {
-               dns_rbtnode_t *node = NULL;
+               dns_qpdata_t *node = NULL;
 
                node = ISC_LIST_HEAD(qpdb->deadnodes[i]);
                while (node != NULL) {
@@ -550,7 +550,7 @@ free_qpdb(dns_qpdb_t *qpdb, bool log) {
                        INSIST(ISC_LIST_EMPTY(qpdb->deadnodes[i]));
                }
                isc_mem_cput(qpdb->common.mctx, qpdb->deadnodes,
-                            qpdb->node_lock_count, sizeof(dns_rbtnodelist_t));
+                            qpdb->node_lock_count, sizeof(dns_qpdatalist_t));
        }
        /*
         * Clean up heap objects.
@@ -767,7 +767,7 @@ add_changed(dns_slabheader_t *header,
        REQUIRE(version->writer);
 
        if (changed != NULL) {
-               dns_rbtnode_t *node = (dns_rbtnode_t *)header->node;
+               dns_qpdata_t *node = (dns_qpdata_t *)header->node;
                uint_fast32_t refs = isc_refcount_increment(&node->references);
 #if DNS_DB_NODETRACE
                fprintf(stderr,
@@ -789,7 +789,7 @@ add_changed(dns_slabheader_t *header,
 }
 
 static void
-rollback_node(dns_rbtnode_t *node, uint32_t serial) {
+rollback_node(dns_qpdata_t *node, uint32_t serial) {
        dns_slabheader_t *header = NULL, *dcurrent = NULL;
        bool make_dirty = false;
 
@@ -870,7 +870,7 @@ clean_stale_headers(dns_slabheader_t *top) {
 }
 
 static void
-clean_cache_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node) {
+clean_cache_node(dns_qpdb_t *qpdb, dns_qpdata_t *node) {
        dns_slabheader_t *current = NULL, *top_prev = NULL, *top_next = NULL;
 
        /*
@@ -901,7 +901,7 @@ clean_cache_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node) {
 }
 
 static void
-clean_zone_node(dns_rbtnode_t *node, uint32_t least_serial) {
+clean_zone_node(dns_qpdata_t *node, uint32_t least_serial) {
        dns_slabheader_t *current = NULL, *dcurrent = NULL;
        dns_slabheader_t *down_next = NULL, *dparent = NULL;
        dns_slabheader_t *top_prev = NULL, *top_next = NULL;
@@ -1036,7 +1036,7 @@ clean_zone_node(dns_rbtnode_t *node, uint32_t least_serial) {
  * tree_lock(write) must be held.
  */
 static void
-delete_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node) {
+delete_node(dns_qpdb_t *qpdb, dns_qpdata_t *node) {
        isc_result_t result = ISC_R_UNEXPECTED;
 
        INSIST(!ISC_LINK_LINKED(node, deadlink));
@@ -1088,7 +1088,7 @@ delete_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node) {
  * Caller must be holding the node lock.
  */
 void
-dns__qpdb_newref(dns_qpdb_t *qpdb, dns_rbtnode_t *node,
+dns__qpdb_newref(dns_qpdb_t *qpdb, dns_qpdata_t *node,
                 isc_rwlocktype_t nlocktype DNS__DB_FLARG) {
        uint_fast32_t refs;
 
@@ -1126,13 +1126,13 @@ dns__qpdb_newref(dns_qpdb_t *qpdb, dns_rbtnode_t *node,
  * The tree lock must be held for the result to be valid.
  */
 static bool
-is_leaf(dns_rbtnode_t *node) {
+is_leaf(dns_qpdata_t *node) {
        return (node->parent != NULL && node->parent->down == node &&
                node->left == NULL && node->right == NULL);
 }
 
 static void
-send_to_prune_tree(dns_qpdb_t *qpdb, dns_rbtnode_t *node,
+send_to_prune_tree(dns_qpdb_t *qpdb, dns_qpdata_t *node,
                   isc_rwlocktype_t nlocktype DNS__DB_FLARG) {
        qpdb_prune_t *prune = isc_mem_get(qpdb->common.mctx, sizeof(*prune));
        *prune = (qpdb_prune_t){ .node = node };
@@ -1153,7 +1153,7 @@ send_to_prune_tree(dns_qpdb_t *qpdb, dns_rbtnode_t *node,
  */
 static void
 cleanup_dead_nodes(dns_qpdb_t *qpdb, int bucketnum DNS__DB_FLARG) {
-       dns_rbtnode_t *node = NULL;
+       dns_qpdata_t *node = NULL;
        int count = 10; /* XXXJT: should be adjustable */
 
        node = ISC_LIST_HEAD(qpdb->deadnodes[bucketnum]);
@@ -1207,7 +1207,7 @@ cleanup_dead_nodes(dns_qpdb_t *qpdb, int bucketnum DNS__DB_FLARG) {
  * have been added to the list).
  */
 static void
-reactivate_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node,
+reactivate_node(dns_qpdb_t *qpdb, dns_qpdata_t *node,
                isc_rwlocktype_t tlocktype DNS__DB_FLARG) {
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
        isc_rwlock_t *nodelock = &qpdb->node_locks[node->locknum].lock;
@@ -1263,7 +1263,7 @@ reactivate_node(dns_qpdb_t *qpdb, dns_rbtnode_t *node,
  * will be immediately freed.
  */
 bool
-dns__qpdb_decref(dns_qpdb_t *qpdb, dns_rbtnode_t *node, uint32_t least_serial,
+dns__qpdb_decref(dns_qpdb_t *qpdb, dns_qpdata_t *node, uint32_t least_serial,
                 isc_rwlocktype_t *nlocktypep, isc_rwlocktype_t *tlocktypep,
                 bool tryupgrade, bool pruning DNS__DB_FLARG) {
        isc_result_t result;
@@ -1444,8 +1444,8 @@ static void
 prune_tree(void *arg) {
        qpdb_prune_t *prune = (qpdb_prune_t *)arg;
        dns_qpdb_t *qpdb = (dns_qpdb_t *)prune->db;
-       dns_rbtnode_t *node = prune->node;
-       dns_rbtnode_t *parent = NULL;
+       dns_qpdata_t *node = prune->node;
+       dns_qpdata_t *parent = NULL;
        unsigned int locknum = node->locknum;
        isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
@@ -1577,7 +1577,7 @@ dns__qpdb_setsecure(dns_db_t *db, dns_qpdb_version_t *version,
  */
 static void
 setnsec3parameters(dns_db_t *db, dns_qpdb_version_t *version) {
-       dns_rbtnode_t *node = NULL;
+       dns_qpdata_t *node = NULL;
        dns_rdata_nsec3param_t nsec3param;
        dns_rdata_t rdata = DNS_RDATA_INIT;
        isc_region_t region;
@@ -1699,7 +1699,7 @@ dns__qpdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp,
        dns_slabheaderlist_t resigned_list;
        qpdb_changed_t *changed = NULL, *next_changed = NULL;
        uint32_t serial, least_serial;
-       dns_rbtnode_t *rbtnode = NULL;
+       dns_qpdata_t *qpnode = NULL;
        dns_slabheader_t *header = NULL;
 
        REQUIRE(VALID_QPDB(qpdb));
@@ -1921,8 +1921,8 @@ dns__qpdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp,
                        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
 
                        next_changed = NEXT(changed, link);
-                       rbtnode = changed->node;
-                       lock = &qpdb->node_locks[rbtnode->locknum].lock;
+                       qpnode = changed->node;
+                       lock = &qpdb->node_locks[qpnode->locknum].lock;
 
                        NODE_WRLOCK(lock, &nlocktype);
                        /*
@@ -1932,14 +1932,14 @@ dns__qpdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp,
                        if (qpdb->loop == NULL) {
                                cleanup_dead_nodes(
                                        qpdb,
-                                       rbtnode->locknum DNS__DB_FLARG_PASS);
+                                       qpnode->locknum DNS__DB_FLARG_PASS);
                        }
 
                        if (rollback) {
-                               rollback_node(rbtnode, serial);
+                               rollback_node(qpnode, serial);
                        }
-                       dns__qpdb_decref(qpdb, rbtnode, least_serial,
-                                        &nlocktype, &tlocktype, true,
+                       dns__qpdb_decref(qpdb, qpnode, least_serial, &nlocktype,
+                                        &tlocktype, true,
                                         false DNS__DB_FILELINE);
 
                        NODE_UNLOCK(lock, &nlocktype);
@@ -1966,7 +1966,7 @@ isc_result_t
 dns__qpdb_findnodeintree(dns_qpdb_t *qpdb, dns_qp_t *tree,
                         const dns_name_t *name, bool create,
                         dns_dbnode_t **nodep DNS__DB_FLARG) {
-       dns_rbtnode_t *node = NULL;
+       dns_qpdata_t *node = NULL;
        dns_name_t nodename;
        isc_result_t result;
        isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
@@ -2033,7 +2033,7 @@ dns__qpdb_findnode(dns_db_t *db, const dns_name_t *name, bool create,
 }
 
 void
-dns__qpdb_bindrdataset(dns_qpdb_t *qpdb, dns_rbtnode_t *node,
+dns__qpdb_bindrdataset(dns_qpdb_t *qpdb, dns_qpdata_t *node,
                       dns_slabheader_t *header, isc_stdtime_t now,
                       isc_rwlocktype_t locktype,
                       dns_rdataset_t *rdataset DNS__DB_FLARG) {
@@ -2152,7 +2152,7 @@ dns__qpdb_attachnode(dns_db_t *db, dns_dbnode_t *source,
        REQUIRE(VALID_QPDB((dns_qpdb_t *)db));
        REQUIRE(targetp != NULL && *targetp == NULL);
 
-       dns_rbtnode_t *node = (dns_rbtnode_t *)source;
+       dns_qpdata_t *node = (dns_qpdata_t *)source;
        uint_fast32_t refs = isc_refcount_increment(&node->references);
 
 #if DNS_DB_NODETRACE
@@ -2168,7 +2168,7 @@ dns__qpdb_attachnode(dns_db_t *db, dns_dbnode_t *source,
 void
 dns__qpdb_detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) {
        dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
-       dns_rbtnode_t *node = NULL;
+       dns_qpdata_t *node = NULL;
        bool want_free = false;
        bool inactive = false;
        db_nodelock_t *nodelock = NULL;
@@ -2178,7 +2178,7 @@ dns__qpdb_detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) {
        REQUIRE(VALID_QPDB(qpdb));
        REQUIRE(targetp != NULL && *targetp != NULL);
 
-       node = (dns_rbtnode_t *)(*targetp);
+       node = (dns_qpdata_t *)(*targetp);
        nodelock = &qpdb->node_locks[node->locknum];
 
        NODE_RDLOCK(&nodelock->lock, &nlocktype);
@@ -2271,7 +2271,7 @@ dns__qpdb_allrdatasets(dns_db_t *db, dns_dbnode_t *node,
                       isc_stdtime_t now,
                       dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) {
        dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
-       dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
+       dns_qpdata_t *qpnode = (dns_qpdata_t *)node;
        dns_qpdb_version_t *rbtversion = version;
        qpdb_rdatasetiter_t *iterator = NULL;
        uint_fast32_t refs;
@@ -2305,7 +2305,7 @@ dns__qpdb_allrdatasets(dns_db_t *db, dns_dbnode_t *node,
        iterator->common.options = options;
        iterator->common.now = now;
 
-       refs = isc_refcount_increment(&rbtnode->references);
+       refs = isc_refcount_increment(&qpnode->references);
 #if DNS_DB_NODETRACE
        fprintf(stderr, "incr:node:%s:%s:%u:%p->references = %" PRIuFAST32 "\n",
                func, file, line, node, refs + 1);
@@ -2321,7 +2321,7 @@ dns__qpdb_allrdatasets(dns_db_t *db, dns_dbnode_t *node,
 }
 
 static bool
-cname_and_other_data(dns_rbtnode_t *node, uint32_t serial) {
+cname_and_other_data(dns_qpdata_t *node, uint32_t serial) {
        dns_slabheader_t *header = NULL, *header_next = NULL;
        bool cname = false, other_data = false;
        dns_rdatatype_t rdtype;
@@ -2436,7 +2436,7 @@ update_recordsandxfrsize(bool add, dns_qpdb_version_t *rbtversion,
 }
 
 isc_result_t
-dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode,
+dns__qpdb_add(dns_qpdb_t *qpdb, dns_qpdata_t *qpnode,
              const dns_name_t *nodename, dns_qpdb_version_t *rbtversion,
              dns_slabheader_t *newheader, unsigned int options, bool loading,
              dns_rdataset_t *addedrdataset, isc_stdtime_t now DNS__DB_FLARG) {
@@ -2499,7 +2499,7 @@ dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode,
                                 * only rdataset that can be found at this
                                 * node is the negative cache entry.
                                 */
-                               for (topheader = rbtnode->data;
+                               for (topheader = qpnode->data;
                                     topheader != NULL;
                                     topheader = topheader->next)
                                {
@@ -2511,7 +2511,7 @@ dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode,
                         * Otherwise look for any RRSIGs of the given
                         * type so they can be marked ancient later.
                         */
-                       for (topheader = rbtnode->data; topheader != NULL;
+                       for (topheader = qpnode->data; topheader != NULL;
                             topheader = topheader->next)
                        {
                                if (topheader->type == sigtype) {
@@ -2528,7 +2528,7 @@ dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode,
                         * check for an extant non-ancient NODATA ncache
                         * entry which covers the same type as the RRSIG.
                         */
-                       for (topheader = rbtnode->data; topheader != NULL;
+                       for (topheader = qpnode->data; topheader != NULL;
                             topheader = topheader->next)
                        {
                                if ((topheader->type == RDATATYPE_NCACHEANY) ||
@@ -2553,8 +2553,8 @@ dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode,
                                        dns_slabheader_destroy(&newheader);
                                        if (addedrdataset != NULL) {
                                                dns__qpdb_bindrdataset(
-                                                       qpdb, rbtnode,
-                                                       topheader, now,
+                                                       qpdb, qpnode, topheader,
+                                                       now,
                                                        isc_rwlocktype_write,
                                                        addedrdataset
                                                                DNS__DB_FLARG_PASS);
@@ -2573,7 +2573,7 @@ dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode,
                }
        }
 
-       for (topheader = rbtnode->data; topheader != NULL;
+       for (topheader = qpnode->data; topheader != NULL;
             topheader = topheader->next)
        {
                if (prio_type(topheader->type)) {
@@ -2621,7 +2621,7 @@ find_header:
                        dns_slabheader_destroy(&newheader);
                        if (addedrdataset != NULL) {
                                dns__qpdb_bindrdataset(
-                                       qpdb, rbtnode, header, now,
+                                       qpdb, qpnode, header, now,
                                        isc_rwlocktype_write,
                                        addedrdataset DNS__DB_FLARG_PASS);
                        }
@@ -2681,7 +2681,7 @@ find_header:
                                newheader = (dns_slabheader_t *)merged;
                                dns_slabheader_reset(newheader,
                                                     (dns_db_t *)qpdb,
-                                                    (dns_dbnode_t *)rbtnode);
+                                                    (dns_dbnode_t *)qpnode);
                                dns_slabheader_copycase(newheader, header);
                                if (loading && RESIGN(newheader) &&
                                    RESIGN(header) &&
@@ -2746,7 +2746,7 @@ find_header:
                        dns_slabheader_destroy(&newheader);
                        if (addedrdataset != NULL) {
                                dns__qpdb_bindrdataset(
-                                       qpdb, rbtnode, header, now,
+                                       qpdb, qpnode, header, now,
                                        isc_rwlocktype_write,
                                        addedrdataset DNS__DB_FLARG_PASS);
                        }
@@ -2811,7 +2811,7 @@ find_header:
                        dns_slabheader_destroy(&newheader);
                        if (addedrdataset != NULL) {
                                dns__qpdb_bindrdataset(
-                                       qpdb, rbtnode, header, now,
+                                       qpdb, qpnode, header, now,
                                        isc_rwlocktype_write,
                                        addedrdataset DNS__DB_FLARG_PASS);
                        }
@@ -2853,7 +2853,7 @@ find_header:
                        if (topheader_prev != NULL) {
                                topheader_prev->next = newheader;
                        } else {
-                               rbtnode->data = newheader;
+                               qpnode->data = newheader;
                        }
                        newheader->next = topheader->next;
                        if (rbtversion != NULL && !header_nx) {
@@ -2886,12 +2886,12 @@ find_header:
                        if (topheader_prev != NULL) {
                                topheader_prev->next = newheader;
                        } else {
-                               rbtnode->data = newheader;
+                               qpnode->data = newheader;
                        }
                        newheader->next = topheader->next;
                        newheader->down = topheader;
                        topheader->next = newheader;
-                       rbtnode->dirty = 1;
+                       qpnode->dirty = 1;
                        if (changed != NULL) {
                                changed->dirty = true;
                        }
@@ -2953,12 +2953,12 @@ find_header:
                        if (topheader_prev != NULL) {
                                topheader_prev->next = newheader;
                        } else {
-                               rbtnode->data = newheader;
+                               qpnode->data = newheader;
                        }
                        newheader->next = topheader->next;
                        newheader->down = topheader;
                        topheader->next = newheader;
-                       rbtnode->dirty = 1;
+                       qpnode->dirty = 1;
                        if (changed != NULL) {
                                changed->dirty = true;
                        }
@@ -2970,16 +2970,16 @@ find_header:
 
                        if (prio_type(newheader->type)) {
                                /* This is a priority type, prepend it */
-                               newheader->next = rbtnode->data;
-                               rbtnode->data = newheader;
+                               newheader->next = qpnode->data;
+                               qpnode->data = newheader;
                        } else if (prioheader != NULL) {
                                /* Append after the priority headers */
                                newheader->next = prioheader->next;
                                prioheader->next = newheader;
                        } else {
                                /* There were no priority headers */
-                               newheader->next = rbtnode->data;
-                               rbtnode->data = newheader;
+                               newheader->next = qpnode->data;
+                               qpnode->data = newheader;
                        }
                }
        }
@@ -2993,13 +2993,13 @@ find_header:
         * Check if the node now contains CNAME and other data.
         */
        if (rbtversion != NULL &&
-           cname_and_other_data(rbtnode, rbtversion->serial))
+           cname_and_other_data(qpnode, rbtversion->serial))
        {
                return (DNS_R_CNAMEANDOTHER);
        }
 
        if (addedrdataset != NULL) {
-               dns__qpdb_bindrdataset(qpdb, rbtnode, newheader, now,
+               dns__qpdb_bindrdataset(qpdb, qpnode, newheader, now,
                                       isc_rwlocktype_write,
                                       addedrdataset DNS__DB_FLARG_PASS);
        }
@@ -3008,7 +3008,7 @@ find_header:
 }
 
 static bool
-delegating_type(dns_qpdb_t *qpdb, dns_rbtnode_t *node, dns_typepair_t type) {
+delegating_type(dns_qpdb_t *qpdb, dns_qpdata_t *node, dns_typepair_t type) {
        if (IS_CACHE(qpdb)) {
                if (type == dns_rdatatype_dname) {
                        return (true);
@@ -3112,7 +3112,7 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node,
                      dns_rdataset_t *rdataset, unsigned int options,
                      dns_rdataset_t *addedrdataset DNS__DB_FLARG) {
        dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
-       dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
+       dns_qpdata_t *qpnode = (dns_qpdata_t *)node;
        dns_qpdb_version_t *rbtversion = version;
        isc_region_t region;
        dns_slabheader_t *newheader = NULL;
@@ -3138,10 +3138,10 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node,
                        return (DNS_R_NOTZONETOP);
                }
                TREE_RDLOCK(&qpdb->tree_lock, &tlocktype);
-               REQUIRE(((rbtnode->nsec == DNS_DB_NSEC_NSEC3 &&
+               REQUIRE(((qpnode->nsec == DNS_DB_NSEC_NSEC3 &&
                          (rdataset->type == dns_rdatatype_nsec3 ||
                           rdataset->covers == dns_rdatatype_nsec3)) ||
-                        (rbtnode->nsec != DNS_DB_NSEC_NSEC3 &&
+                        (qpnode->nsec != DNS_DB_NSEC_NSEC3 &&
                          rdataset->type != dns_rdatatype_nsec3 &&
                          rdataset->covers != dns_rdatatype_nsec3)));
                TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
@@ -3170,7 +3170,7 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node,
                .type = DNS_TYPEPAIR_VALUE(rdataset->type, rdataset->covers),
                .trust = rdataset->trust,
                .last_used = now,
-               .node = rbtnode,
+               .node = qpnode,
        };
 
        dns_slabheader_reset(newheader, db, node);
@@ -3234,7 +3234,7 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node,
         * just DNAME for the cache), then we need to set the callback bit
         * on the node.
         */
-       if (delegating_type(qpdb, rbtnode, rdataset->type)) {
+       if (delegating_type(qpdb, qpnode, rdataset->type)) {
                delegating = true;
        } else {
                delegating = false;
@@ -3244,7 +3244,7 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node,
         * Add to the auxiliary NSEC tree if we're adding an NSEC record.
         */
        TREE_RDLOCK(&qpdb->tree_lock, &tlocktype);
-       if (rbtnode->nsec != DNS_DB_NSEC_HAS_NSEC &&
+       if (qpnode->nsec != DNS_DB_NSEC_HAS_NSEC &&
            rdataset->type == dns_rdatatype_nsec)
        {
                newnsec = true;
@@ -3272,7 +3272,7 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node,
                                     &tlocktype DNS__DB_FLARG_PASS);
        }
 
-       NODE_WRLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+       NODE_WRLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
 
        if (qpdb->rrsetstats != NULL) {
                DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_STATCOUNT);
@@ -3284,10 +3284,10 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node,
        if (IS_CACHE(qpdb)) {
                if (tlocktype == isc_rwlocktype_write) {
                        cleanup_dead_nodes(qpdb,
-                                          rbtnode->locknum DNS__DB_FLARG_PASS);
+                                          qpnode->locknum DNS__DB_FLARG_PASS);
                }
 
-               expire_ttl_headers(qpdb, rbtnode->locknum, &tlocktype, now,
+               expire_ttl_headers(qpdb, qpnode->locknum, &tlocktype, now,
                                   cache_is_overmem DNS__DB_FLARG_PASS);
 
                /*
@@ -3304,7 +3304,7 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node,
 
        result = ISC_R_SUCCESS;
        if (newnsec) {
-               dns_rbtnode_t *nsecnode = NULL;
+               dns_qpdata_t *nsecnode = NULL;
 
                result = dns_qp_getname(qpdb->nsec, name, (void **)&nsecnode,
                                        NULL);
@@ -3317,19 +3317,19 @@ dns__qpdb_addrdataset(dns_db_t *db, dns_dbnode_t *node,
                        result = dns_qp_insert(qpdb->nsec, nsecnode, 0);
                        INSIST(result == ISC_R_SUCCESS);
                }
-               rbtnode->nsec = DNS_DB_NSEC_HAS_NSEC;
+               qpnode->nsec = DNS_DB_NSEC_HAS_NSEC;
        }
 
        if (result == ISC_R_SUCCESS) {
-               result = dns__qpdb_add(qpdb, rbtnode, name, rbtversion,
+               result = dns__qpdb_add(qpdb, qpnode, name, rbtversion,
                                       newheader, options, false, addedrdataset,
                                       now DNS__DB_FLARG_PASS);
        }
        if (result == ISC_R_SUCCESS && delegating) {
-               rbtnode->find_callback = 1;
+               qpnode->find_callback = 1;
        }
 
-       NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+       NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
 
        if (tlocktype != isc_rwlocktype_none) {
                TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
@@ -3353,7 +3353,7 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node,
                           unsigned int options,
                           dns_rdataset_t *newrdataset DNS__DB_FLARG) {
        dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
-       dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
+       dns_qpdata_t *qpnode = (dns_qpdata_t *)node;
        dns_qpdb_version_t *rbtversion = version;
        dns_fixedname_t fname;
        dns_name_t *nodename = dns_fixedname_initname(&fname);
@@ -3371,10 +3371,10 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node,
 
        if (!IS_CACHE(qpdb)) {
                TREE_RDLOCK(&qpdb->tree_lock, &tlocktype);
-               REQUIRE(((rbtnode->nsec == DNS_DB_NSEC_NSEC3 &&
+               REQUIRE(((qpnode->nsec == DNS_DB_NSEC_NSEC3 &&
                          (rdataset->type == dns_rdatatype_nsec3 ||
                           rdataset->covers == dns_rdatatype_nsec3)) ||
-                        (rbtnode->nsec != DNS_DB_NSEC_NSEC3 &&
+                        (qpnode->nsec != DNS_DB_NSEC_NSEC3 &&
                          rdataset->type != dns_rdatatype_nsec3 &&
                          rdataset->covers != dns_rdatatype_nsec3)));
                TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
@@ -3400,7 +3400,7 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node,
        atomic_init(&newheader->count,
                    atomic_fetch_add_relaxed(&init_count, 1));
        newheader->last_used = 0;
-       newheader->node = rbtnode;
+       newheader->node = qpnode;
        newheader->db = (dns_db_t *)qpdb;
        if ((rdataset->attributes & DNS_RDATASETATTR_RESIGN) != 0) {
                DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_RESIGN);
@@ -3413,17 +3413,17 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node,
                newheader->resign_lsb = 0;
        }
 
-       NODE_WRLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+       NODE_WRLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
 
        changed = add_changed(newheader, rbtversion DNS__DB_FLARG_PASS);
        if (changed == NULL) {
                dns_slabheader_destroy(&newheader);
-               NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock,
+               NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock,
                            &nlocktype);
                return (ISC_R_NOMEMORY);
        }
 
-       for (topheader = rbtnode->data; topheader != NULL;
+       for (topheader = qpnode->data; topheader != NULL;
             topheader = topheader->next)
        {
                if (topheader->type == newheader->type) {
@@ -3469,7 +3469,7 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node,
                                        newheader, DNS_SLABHEADERATTR_RESIGN);
                                newheader->resign = header->resign;
                                newheader->resign_lsb = header->resign_lsb;
-                               dns__qpzone_resigninsert(qpdb, rbtnode->locknum,
+                               dns__qpzone_resigninsert(qpdb, qpnode->locknum,
                                                         newheader);
                        }
                        /*
@@ -3492,7 +3492,7 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node,
                         */
                        dns_slabheader_destroy(&newheader);
                        newheader = dns_slabheader_new((dns_db_t *)qpdb,
-                                                      (dns_dbnode_t *)rbtnode);
+                                                      (dns_dbnode_t *)qpnode);
                        dns__qpdb_setttl(newheader, 0);
                        newheader->type = topheader->type;
                        atomic_init(&newheader->attributes,
@@ -3513,12 +3513,12 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node,
                if (topheader_prev != NULL) {
                        topheader_prev->next = newheader;
                } else {
-                       rbtnode->data = newheader;
+                       qpnode->data = newheader;
                }
                newheader->next = topheader->next;
                newheader->down = topheader;
                topheader->next = newheader;
-               rbtnode->dirty = 1;
+               qpnode->dirty = 1;
                changed->dirty = true;
                dns__qpzone_resigndelete(qpdb, rbtversion,
                                         header DNS__DB_FLARG_PASS);
@@ -3536,7 +3536,7 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node,
        }
 
        if (result == ISC_R_SUCCESS && newrdataset != NULL) {
-               dns__qpdb_bindrdataset(qpdb, rbtnode, newheader, 0,
+               dns__qpdb_bindrdataset(qpdb, qpnode, newheader, 0,
                                       isc_rwlocktype_write,
                                       newrdataset DNS__DB_FLARG_PASS);
        }
@@ -3544,13 +3544,13 @@ dns__qpdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node,
        if (result == DNS_R_NXRRSET && newrdataset != NULL &&
            (options & DNS_DBSUB_WANTOLD) != 0)
        {
-               dns__qpdb_bindrdataset(qpdb, rbtnode, header, 0,
+               dns__qpdb_bindrdataset(qpdb, qpnode, header, 0,
                                       isc_rwlocktype_write,
                                       newrdataset DNS__DB_FLARG_PASS);
        }
 
 unlock:
-       NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+       NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
 
        /*
         * Update the zone's secure status.  If version is non-NULL
@@ -3571,7 +3571,7 @@ dns__qpdb_deleterdataset(dns_db_t *db, dns_dbnode_t *node,
                         dns_dbversion_t *version, dns_rdatatype_t type,
                         dns_rdatatype_t covers DNS__DB_FLARG) {
        dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
-       dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
+       dns_qpdata_t *qpnode = (dns_qpdata_t *)node;
        dns_qpdb_version_t *rbtversion = version;
        dns_fixedname_t fname;
        dns_name_t *nodename = dns_fixedname_initname(&fname);
@@ -3599,11 +3599,11 @@ dns__qpdb_deleterdataset(dns_db_t *db, dns_dbnode_t *node,
 
        dns__qpdb_nodefullname(db, node, nodename);
 
-       NODE_WRLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
-       result = dns__qpdb_add(qpdb, rbtnode, nodename, rbtversion, newheader,
+       NODE_WRLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
+       result = dns__qpdb_add(qpdb, qpnode, nodename, rbtversion, newheader,
                               DNS_DBADD_FORCE, false, NULL,
                               0 DNS__DB_FLARG_PASS);
-       NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+       NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
 
        /*
         * Update the zone's secure status.  If version is non-NULL
@@ -3665,14 +3665,14 @@ dns__qpdb_setloop(dns_db_t *db, isc_loop_t *loop) {
 isc_result_t
 dns__qpdb_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
        dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
-       dns_rbtnode_t *onode = NULL;
+       dns_qpdata_t *onode = NULL;
        isc_result_t result = ISC_R_SUCCESS;
 
        REQUIRE(VALID_QPDB(qpdb));
        REQUIRE(nodep != NULL && *nodep == NULL);
 
        /* Note that the access to origin_node doesn't require a DB lock */
-       onode = (dns_rbtnode_t *)qpdb->origin_node;
+       onode = (dns_qpdata_t *)qpdb->origin_node;
        if (onode != NULL) {
                dns__qpdb_newref(qpdb, onode,
                                 isc_rwlocktype_none DNS__DB_FLARG_PASS);
@@ -3688,23 +3688,23 @@ dns__qpdb_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
 void
 dns__qpdb_locknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type) {
        dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
-       dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
+       dns_qpdata_t *qpnode = (dns_qpdata_t *)node;
 
-       RWLOCK(&qpdb->node_locks[rbtnode->locknum].lock, type);
+       RWLOCK(&qpdb->node_locks[qpnode->locknum].lock, type);
 }
 
 void
 dns__qpdb_unlocknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type) {
        dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
-       dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
+       dns_qpdata_t *qpnode = (dns_qpdata_t *)node;
 
-       RWUNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, type);
+       RWUNLOCK(&qpdb->node_locks[qpnode->locknum].lock, type);
 }
 
 isc_result_t
 dns__qpdb_nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name) {
        dns_qpdb_t *qpdb = (dns_qpdb_t *)db;
-       dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
+       dns_qpdata_t *qpnode = (dns_qpdata_t *)node;
        isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
 
        REQUIRE(VALID_QPDB(qpdb));
@@ -3712,7 +3712,7 @@ dns__qpdb_nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name) {
        REQUIRE(name != NULL);
 
        TREE_RDLOCK(&qpdb->tree_lock, &tlocktype);
-       dns_name_copy(rbtnode->name, name);
+       dns_name_copy(qpnode->name, name);
        TREE_UNLOCK(&qpdb->tree_lock, &tlocktype);
 
        return (ISC_R_SUCCESS);
@@ -3810,7 +3810,7 @@ dns__qpdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
         * Create deadnode lists.
         */
        qpdb->deadnodes = isc_mem_get(mctx, qpdb->node_lock_count *
-                                                   sizeof(dns_rbtnodelist_t));
+                                                   sizeof(dns_qpdatalist_t));
        for (i = 0; i < (int)qpdb->node_lock_count; i++) {
                ISC_LIST_INIT(qpdb->deadnodes[i]);
        }
@@ -3964,15 +3964,15 @@ static isc_result_t
 rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
        qpdb_rdatasetiter_t *rbtiterator = (qpdb_rdatasetiter_t *)iterator;
        dns_qpdb_t *qpdb = (dns_qpdb_t *)(rbtiterator->common.db);
-       dns_rbtnode_t *rbtnode = rbtiterator->common.node;
+       dns_qpdata_t *qpnode = rbtiterator->common.node;
        dns_qpdb_version_t *rbtversion = rbtiterator->common.version;
        dns_slabheader_t *header = NULL, *top_next = NULL;
        uint32_t serial = IS_CACHE(qpdb) ? 1 : rbtversion->serial;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
 
-       NODE_RDLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+       NODE_RDLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
 
-       for (header = rbtnode->data; header != NULL; header = top_next) {
+       for (header = qpnode->data; header != NULL; header = top_next) {
                top_next = header->next;
                do {
                        if (EXPIREDOK(rbtiterator)) {
@@ -3996,7 +3996,7 @@ rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
                }
        }
 
-       NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+       NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
 
        rbtiterator->current = header;
 
@@ -4011,7 +4011,7 @@ static isc_result_t
 rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
        qpdb_rdatasetiter_t *rbtiterator = (qpdb_rdatasetiter_t *)iterator;
        dns_qpdb_t *qpdb = (dns_qpdb_t *)(rbtiterator->common.db);
-       dns_rbtnode_t *rbtnode = rbtiterator->common.node;
+       dns_qpdata_t *qpnode = rbtiterator->common.node;
        dns_qpdb_version_t *rbtversion = rbtiterator->common.version;
        dns_slabheader_t *header = NULL, *top_next = NULL;
        uint32_t serial = IS_CACHE(qpdb) ? 1 : rbtversion->serial;
@@ -4025,7 +4025,7 @@ rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
                return (ISC_R_NOMORE);
        }
 
-       NODE_RDLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+       NODE_RDLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
 
        type = header->type;
        rdtype = DNS_TYPEPAIR_TYPE(header->type);
@@ -4088,7 +4088,7 @@ rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
                }
        }
 
-       NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+       NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
 
        rbtiterator->current = header;
 
@@ -4104,20 +4104,20 @@ rdatasetiter_current(dns_rdatasetiter_t *iterator,
                     dns_rdataset_t *rdataset DNS__DB_FLARG) {
        qpdb_rdatasetiter_t *rbtiterator = (qpdb_rdatasetiter_t *)iterator;
        dns_qpdb_t *qpdb = (dns_qpdb_t *)(rbtiterator->common.db);
-       dns_rbtnode_t *rbtnode = rbtiterator->common.node;
+       dns_qpdata_t *qpnode = rbtiterator->common.node;
        dns_slabheader_t *header = NULL;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
 
        header = rbtiterator->current;
        REQUIRE(header != NULL);
 
-       NODE_RDLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+       NODE_RDLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
 
-       dns__qpdb_bindrdataset(qpdb, rbtnode, header, rbtiterator->common.now,
+       dns__qpdb_bindrdataset(qpdb, qpnode, header, rbtiterator->common.now,
                               isc_rwlocktype_read,
                               rdataset DNS__DB_FLARG_PASS);
 
-       NODE_UNLOCK(&qpdb->node_locks[rbtnode->locknum].lock, &nlocktype);
+       NODE_UNLOCK(&qpdb->node_locks[qpnode->locknum].lock, &nlocktype);
 }
 
 /*
@@ -4127,7 +4127,7 @@ rdatasetiter_current(dns_rdatasetiter_t *iterator,
 static void
 reference_iter_node(qpdb_dbiterator_t *qpdbiter DNS__DB_FLARG) {
        dns_qpdb_t *qpdb = (dns_qpdb_t *)qpdbiter->common.db;
-       dns_rbtnode_t *node = qpdbiter->node;
+       dns_qpdata_t *node = qpdbiter->node;
 
        if (node == NULL) {
                return;
@@ -4140,7 +4140,7 @@ reference_iter_node(qpdb_dbiterator_t *qpdbiter DNS__DB_FLARG) {
 static void
 dereference_iter_node(qpdb_dbiterator_t *qpdbiter DNS__DB_FLARG) {
        dns_qpdb_t *qpdb = (dns_qpdb_t *)qpdbiter->common.db;
-       dns_rbtnode_t *node = qpdbiter->node;
+       dns_qpdata_t *node = qpdbiter->node;
        isc_rwlock_t *lock = NULL;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
        isc_rwlocktype_t tlocktype = qpdbiter->tree_locked;
@@ -4394,7 +4394,7 @@ dbiterator_seek(dns_dbiterator_t *iterator,
                                       qpdbiter->current, NULL,
                                       (void **)&qpdbiter->node, NULL);
                if (result == DNS_R_PARTIALMATCH) {
-                       dns_rbtnode_t *node = NULL;
+                       dns_qpdata_t *node = NULL;
                        tresult = dns_qp_lookup(qpdb->nsec3, name, NULL,
                                                &qpdbiter->nsec3iter, NULL,
                                                (void **)&node, NULL);
@@ -4544,7 +4544,7 @@ dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep,
                   dns_name_t *name DNS__DB_FLARG) {
        dns_qpdb_t *qpdb = (dns_qpdb_t *)iterator->db;
        qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
-       dns_rbtnode_t *node = qpdbiter->node;
+       dns_qpdata_t *node = qpdbiter->node;
        isc_result_t result = ISC_R_SUCCESS;
 
        REQUIRE(qpdbiter->result == ISC_R_SUCCESS);

diff --git a/lib/dns/qpdb_p.h b/lib/dns/qpdb_p.h
index 4d87dd440a1541d19c686f061451ef10bda35679..ab0d589f24531373f78d940aa357070bf9b59099 100644 (file)
--- a/lib/dns/qpdb_p.h
+++ b/lib/dns/qpdb_p.h
@@ -30,7 +30,7 @@
 #define VALID_QPDB(qpdb) \
        ((qpdb) != NULL && (qpdb)->common.impmagic == QPDB_MAGIC)
 
-#define QPDB_HEADERNODE(h) ((dns_rbtnode_t *)((h)->node))
+#define QPDB_HEADERNODE(h) ((dns_qpdata_t *)((h)->node))
 
 /*
  * Allow clients with a virtual time of up to 5 minutes in the past to see
@@ -91,13 +91,13 @@ struct dns_qpdata {
         * be reached from a child that was found by a hash lookup.
         */
        unsigned int hashval;
-       dns_rbtnode_t *uppernode;
-       dns_rbtnode_t *hashnext;
+       dns_qpdata_t *uppernode;
+       dns_qpdata_t *hashnext;
 
-       dns_rbtnode_t *parent;
-       dns_rbtnode_t *left;
-       dns_rbtnode_t *right;
-       dns_rbtnode_t *down;
+       dns_qpdata_t *parent;
+       dns_qpdata_t *left;
+       dns_qpdata_t *right;
+       dns_qpdata_t *down;
 
        dns_fixedname_t fn;
        dns_name_t *name;
@@ -108,7 +108,7 @@ struct dns_qpdata {
         * have no data any longer, but we cannot unlink at that exact moment
         * because we did not or could not obtain a write lock on the tree.
         */
-       ISC_LINK(dns_qpdbnode_t) deadlink;
+       ISC_LINK(dns_qpdata_t) deadlink;
 
        /*@{*/
        /*!
@@ -139,7 +139,7 @@ struct dns_qpdata {
 };
 
 typedef struct qpdb_changed {
-       dns_rbtnode_t *node;
+       dns_qpdata_t *node;
        bool dirty;
        ISC_LINK(struct qpdb_changed) link;
 } qpdb_changed_t;
@@ -193,8 +193,8 @@ struct dns_qpdb {
        /* Locks for individual tree nodes */
        unsigned int node_lock_count;
        db_nodelock_t *node_locks;
-       dns_rbtnode_t *origin_node;
-       dns_rbtnode_t *nsec3_origin_node;
+       dns_qpdata_t *origin_node;
+       dns_qpdata_t *nsec3_origin_node;
        dns_stats_t *rrsetstats;     /* cache DB only */
        isc_stats_t *cachestats;     /* cache DB only */
        isc_stats_t *gluecachestats; /* zone DB only */
@@ -240,7 +240,7 @@ struct dns_qpdb {
         * Temporary storage for stale cache nodes and dynamically deleted
         * nodes that await being cleaned up.
         */
-       dns_rbtnodelist_t *deadnodes;
+       dns_qpdatalist_t *deadnodes;
 
        /*
         * Heaps.  These are used for TTL based expiry in a cache,
@@ -274,7 +274,7 @@ typedef struct {
        bool copy_name;
        bool need_cleanup;
        bool wild;
-       dns_rbtnode_t *zonecut;
+       dns_qpdata_t *zonecut;
        dns_slabheader_t *zonecut_header;
        dns_slabheader_t *zonecut_sigheader;
        dns_fixedname_t zonecut_name;
@@ -294,7 +294,7 @@ typedef struct {
  */
 typedef struct {
        dns_db_t *db;
-       dns_rbtnode_t *node;
+       dns_qpdata_t *node;
 } qpdb_prune_t;
 
 extern dns_dbmethods_t dns__qpdb_zonemethods;
@@ -448,7 +448,7 @@ dns__qpdb_unlocknode(dns_db_t *db, dns_dbnode_t *node, isc_rwlocktype_t type);
  * rbt-cachedb.c:
  */
 void
-dns__qpdb_bindrdataset(dns_qpdb_t *qpdb, dns_rbtnode_t *node,
+dns__qpdb_bindrdataset(dns_qpdb_t *qpdb, dns_qpdata_t *node,
                       dns_slabheader_t *header, isc_stdtime_t now,
                       isc_rwlocktype_t locktype,
                       dns_rdataset_t *rdataset DNS__DB_FLARG);
@@ -460,7 +460,7 @@ void
 dns__qpdb_freeglue(dns_glue_t *glue_list);
 
 void
-dns__qpdb_newref(dns_qpdb_t *qpdb, dns_rbtnode_t *node,
+dns__qpdb_newref(dns_qpdb_t *qpdb, dns_qpdata_t *node,
                 isc_rwlocktype_t locktype DNS__DB_FLARG);
 /*%<
  * Increment the reference counter to a node in an RBT database.
@@ -471,7 +471,7 @@ dns__qpdb_newref(dns_qpdb_t *qpdb, dns_rbtnode_t *node,
  */
 
 bool
-dns__qpdb_decref(dns_qpdb_t *qpdb, dns_rbtnode_t *node, uint32_t least_serial,
+dns__qpdb_decref(dns_qpdb_t *qpdb, dns_qpdata_t *node, uint32_t least_serial,
                 isc_rwlocktype_t *nlocktypep, isc_rwlocktype_t *tlocktypep,
                 bool tryupgrade, bool pruning DNS__DB_FLARG);
 /*%<
@@ -484,7 +484,7 @@ dns__qpdb_decref(dns_qpdb_t *qpdb, dns_rbtnode_t *node, uint32_t least_serial,
  */
 
 isc_result_t
-dns__qpdb_add(dns_qpdb_t *qpdb, dns_rbtnode_t *rbtnode,
+dns__qpdb_add(dns_qpdb_t *qpdb, dns_qpdata_t *qpnode,
              const dns_name_t *nodename, dns_qpdb_version_t *rbtversion,
              dns_slabheader_t *newheader, unsigned int options, bool loading,
              dns_rdataset_t *addedrdataset, isc_stdtime_t now DNS__DB_FLARG);

diff --git a/tests/dns/qpdb_test.c b/tests/dns/qpdb_test.c
index 2ced0f16dfccb07014b7660a6640f92545792c99..d02c3d0c96f674a9daea3710241af0b9b4351f17 100644 (file)
--- a/tests/dns/qpdb_test.c
+++ b/tests/dns/qpdb_test.c
@@ -102,7 +102,7 @@ ownercase_test_one(const char *str1, const char *str2) {
                .common.mctx = mctx,
                .node_locks = node_locks,
        };
-       dns_rbtnode_t rbtnode = { .locknum = 0 };
+       dns_qpdata_t rbtnode = { .locknum = 0 };
        dns_slabheader_t header = {
                .node = &rbtnode,
                .db = (dns_db_t *)&qpdb,
@@ -169,7 +169,7 @@ ISC_RUN_TEST_IMPL(setownercase) {
                .common.mctx = mctx,
                .node_locks = node_locks,
        };
-       dns_rbtnode_t rbtnode = { .locknum = 0 };
+       dns_qpdata_t rbtnode = { .locknum = 0 };
        dns_slabheader_t header = {
                .node = &rbtnode,
                .db = (dns_db_t *)&qpdb,