fix more ambiguous struct names

there were some structure names used in qpcache.c and qpzone.c that
were too similar to each other and could be confusing when debugging.
they have been changed as follows:

in qcache.c:
- changed_t was unused, and has been removed
- search_t -> qpc_search_t
- qpdb_rdatasetiter_t -> qpc_rditer_t
- qpdb_dbiterator_t -> qpc_dbiter_t

in qpzone.c:
- qpdb_changed_t -> qpz_changed_t
- qpdb_changedlist_t -> qpz_changedlist_t
- qpdb_version_t -> qpz_version_t
- qpdb_versionlist_t -> qpz_versionlist_t
- qpdb_search_t -> qpz_search_t
- qpdb_load_t -> qpz_search_t

diff --git a/lib/dns/qpcache.c b/lib/dns/qpcache.c
index 879496a6d3f926015d37ef0bd53101b93a9f54bb..2c3eaed3988c101936e4c7062817026e983b7429 100644 (file)
--- a/lib/dns/qpcache.c
+++ b/lib/dns/qpcache.c
@@ -218,15 +218,7 @@ struct qpcnode {
        ISC_LINK(qpcnode_t) deadlink;
 };
 
-typedef struct changed {
-       qpcnode_t *node;
-       bool dirty;
-       ISC_LINK(struct changed) link;
-} changed_t;
-
 typedef struct qpcache qpcache_t;
-typedef ISC_LIST(changed_t) changedlist_t;
-
 struct qpcache {
        /* Unlocked. */
        dns_db_t common;
@@ -303,7 +295,7 @@ typedef struct {
        dns_slabheader_t *zonecut_header;
        dns_slabheader_t *zonecut_sigheader;
        isc_stdtime_t now;
-} search_t;
+} qpc_search_t;
 
 #ifdef DNS_DB_NODETRACE
 #define qpcnode_ref(ptr)   qpcnode__ref(ptr, __func__, __FILE__, __LINE__)
@@ -375,10 +367,10 @@ static dns_rdatasetitermethods_t rdatasetiter_methods = {
        rdatasetiter_current
 };
 
-typedef struct qpdb_rdatasetiter {
+typedef struct qpc_rditer {
        dns_rdatasetiter_t common;
        dns_slabheader_t *current;
-} qpdb_rdatasetiter_t;
+} qpc_rditer_t;
 
 static void
 dbiterator_destroy(dns_dbiterator_t **iteratorp DNS__DB_FLARG);
@@ -415,7 +407,7 @@ static dns_dbiteratormethods_t dbiterator_methods = {
  * to have a separate tree for NSEC3 records, and to copy in the more complex
  * iterator implementation from qpzone.c.
  */
-typedef struct qpdb_dbiterator {
+typedef struct qpc_dbit {
        dns_dbiterator_t common;
        bool paused;
        isc_rwlocktype_t tree_locked;
@@ -424,7 +416,7 @@ typedef struct qpdb_dbiterator {
        dns_name_t *name;
        dns_qpiter_t iter;
        qpcnode_t *node;
-} qpdb_dbiterator_t;
+} qpc_dbit_t;
 
 static void
 free_qpdb(qpcache_t *qpdb, bool log);
@@ -1118,7 +1110,7 @@ bindrdataset(qpcache_t *qpdb, qpcnode_t *node, dns_slabheader_t *header,
 }
 
 static isc_result_t
-setup_delegation(search_t *search, dns_dbnode_t **nodep,
+setup_delegation(qpc_search_t *search, dns_dbnode_t **nodep,
                 dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
                 isc_rwlocktype_t tlocktype DNS__DB_FLARG) {
        dns_typepair_t type;
@@ -1170,7 +1162,7 @@ setup_delegation(search_t *search, dns_dbnode_t **nodep,
 static bool
 check_stale_header(qpcnode_t *node, dns_slabheader_t *header,
                   isc_rwlocktype_t *nlocktypep, isc_rwlock_t *lock,
-                  search_t *search, dns_slabheader_t **header_prev) {
+                  qpc_search_t *search, dns_slabheader_t **header_prev) {
        if (!ACTIVE(header, search->now)) {
                dns_ttl_t stale = header->ttl + STALE_TTL(header, search->qpdb);
                /*
@@ -1275,7 +1267,7 @@ check_stale_header(qpcnode_t *node, dns_slabheader_t *header,
 
 static isc_result_t
 check_zonecut(qpcnode_t *node, void *arg DNS__DB_FLARG) {
-       search_t *search = arg;
+       qpc_search_t *search = arg;
        dns_slabheader_t *header = NULL;
        dns_slabheader_t *header_prev = NULL, *header_next = NULL;
        dns_slabheader_t *dname_header = NULL, *sigdname_header = NULL;
@@ -1337,8 +1329,9 @@ check_zonecut(qpcnode_t *node, void *arg DNS__DB_FLARG) {
 }
 
 static isc_result_t
-find_deepest_zonecut(search_t *search, qpcnode_t *node, dns_dbnode_t **nodep,
-                    dns_name_t *foundname, dns_rdataset_t *rdataset,
+find_deepest_zonecut(qpc_search_t *search, qpcnode_t *node,
+                    dns_dbnode_t **nodep, dns_name_t *foundname,
+                    dns_rdataset_t *rdataset,
                     dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
        isc_result_t result = ISC_R_NOTFOUND;
        qpcache_t *qpdb = NULL;
@@ -1457,7 +1450,7 @@ find_deepest_zonecut(search_t *search, qpcnode_t *node, dns_dbnode_t **nodep,
  * Otherwise, return ISC_R_NOTFOUND.
  */
 static isc_result_t
-find_coveringnsec(search_t *search, const dns_name_t *name,
+find_coveringnsec(qpc_search_t *search, const dns_name_t *name,
                  dns_dbnode_t **nodep, isc_stdtime_t now,
                  dns_name_t *foundname, dns_rdataset_t *rdataset,
                  dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
@@ -1562,7 +1555,7 @@ find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
      dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
        qpcnode_t *node = NULL;
        isc_result_t result;
-       search_t search;
+       qpc_search_t search;
        bool cname_ok = true;
        bool found_noqname = false;
        bool all_negative = true;
@@ -1587,7 +1580,7 @@ find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
                now = isc_stdtime_now();
        }
 
-       search = (search_t){
+       search = (qpc_search_t){
                .qpdb = (qpcache_t *)db,
                .options = options,
                .now = now,
@@ -2008,7 +2001,7 @@ findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options,
        qpcnode_t *node = NULL;
        isc_rwlock_t *lock = NULL;
        isc_result_t result;
-       search_t search;
+       qpc_search_t search;
        dns_slabheader_t *header = NULL;
        dns_slabheader_t *header_prev = NULL, *header_next = NULL;
        dns_slabheader_t *found = NULL, *foundsig = NULL;
@@ -2022,7 +2015,7 @@ findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options,
                now = isc_stdtime_now();
        }
 
-       search = (search_t){
+       search = (qpc_search_t){
                .qpdb = (qpcache_t *)db,
                .options = options,
                .now = now,
@@ -2894,12 +2887,12 @@ static isc_result_t
 createiterator(dns_db_t *db, unsigned int options ISC_ATTR_UNUSED,
               dns_dbiterator_t **iteratorp) {
        qpcache_t *qpdb = (qpcache_t *)db;
-       qpdb_dbiterator_t *qpdbiter = NULL;
+       qpc_dbit_t *qpdbiter = NULL;
 
        REQUIRE(VALID_QPDB(qpdb));
 
        qpdbiter = isc_mem_get(qpdb->common.mctx, sizeof(*qpdbiter));
-       *qpdbiter = (qpdb_dbiterator_t){
+       *qpdbiter = (qpc_dbit_t){
                .common.methods = &dbiterator_methods,
                .common.magic = DNS_DBITERATOR_MAGIC,
                .paused = true,
@@ -2919,7 +2912,7 @@ allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
             dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) {
        qpcache_t *qpdb = (qpcache_t *)db;
        qpcnode_t *qpnode = (qpcnode_t *)node;
-       qpdb_rdatasetiter_t *iterator = NULL;
+       qpc_rditer_t *iterator = NULL;
 
        REQUIRE(VALID_QPDB(qpdb));
 
@@ -3834,9 +3827,9 @@ dns__qpcache_create(isc_mem_t *mctx, const dns_name_t *origin,
 
 static void
 rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) {
-       qpdb_rdatasetiter_t *rbtiterator = NULL;
+       qpc_rditer_t *rbtiterator = NULL;
 
-       rbtiterator = (qpdb_rdatasetiter_t *)(*iteratorp);
+       rbtiterator = (qpc_rditer_t *)(*iteratorp);
 
        dns__db_detachnode(rbtiterator->common.db,
                           &rbtiterator->common.node DNS__DB_FLARG_PASS);
@@ -3847,7 +3840,7 @@ rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) {
 }
 
 static bool
-iterator_active(qpcache_t *qpdb, qpdb_rdatasetiter_t *rbtiterator,
+iterator_active(qpcache_t *qpdb, qpc_rditer_t *rbtiterator,
                dns_slabheader_t *header) {
        dns_ttl_t stale_ttl = header->ttl + STALE_TTL(header, qpdb);
 
@@ -3877,7 +3870,7 @@ iterator_active(qpcache_t *qpdb, qpdb_rdatasetiter_t *rbtiterator,
 
 static isc_result_t
 rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
-       qpdb_rdatasetiter_t *rbtiterator = (qpdb_rdatasetiter_t *)iterator;
+       qpc_rditer_t *rbtiterator = (qpc_rditer_t *)iterator;
        qpcache_t *qpdb = (qpcache_t *)(rbtiterator->common.db);
        qpcnode_t *qpnode = rbtiterator->common.node;
        dns_slabheader_t *header = NULL, *top_next = NULL;
@@ -3921,7 +3914,7 @@ rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
 
 static isc_result_t
 rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
-       qpdb_rdatasetiter_t *rbtiterator = (qpdb_rdatasetiter_t *)iterator;
+       qpc_rditer_t *rbtiterator = (qpc_rditer_t *)iterator;
        qpcache_t *qpdb = (qpcache_t *)(rbtiterator->common.db);
        qpcnode_t *qpnode = rbtiterator->common.node;
        dns_slabheader_t *header = NULL, *top_next = NULL;
@@ -4011,7 +4004,7 @@ rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
 static void
 rdatasetiter_current(dns_rdatasetiter_t *iterator,
                     dns_rdataset_t *rdataset DNS__DB_FLARG) {
-       qpdb_rdatasetiter_t *rbtiterator = (qpdb_rdatasetiter_t *)iterator;
+       qpc_rditer_t *rbtiterator = (qpc_rditer_t *)iterator;
        qpcache_t *qpdb = (qpcache_t *)(rbtiterator->common.db);
        qpcnode_t *qpnode = rbtiterator->common.node;
        dns_slabheader_t *header = NULL;
@@ -4033,7 +4026,7 @@ rdatasetiter_current(dns_rdatasetiter_t *iterator,
  */
 
 static void
-reference_iter_node(qpdb_dbiterator_t *qpdbiter DNS__DB_FLARG) {
+reference_iter_node(qpc_dbit_t *qpdbiter DNS__DB_FLARG) {
        qpcache_t *qpdb = (qpcache_t *)qpdbiter->common.db;
        qpcnode_t *node = qpdbiter->node;
 
@@ -4046,7 +4039,7 @@ reference_iter_node(qpdb_dbiterator_t *qpdbiter DNS__DB_FLARG) {
 }
 
 static void
-dereference_iter_node(qpdb_dbiterator_t *qpdbiter DNS__DB_FLARG) {
+dereference_iter_node(qpc_dbit_t *qpdbiter DNS__DB_FLARG) {
        qpcache_t *qpdb = (qpcache_t *)qpdbiter->common.db;
        qpcnode_t *node = qpdbiter->node;
        isc_rwlock_t *lock = NULL;
@@ -4071,7 +4064,7 @@ dereference_iter_node(qpdb_dbiterator_t *qpdbiter DNS__DB_FLARG) {
 }
 
 static void
-resume_iteration(qpdb_dbiterator_t *qpdbiter, bool continuing) {
+resume_iteration(qpc_dbit_t *qpdbiter, bool continuing) {
        qpcache_t *qpdb = (qpcache_t *)qpdbiter->common.db;
 
        REQUIRE(qpdbiter->paused);
@@ -4101,7 +4094,7 @@ resume_iteration(qpdb_dbiterator_t *qpdbiter, bool continuing) {
 
 static void
 dbiterator_destroy(dns_dbiterator_t **iteratorp DNS__DB_FLARG) {
-       qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)(*iteratorp);
+       qpc_dbit_t *qpdbiter = (qpc_dbit_t *)(*iteratorp);
        qpcache_t *qpdb = (qpcache_t *)qpdbiter->common.db;
        dns_db_t *db = NULL;
 
@@ -4124,7 +4117,7 @@ dbiterator_destroy(dns_dbiterator_t **iteratorp DNS__DB_FLARG) {
 static isc_result_t
 dbiterator_first(dns_dbiterator_t *iterator DNS__DB_FLARG) {
        isc_result_t result;
-       qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
+       qpc_dbit_t *qpdbiter = (qpc_dbit_t *)iterator;
        qpcache_t *qpdb = (qpcache_t *)iterator->db;
 
        if (qpdbiter->result != ISC_R_SUCCESS &&
@@ -4165,7 +4158,7 @@ dbiterator_first(dns_dbiterator_t *iterator DNS__DB_FLARG) {
 static isc_result_t
 dbiterator_last(dns_dbiterator_t *iterator DNS__DB_FLARG) {
        isc_result_t result;
-       qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
+       qpc_dbit_t *qpdbiter = (qpc_dbit_t *)iterator;
        qpcache_t *qpdb = (qpcache_t *)iterator->db;
 
        if (qpdbiter->result != ISC_R_SUCCESS &&
@@ -4202,7 +4195,7 @@ static isc_result_t
 dbiterator_seek(dns_dbiterator_t *iterator,
                const dns_name_t *name DNS__DB_FLARG) {
        isc_result_t result;
-       qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
+       qpc_dbit_t *qpdbiter = (qpc_dbit_t *)iterator;
        qpcache_t *qpdb = (qpcache_t *)iterator->db;
 
        if (qpdbiter->result != ISC_R_SUCCESS &&
@@ -4237,7 +4230,7 @@ dbiterator_seek(dns_dbiterator_t *iterator,
 static isc_result_t
 dbiterator_prev(dns_dbiterator_t *iterator DNS__DB_FLARG) {
        isc_result_t result;
-       qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
+       qpc_dbit_t *qpdbiter = (qpc_dbit_t *)iterator;
 
        REQUIRE(qpdbiter->node != NULL);
 
@@ -4269,7 +4262,7 @@ dbiterator_prev(dns_dbiterator_t *iterator DNS__DB_FLARG) {
 static isc_result_t
 dbiterator_next(dns_dbiterator_t *iterator DNS__DB_FLARG) {
        isc_result_t result;
-       qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
+       qpc_dbit_t *qpdbiter = (qpc_dbit_t *)iterator;
 
        REQUIRE(qpdbiter->node != NULL);
 
@@ -4302,7 +4295,7 @@ static isc_result_t
 dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep,
                   dns_name_t *name DNS__DB_FLARG) {
        qpcache_t *qpdb = (qpcache_t *)iterator->db;
-       qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
+       qpc_dbit_t *qpdbiter = (qpc_dbit_t *)iterator;
        qpcnode_t *node = qpdbiter->node;
 
        REQUIRE(qpdbiter->result == ISC_R_SUCCESS);
@@ -4326,7 +4319,7 @@ dbiterator_current(dns_dbiterator_t *iterator, dns_dbnode_t **nodep,
 static isc_result_t
 dbiterator_pause(dns_dbiterator_t *iterator) {
        qpcache_t *qpdb = (qpcache_t *)iterator->db;
-       qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
+       qpc_dbit_t *qpdbiter = (qpc_dbit_t *)iterator;
 
        if (qpdbiter->result != ISC_R_SUCCESS &&
            qpdbiter->result != ISC_R_NOTFOUND &&
@@ -4352,7 +4345,7 @@ dbiterator_pause(dns_dbiterator_t *iterator) {
 
 static isc_result_t
 dbiterator_origin(dns_dbiterator_t *iterator, dns_name_t *name) {
-       qpdb_dbiterator_t *qpdbiter = (qpdb_dbiterator_t *)iterator;
+       qpc_dbit_t *qpdbiter = (qpc_dbit_t *)iterator;
 
        if (qpdbiter->result != ISC_R_SUCCESS) {
                return (qpdbiter->result);

diff --git a/lib/dns/qpzone.c b/lib/dns/qpzone.c
index 9f66d5469209f8c950f3e4e6be53678e0c23462e..02002577367771bb3a388efae8f727dfb687c327 100644 (file)
--- a/lib/dns/qpzone.c
+++ b/lib/dns/qpzone.c
@@ -108,25 +108,25 @@
 typedef struct qpzonedb qpzonedb_t;
 typedef struct qpznode qpznode_t;
 
-typedef struct qpdb_changed {
+typedef struct qpz_changed {
        qpznode_t *node;
        bool dirty;
-       ISC_LINK(struct qpdb_changed) link;
-} qpdb_changed_t;
+       ISC_LINK(struct qpz_changed) link;
+} qpz_changed_t;
 
-typedef ISC_LIST(qpdb_changed_t) qpdb_changedlist_t;
+typedef ISC_LIST(qpz_changed_t) qpz_changedlist_t;
 
-typedef struct qpdb_version qpdb_version_t;
-struct qpdb_version {
+typedef struct qpz_version qpz_version_t;
+struct qpz_version {
        /* Not locked */
        uint32_t serial;
        qpzonedb_t *qpdb;
        isc_refcount_t references;
        /* Locked by database lock. */
        bool writer;
-       qpdb_changedlist_t changed_list;
+       qpz_changedlist_t changed_list;
        dns_slabheaderlist_t resigned_list;
-       ISC_LINK(qpdb_version_t) link;
+       ISC_LINK(qpz_version_t) link;
        bool secure;
        bool havensec3;
        /* NSEC3 parameters */
@@ -146,7 +146,7 @@ struct qpdb_version {
        struct cds_wfs_stack glue_stack;
 };
 
-typedef ISC_LIST(qpdb_version_t) qpdb_versionlist_t;
+typedef ISC_LIST(qpz_version_t) qpz_versionlist_t;
 
 struct qpznode {
        dns_name_t name;
@@ -180,9 +180,9 @@ struct qpzonedb {
        uint32_t current_serial;
        uint32_t least_serial;
        uint32_t next_serial;
-       qpdb_version_t *current_version;
-       qpdb_version_t *future_version;
-       qpdb_versionlist_t open_versions;
+       qpz_version_t *current_version;
+       qpz_version_t *future_version;
+       qpz_versionlist_t open_versions;
        isc_loop_t *loop;
        struct rcu_head rcu_head;
 
@@ -198,7 +198,7 @@ struct qpzonedb {
  */
 typedef struct {
        qpzonedb_t *qpdb;
-       qpdb_version_t *version;
+       qpz_version_t *version;
        dns_qpread_t qpr;
        uint32_t serial;
        unsigned int options;
@@ -212,7 +212,7 @@ typedef struct {
        dns_slabheader_t *zonecut_sigheader;
        dns_fixedname_t zonecut_name;
        isc_stdtime_t now;
-} qpdb_search_t;
+} qpz_search_t;
 
 /*%
  * Load Context
@@ -223,7 +223,7 @@ typedef struct {
        dns_qp_t *tree;
        dns_qp_t *nsec;
        dns_qp_t *nsec3;
-} qpdb_load_t;
+} qpz_load_t;
 
 static dns_dbmethods_t qpdb_zonemethods;
 
@@ -600,11 +600,11 @@ new_qpznode(qpzonedb_t *qpdb, const dns_name_t *name) {
        return (newdata);
 }
 
-static qpdb_version_t *
+static qpz_version_t *
 allocate_version(isc_mem_t *mctx, uint32_t serial, unsigned int references,
                 bool writer) {
-       qpdb_version_t *version = isc_mem_get(mctx, sizeof(*version));
-       *version = (qpdb_version_t){
+       qpz_version_t *version = isc_mem_get(mctx, sizeof(*version));
+       *version = (qpz_version_t){
                .serial = serial,
                .writer = writer,
                .changed_list = ISC_LIST_INITIALIZER,
@@ -1031,7 +1031,7 @@ bindrdataset(qpzonedb_t *qpdb, qpznode_t *node, dns_slabheader_t *header,
 }
 
 static void
-setnsec3parameters(dns_db_t *db, qpdb_version_t *version) {
+setnsec3parameters(dns_db_t *db, qpz_version_t *version) {
        qpznode_t *node = NULL;
        dns_rdata_nsec3param_t nsec3param;
        dns_rdata_t rdata = DNS_RDATA_INIT;
@@ -1116,8 +1116,8 @@ unlock:
 }
 
 static void
-cleanup_nondirty(qpdb_version_t *version, qpdb_changedlist_t *cleanup_list) {
-       qpdb_changed_t *changed = NULL, *next_changed = NULL;
+cleanup_nondirty(qpz_version_t *version, qpz_changedlist_t *cleanup_list) {
+       qpz_changed_t *changed = NULL, *next_changed = NULL;
 
        /*
         * If the changed record is dirty, then an update created multiple
@@ -1142,7 +1142,7 @@ cleanup_nondirty(qpdb_version_t *version, qpdb_changedlist_t *cleanup_list) {
 }
 
 static void
-setsecure(dns_db_t *db, qpdb_version_t *version, dns_dbnode_t *origin) {
+setsecure(dns_db_t *db, qpz_version_t *version, dns_dbnode_t *origin) {
        dns_rdataset_t keyset;
        dns_rdataset_t nsecset, signsecset;
        bool haszonekey = false;
@@ -1198,7 +1198,7 @@ setsecure(dns_db_t *db, qpdb_version_t *version, dns_dbnode_t *origin) {
 static void
 currentversion(dns_db_t *db, dns_dbversion_t **versionp) {
        qpzonedb_t *qpdb = (qpzonedb_t *)db;
-       qpdb_version_t *version = NULL;
+       qpz_version_t *version = NULL;
 
        REQUIRE(VALID_QPZONE(qpdb));
 
@@ -1214,7 +1214,7 @@ static void
 attachversion(dns_db_t *db, dns_dbversion_t *source,
              dns_dbversion_t **targetp) {
        qpzonedb_t *qpdb = (qpzonedb_t *)db;
-       qpdb_version_t *version = source;
+       qpz_version_t *version = source;
 
        REQUIRE(VALID_QPZONE(qpdb));
        INSIST(version != NULL && version->qpdb == qpdb);
@@ -1227,7 +1227,7 @@ attachversion(dns_db_t *db, dns_dbversion_t *source,
 static isc_result_t
 newversion(dns_db_t *db, dns_dbversion_t **versionp) {
        qpzonedb_t *qpdb = (qpzonedb_t *)db;
-       qpdb_version_t *version = NULL;
+       qpz_version_t *version = NULL;
 
        REQUIRE(VALID_QPZONE(qpdb));
        REQUIRE(versionp != NULL && *versionp == NULL);
@@ -1274,7 +1274,7 @@ resigninsert(qpzonedb_t *qpdb, dns_slabheader_t *newheader) {
 }
 
 static void
-resigndelete(qpzonedb_t *qpdb, qpdb_version_t *version,
+resigndelete(qpzonedb_t *qpdb, qpz_version_t *version,
             dns_slabheader_t *header DNS__DB_FLARG) {
        if (header == NULL || header->heap_index == 0) {
                return;
@@ -1290,8 +1290,8 @@ resigndelete(qpzonedb_t *qpdb, qpdb_version_t *version,
 }
 
 static void
-make_least_version(qpzonedb_t *qpdb, qpdb_version_t *version,
-                  qpdb_changedlist_t *cleanup_list) {
+make_least_version(qpzonedb_t *qpdb, qpz_version_t *version,
+                  qpz_changedlist_t *cleanup_list) {
        qpdb->least_serial = version->serial;
        *cleanup_list = version->changed_list;
        ISC_LIST_INIT(version->changed_list);
@@ -1332,18 +1332,18 @@ static void
 closeversion(dns_db_t *db, dns_dbversion_t **versionp,
             bool commit DNS__DB_FLARG) {
        qpzonedb_t *qpdb = (qpzonedb_t *)db;
-       qpdb_version_t *version = NULL, *cleanup_version = NULL;
-       qpdb_version_t *least_greater = NULL;
+       qpz_version_t *version = NULL, *cleanup_version = NULL;
+       qpz_version_t *least_greater = NULL;
        qpznode_t *node = NULL;
        bool rollback = false;
-       qpdb_changed_t *changed = NULL, *next_changed = NULL;
-       qpdb_changedlist_t cleanup_list;
+       qpz_changed_t *changed = NULL, *next_changed = NULL;
+       qpz_changedlist_t cleanup_list;
        dns_slabheaderlist_t resigned_list;
        dns_slabheader_t *header = NULL;
        uint32_t serial, least_serial;
 
        REQUIRE(VALID_QPZONE(qpdb));
-       version = (qpdb_version_t *)*versionp;
+       version = (qpz_version_t *)*versionp;
        INSIST(version->qpdb == qpdb);
 
        if (isc_refcount_decrement(&version->references) > 1) {
@@ -1367,7 +1367,7 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp,
        if (version->writer) {
                if (commit) {
                        unsigned int cur_ref;
-                       qpdb_version_t *cur_version = NULL;
+                       qpz_version_t *cur_version = NULL;
 
                        INSIST(version == qpdb->future_version);
                        /*
@@ -1567,7 +1567,7 @@ findrdataset(dns_db_t *db, dns_dbnode_t *dbnode, dns_dbversion_t *dbversion,
        dns_slabheader_t *header = NULL, *header_next = NULL;
        dns_slabheader_t *found = NULL, *foundsig = NULL;
        uint32_t serial;
-       qpdb_version_t *version = dbversion;
+       qpz_version_t *version = dbversion;
        bool close_version = false;
        dns_typepair_t matchtype, sigmatchtype;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
@@ -1651,7 +1651,7 @@ delegating_type(qpzonedb_t *qpdb, qpznode_t *node, dns_typepair_t type) {
 }
 
 static void
-loading_addnode(qpdb_load_t *loadctx, const dns_name_t *name,
+loading_addnode(qpz_load_t *loadctx, const dns_name_t *name,
                dns_rdatatype_t type, dns_rdatatype_t covers,
                qpznode_t **nodep) {
        qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db;
@@ -1775,9 +1775,9 @@ cname_and_other(qpznode_t *node, uint32_t serial) {
        return (false);
 }
 
-static qpdb_changed_t *
-add_changed(dns_slabheader_t *header, qpdb_version_t *version DNS__DB_FLARG) {
-       qpdb_changed_t *changed = NULL;
+static qpz_changed_t *
+add_changed(dns_slabheader_t *header, qpz_version_t *version DNS__DB_FLARG) {
+       qpz_changed_t *changed = NULL;
        qpzonedb_t *qpdb = (qpzonedb_t *)header->db;
        qpznode_t *node = (qpznode_t *)header->node;
 
@@ -1786,7 +1786,7 @@ add_changed(dns_slabheader_t *header, qpdb_version_t *version DNS__DB_FLARG) {
        RWLOCK(&qpdb->lock, isc_rwlocktype_write);
        REQUIRE(version->writer);
 
-       *changed = (qpdb_changed_t){ .node = node };
+       *changed = (qpz_changed_t){ .node = node };
        ISC_LIST_INITANDAPPEND(version->changed_list, changed, link);
        newref(qpdb, node DNS__DB_FLARG_PASS);
        RWUNLOCK(&qpdb->lock, isc_rwlocktype_write);
@@ -1803,7 +1803,7 @@ recordsize(dns_slabheader_t *header, unsigned int namelen) {
 }
 
 static void
-maybe_update_recordsandsize(bool add, qpdb_version_t *version,
+maybe_update_recordsandsize(bool add, qpz_version_t *version,
                            dns_slabheader_t *header, unsigned int namelen) {
        unsigned char *hdr = (unsigned char *)header;
        size_t hdrsize = sizeof(*header);
@@ -1825,10 +1825,10 @@ maybe_update_recordsandsize(bool add, qpdb_version_t *version,
 
 static isc_result_t
 add(qpzonedb_t *qpdb, qpznode_t *node, const dns_name_t *nodename,
-    qpdb_version_t *version, dns_slabheader_t *newheader, unsigned int options,
+    qpz_version_t *version, dns_slabheader_t *newheader, unsigned int options,
     bool loading, dns_rdataset_t *addedrdataset,
     isc_stdtime_t now DNS__DB_FLARG) {
-       qpdb_changed_t *changed = NULL;
+       qpz_changed_t *changed = NULL;
        dns_slabheader_t *topheader = NULL, *topheader_prev = NULL;
        dns_slabheader_t *prioheader = NULL;
        dns_slabheader_t *header = NULL;
@@ -2114,7 +2114,7 @@ addwildcards(qpzonedb_t *qpdb, dns_qp_t *qp, const dns_name_t *name,
 static isc_result_t
 loading_addrdataset(void *arg, const dns_name_t *name,
                    dns_rdataset_t *rdataset DNS__DB_FLARG) {
-       qpdb_load_t *loadctx = arg;
+       qpz_load_t *loadctx = arg;
        qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db;
        qpznode_t *node = NULL;
        isc_result_t result = ISC_R_SUCCESS;
@@ -2203,7 +2203,7 @@ loading_addrdataset(void *arg, const dns_name_t *name,
 
 static void
 loading_setup(void *arg) {
-       qpdb_load_t *loadctx = arg;
+       qpz_load_t *loadctx = arg;
        qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db;
 
        dns_qpmulti_write(qpdb->tree, &loadctx->tree);
@@ -2213,7 +2213,7 @@ loading_setup(void *arg) {
 
 static void
 loading_commit(void *arg) {
-       qpdb_load_t *loadctx = arg;
+       qpz_load_t *loadctx = arg;
        qpzonedb_t *qpdb = (qpzonedb_t *)loadctx->db;
 
        if (loadctx->tree != NULL) {
@@ -2232,7 +2232,7 @@ loading_commit(void *arg) {
 
 static isc_result_t
 beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
-       qpdb_load_t *loadctx = NULL;
+       qpz_load_t *loadctx = NULL;
        qpzonedb_t *qpdb = NULL;
        qpdb = (qpzonedb_t *)db;
 
@@ -2240,7 +2240,7 @@ beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
        REQUIRE(VALID_QPZONE(qpdb));
 
        loadctx = isc_mem_get(qpdb->common.mctx, sizeof(*loadctx));
-       *loadctx = (qpdb_load_t){ .db = db };
+       *loadctx = (qpz_load_t){ .db = db };
 
        RWLOCK(&qpdb->lock, isc_rwlocktype_write);
 
@@ -2260,7 +2260,7 @@ beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
 
 static isc_result_t
 endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
-       qpdb_load_t *loadctx = NULL;
+       qpz_load_t *loadctx = NULL;
        qpzonedb_t *qpdb = (qpzonedb_t *)db;
 
        REQUIRE(VALID_QPZONE(qpdb));
@@ -2317,7 +2317,7 @@ getnsec3parameters(dns_db_t *db, dns_dbversion_t *dbversion, dns_hash_t *hash,
                   size_t *salt_length) {
        qpzonedb_t *qpdb = NULL;
        isc_result_t result = ISC_R_NOTFOUND;
-       qpdb_version_t *version = dbversion;
+       qpz_version_t *version = dbversion;
 
        qpdb = (qpzonedb_t *)db;
 
@@ -2357,7 +2357,7 @@ static isc_result_t
 getsize(dns_db_t *db, dns_dbversion_t *dbversion, uint64_t *records,
        uint64_t *xfrsize) {
        qpzonedb_t *qpdb = NULL;
-       qpdb_version_t *version = dbversion;
+       qpz_version_t *version = dbversion;
        isc_result_t result = ISC_R_SUCCESS;
 
        qpdb = (qpzonedb_t *)db;
@@ -2568,7 +2568,7 @@ findnsec3node(dns_db_t *db, const dns_name_t *name, bool create,
 }
 
 static bool
-matchparams(dns_slabheader_t *header, qpdb_search_t *search) {
+matchparams(dns_slabheader_t *header, qpz_search_t *search) {
        dns_rdata_t rdata = DNS_RDATA_INIT;
        dns_rdata_nsec3_t nsec3;
        unsigned char *raw = NULL;
@@ -2606,7 +2606,7 @@ matchparams(dns_slabheader_t *header, qpdb_search_t *search) {
 }
 
 static isc_result_t
-setup_delegation(qpdb_search_t *search, dns_dbnode_t **nodep,
+setup_delegation(qpz_search_t *search, dns_dbnode_t **nodep,
                 dns_name_t *foundname, dns_rdataset_t *rdataset,
                 dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
        dns_name_t *zcname = NULL;
@@ -2674,7 +2674,7 @@ typedef enum { FORWARD, BACK } direction_t;
  * Return true if we found a predecessor or successor.
  */
 static bool
-step(qpdb_search_t *search, dns_qpiter_t *it, direction_t direction,
+step(qpz_search_t *search, dns_qpiter_t *it, direction_t direction,
      dns_name_t *nextname) {
        dns_fixedname_t fnodename;
        dns_name_t *nodename = dns_fixedname_initname(&fnodename);
@@ -2723,8 +2723,7 @@ step(qpdb_search_t *search, dns_qpiter_t *it, direction_t direction,
 }
 
 static bool
-activeempty(qpdb_search_t *search, dns_qpiter_t *it,
-           const dns_name_t *current) {
+activeempty(qpz_search_t *search, dns_qpiter_t *it, const dns_name_t *current) {
        dns_fixedname_t fnext;
        dns_name_t *next = dns_fixedname_initname(&fnext);
 
@@ -2746,7 +2745,7 @@ activeempty(qpdb_search_t *search, dns_qpiter_t *it,
 }
 
 static bool
-wildcard_blocked(qpdb_search_t *search, const dns_name_t *qname,
+wildcard_blocked(qpz_search_t *search, const dns_name_t *qname,
                 dns_name_t *wname) {
        isc_result_t result;
        dns_fixedname_t fnext;
@@ -2818,7 +2817,7 @@ wildcard_blocked(qpdb_search_t *search, const dns_name_t *qname,
 }
 
 static isc_result_t
-find_wildcard(qpdb_search_t *search, qpznode_t **nodep,
+find_wildcard(qpz_search_t *search, qpznode_t **nodep,
              const dns_name_t *qname) {
        dns_slabheader_t *header = NULL;
        isc_result_t result = ISC_R_NOTFOUND;
@@ -2944,7 +2943,7 @@ find_wildcard(qpdb_search_t *search, qpznode_t **nodep,
  * Find node of the NSEC/NSEC3 record that is 'name'.
  */
 static isc_result_t
-previous_closest_nsec(dns_rdatatype_t type, qpdb_search_t *search,
+previous_closest_nsec(dns_rdatatype_t type, qpz_search_t *search,
                      dns_name_t *name, qpznode_t **nodep, dns_qpiter_t *nit,
                      bool *firstp) {
        isc_result_t result;
@@ -3033,7 +3032,7 @@ previous_closest_nsec(dns_rdatatype_t type, qpdb_search_t *search,
  * current NSEC3PARAM record are considered.
  */
 static isc_result_t
-find_closest_nsec(qpdb_search_t *search, dns_dbnode_t **nodep,
+find_closest_nsec(qpz_search_t *search, dns_dbnode_t **nodep,
                  dns_name_t *foundname, dns_rdataset_t *rdataset,
                  dns_rdataset_t *sigrdataset, bool nsec3,
                  bool secure DNS__DB_FLARG) {
@@ -3204,7 +3203,7 @@ again:
 
 static isc_result_t
 check_zonecut(qpznode_t *node, void *arg DNS__DB_FLARG) {
-       qpdb_search_t *search = arg;
+       qpz_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;
@@ -3338,7 +3337,7 @@ find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
        isc_result_t result;
        qpzonedb_t *qpdb = (qpzonedb_t *)db;
        qpznode_t *node = NULL;
-       qpdb_search_t search;
+       qpz_search_t search;
        bool cname_ok = true, close_version = false;
        bool maybe_zonecut = false, at_zonecut = false;
        bool wild = false, empty_node = false;
@@ -3353,7 +3352,7 @@ find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
 
        REQUIRE(VALID_QPZONE((qpzonedb_t *)db));
        INSIST(version == NULL ||
-              ((qpdb_version_t *)version)->qpdb == (qpzonedb_t *)db);
+              ((qpz_version_t *)version)->qpdb == (qpzonedb_t *)db);
 
        /*
         * If the caller didn't supply a version, attach to the current
@@ -3364,10 +3363,10 @@ find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
                close_version = true;
        }
 
-       search = (qpdb_search_t){
+       search = (qpz_search_t){
                .qpdb = (qpzonedb_t *)db,
                .version = version,
-               .serial = ((qpdb_version_t *)version)->serial,
+               .serial = ((qpz_version_t *)version)->serial,
                .options = options,
        };
        dns_fixedname_init(&search.zonecut_name);
@@ -3853,7 +3852,7 @@ allrdatasets(dns_db_t *db, dns_dbnode_t *dbnode, dns_dbversion_t *dbversion,
             dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) {
        qpzonedb_t *qpdb = (qpzonedb_t *)db;
        qpznode_t *node = (qpznode_t *)dbnode;
-       qpdb_version_t *version = dbversion;
+       qpz_version_t *version = dbversion;
        qpdb_rdatasetiter_t *iterator = NULL;
 
        REQUIRE(VALID_QPZONE(qpdb));
@@ -4065,7 +4064,7 @@ rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
        qpdb_rdatasetiter_t *qrditer = (qpdb_rdatasetiter_t *)iterator;
        qpzonedb_t *qpdb = (qpzonedb_t *)(qrditer->common.db);
        qpznode_t *node = qrditer->common.node;
-       qpdb_version_t *version = qrditer->common.version;
+       qpz_version_t *version = qrditer->common.version;
        dns_slabheader_t *header = NULL, *top_next = NULL;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
 
@@ -4106,7 +4105,7 @@ rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
        qpdb_rdatasetiter_t *qrditer = (qpdb_rdatasetiter_t *)iterator;
        qpzonedb_t *qpdb = (qpzonedb_t *)(qrditer->common.db);
        qpznode_t *node = qrditer->common.node;
-       qpdb_version_t *version = qrditer->common.version;
+       qpz_version_t *version = qrditer->common.version;
        dns_slabheader_t *header = NULL, *top_next = NULL;
        dns_typepair_t type, negtype;
        dns_rdatatype_t rdtype;
@@ -4635,7 +4634,7 @@ addrdataset(dns_db_t *db, dns_dbnode_t *dbnode, dns_dbversion_t *dbversion,
        isc_result_t result;
        qpzonedb_t *qpdb = (qpzonedb_t *)db;
        qpznode_t *node = (qpznode_t *)dbnode;
-       qpdb_version_t *version = dbversion;
+       qpz_version_t *version = dbversion;
        isc_region_t region;
        dns_slabheader_t *newheader = NULL;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
@@ -4757,7 +4756,7 @@ subtractrdataset(dns_db_t *db, dns_dbnode_t *dbnode, dns_dbversion_t *dbversion,
                 dns_rdataset_t *newrdataset DNS__DB_FLARG) {
        qpzonedb_t *qpdb = (qpzonedb_t *)db;
        qpznode_t *node = (qpznode_t *)dbnode;
-       qpdb_version_t *version = dbversion;
+       qpz_version_t *version = dbversion;
        dns_fixedname_t fname;
        dns_name_t *nodename = dns_fixedname_initname(&fname);
        dns_slabheader_t *topheader = NULL, *topheader_prev = NULL;
@@ -4765,7 +4764,7 @@ subtractrdataset(dns_db_t *db, dns_dbnode_t *dbnode, dns_dbversion_t *dbversion,
        unsigned char *subresult = NULL;
        isc_region_t region;
        isc_result_t result;
-       qpdb_changed_t *changed = NULL;
+       qpz_changed_t *changed = NULL;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
 
        REQUIRE(VALID_QPZONE(qpdb));
@@ -4945,7 +4944,7 @@ deleterdataset(dns_db_t *db, dns_dbnode_t *dbnode, dns_dbversion_t *dbversion,
               dns_rdatatype_t type, dns_rdatatype_t covers DNS__DB_FLARG) {
        qpzonedb_t *qpdb = (qpzonedb_t *)db;
        qpznode_t *node = (qpznode_t *)dbnode;
-       qpdb_version_t *version = dbversion;
+       qpz_version_t *version = dbversion;
        dns_fixedname_t fname;
        dns_name_t *nodename = dns_fixedname_initname(&fname);
        isc_result_t result;
@@ -5212,7 +5211,7 @@ addglue_to_message(dns_glue_t *ge, dns_message_t *msg) {
 }
 
 static dns_glue_t *
-newglue(qpzonedb_t *qpdb, qpdb_version_t *version, qpznode_t *node,
+newglue(qpzonedb_t *qpdb, qpz_version_t *version, qpznode_t *node,
        dns_rdataset_t *rdataset) {
        dns_fixedname_t nodename;
        dns_glue_additionaldata_ctx_t ctx = {
@@ -5239,7 +5238,7 @@ static isc_result_t
 addglue(dns_db_t *db, dns_dbversion_t *dbversion, dns_rdataset_t *rdataset,
        dns_message_t *msg) {
        qpzonedb_t *qpdb = (qpzonedb_t *)db;
-       qpdb_version_t *version = dbversion;
+       qpz_version_t *version = dbversion;
        qpznode_t *node = (qpznode_t *)rdataset->slab.node;
        dns_slabheader_t *header = dns_slabheader_fromrdataset(rdataset);