Enforce type checking for dns_dbversiont_t

Originally, the dns_dbversion_t was typedef'ed to void type.  This
allowed some flexibility, but using (void *) just removes any
type-checking that C might have.  Instead of using:

    typedef void dns_dbversion_t;

use a trick to define the type to non-existing structure:

    typedef struct dns_dbversion dns_dbversion_t;

This allows the C compilers to employ the type-checking while the
structure itself doesn't have to be ever defined because the actual
'storage' is never accessed using dns_dbversion_t type.

diff --git a/bin/named/builtin.c b/bin/named/builtin.c
index 9d4180614bd7b7324d9cfa181b95d4b96693afc5..9ed069ecf6738eb541f0f90e521ed1204f98501d 100644 (file)
--- a/bin/named/builtin.c
+++ b/bin/named/builtin.c
@@ -925,7 +925,7 @@ find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
 
        REQUIRE(VALID_BDB(bdb));
        REQUIRE(nodep == NULL || *nodep == NULL);
-       REQUIRE(version == NULL || version == (void *)&dummy);
+       REQUIRE(version == NULL || version == (dns_dbversion_t *)&dummy);
 
        if (!dns_name_issubdomain(name, &db->origin)) {
                return (DNS_R_NXDOMAIN);
@@ -1142,7 +1142,7 @@ allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
             dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) {
        bdb_rdatasetiter_t *iterator = NULL;
 
-       REQUIRE(version == NULL || version == &dummy);
+       REQUIRE(version == NULL || version == (dns_dbversion_t *)&dummy);
 
        iterator = isc_mem_get(db->mctx, sizeof(bdb_rdatasetiter_t));
        *iterator = (bdb_rdatasetiter_t){

diff --git a/lib/dns/include/dns/types.h b/lib/dns/include/dns/types.h
index a389ef7e892c126d21fb5154fd7ee35d95d80fb5..1e56d1d256b16b0a4ddce700c8044b132bc67f3c 100644 (file)
--- a/lib/dns/include/dns/types.h
+++ b/lib/dns/include/dns/types.h
@@ -64,7 +64,7 @@ typedef void                         dns_dbload_t;
 typedef struct dns_dbnode dns_dbnode_t; /* this is dummy struct for proper type
                                           checking */
 typedef struct dns_dbonupdatelistener dns_dbonupdatelistener_t;
-typedef void                         dns_dbversion_t;
+typedef struct dns_dbversion         dns_dbversion_t;
 typedef struct dns_dlzimplementation  dns_dlzimplementation_t;
 typedef struct dns_dlzdb             dns_dlzdb_t;
 typedef ISC_LIST(dns_dlzdb_t) dns_dlzdblist_t;

diff --git a/lib/dns/qpzone.c b/lib/dns/qpzone.c
index 67e82e88b5f6bf9a5c524828f002294c47e96516..ef58c7da6bfbf3d1acd3379d2622a3929478c29b 100644 (file)
--- a/lib/dns/qpzone.c
+++ b/lib/dns/qpzone.c
@@ -1095,8 +1095,8 @@ setsecure(dns_db_t *db, qpz_version_t *version, dns_dbnode_t *origin) {
        isc_result_t result;
 
        dns_rdataset_init(&keyset);
-       result = dns_db_findrdataset(db, origin, version, dns_rdatatype_dnskey,
-                                    0, 0, &keyset, NULL);
+       result = dns_db_findrdataset(db, origin, (dns_dbversion_t *)version,
+                                    dns_rdatatype_dnskey, 0, 0, &keyset, NULL);
        if (result == ISC_R_SUCCESS) {
                result = dns_rdataset_first(&keyset);
                while (result == ISC_R_SUCCESS) {
@@ -1118,8 +1118,9 @@ setsecure(dns_db_t *db, qpz_version_t *version, dns_dbnode_t *origin) {
 
        dns_rdataset_init(&nsecset);
        dns_rdataset_init(&signsecset);
-       result = dns_db_findrdataset(db, origin, version, dns_rdatatype_nsec, 0,
-                                    0, &nsecset, &signsecset);
+       result = dns_db_findrdataset(db, origin, (dns_dbversion_t *)version,
+                                    dns_rdatatype_nsec, 0, 0, &nsecset,
+                                    &signsecset);
        if (result == ISC_R_SUCCESS) {
                if (dns_rdataset_isassociated(&signsecset)) {
                        hasnsec = true;
@@ -1159,14 +1160,14 @@ static void
 attachversion(dns_db_t *db, dns_dbversion_t *source,
              dns_dbversion_t **targetp) {
        qpzonedb_t *qpdb = (qpzonedb_t *)db;
-       qpz_version_t *version = source;
+       qpz_version_t *version = (qpz_version_t *)source;
 
        REQUIRE(VALID_QPZONE(qpdb));
        INSIST(version != NULL && version->qpdb == qpdb);
 
        isc_refcount_increment(&version->references);
 
-       *targetp = version;
+       *targetp = source;
 }
 
 static isc_result_t
@@ -1201,7 +1202,7 @@ newversion(dns_db_t *db, dns_dbversion_t **versionp) {
        qpdb->future_version = version;
        RWUNLOCK(&qpdb->lock, isc_rwlocktype_write);
 
-       *versionp = version;
+       *versionp = (dns_dbversion_t *)version;
 
        return (ISC_R_SUCCESS);
 }
@@ -1511,7 +1512,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;
-       qpz_version_t *version = dbversion;
+       qpz_version_t *version = (qpz_version_t *)dbversion;
        bool close_version = false;
        dns_typepair_t matchtype, sigmatchtype;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
@@ -2224,7 +2225,7 @@ endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
        qpdb->attributes |= QPDB_ATTR_LOADED;
 
        if (qpdb->origin != NULL) {
-               dns_dbversion_t *version = qpdb->current_version;
+               qpz_version_t *version = qpdb->current_version;
                RWUNLOCK(&qpdb->lock, isc_rwlocktype_write);
                setsecure(db, version, (dns_dbnode_t *)qpdb->origin);
        } else {
@@ -2263,7 +2264,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;
-       qpz_version_t *version = dbversion;
+       qpz_version_t *version = (qpz_version_t *)dbversion;
 
        qpdb = (qpzonedb_t *)db;
 
@@ -2303,7 +2304,7 @@ static isc_result_t
 getsize(dns_db_t *db, dns_dbversion_t *dbversion, uint64_t *records,
        uint64_t *xfrsize) {
        qpzonedb_t *qpdb = NULL;
-       qpz_version_t *version = dbversion;
+       qpz_version_t *version = (qpz_version_t *)dbversion;
        isc_result_t result = ISC_R_SUCCESS;
 
        qpdb = (qpzonedb_t *)db;
@@ -3311,7 +3312,7 @@ find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
 
        search = (qpz_search_t){
                .qpdb = (qpzonedb_t *)db,
-               .version = version,
+               .version = (qpz_version_t *)version,
                .serial = ((qpz_version_t *)version)->serial,
                .options = options,
        };
@@ -3798,7 +3799,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;
-       qpz_version_t *version = dbversion;
+       qpz_version_t *version = (qpz_version_t *)dbversion;
        qpdb_rdatasetiter_t *iterator = NULL;
 
        REQUIRE(VALID_QPZONE(qpdb));
@@ -4004,7 +4005,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 = (qpznode_t *)qrditer->common.node;
-       qpz_version_t *version = qrditer->common.version;
+       qpz_version_t *version = (qpz_version_t *)qrditer->common.version;
        dns_slabheader_t *header = NULL, *top_next = NULL;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
 
@@ -4045,7 +4046,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 = (qpznode_t *)qrditer->common.node;
-       qpz_version_t *version = qrditer->common.version;
+       qpz_version_t *version = (qpz_version_t *)qrditer->common.version;
        dns_slabheader_t *header = NULL, *top_next = NULL;
        dns_typepair_t type, negtype;
        dns_rdatatype_t rdtype;
@@ -4574,7 +4575,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;
-       qpz_version_t *version = dbversion;
+       qpz_version_t *version = (qpz_version_t *)dbversion;
        isc_region_t region;
        dns_slabheader_t *newheader = NULL;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
@@ -4697,7 +4698,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;
-       qpz_version_t *version = dbversion;
+       qpz_version_t *version = (qpz_version_t *)dbversion;
        dns_fixedname_t fname;
        dns_name_t *nodename = dns_fixedname_initname(&fname);
        dns_slabheader_t *topheader = NULL, *topheader_prev = NULL;
@@ -4887,7 +4888,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;
-       qpz_version_t *version = dbversion;
+       qpz_version_t *version = (qpz_version_t *)dbversion;
        dns_fixedname_t fname;
        dns_name_t *nodename = dns_fixedname_initname(&fname);
        isc_result_t result;
@@ -5269,7 +5270,7 @@ static void
 addglue(dns_db_t *db, dns_dbversion_t *dbversion, dns_rdataset_t *rdataset,
        dns_message_t *msg) {
        qpzonedb_t *qpdb = (qpzonedb_t *)db;
-       qpz_version_t *version = dbversion;
+       qpz_version_t *version = (qpz_version_t *)dbversion;
        qpznode_t *node = (qpznode_t *)rdataset->slab.node;
        dns_gluenode_t *gluenode = NULL;
 

diff --git a/lib/dns/rbt-zonedb.c b/lib/dns/rbt-zonedb.c
index d90b48eb1d60ea6110ea404e6463f889a7f87ea6..f71bd72e5b709bbe31f459c0d3cb258508c80e51 100644 (file)
--- a/lib/dns/rbt-zonedb.c
+++ b/lib/dns/rbt-zonedb.c
@@ -1021,7 +1021,7 @@ zone_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
 
        search = (rbtdb_search_t){
                .rbtdb = (dns_rbtdb_t *)db,
-               .rbtversion = version,
+               .rbtversion = (dns_rbtdb_version_t *)version,
                .serial = ((dns_rbtdb_version_t *)version)->serial,
                .options = options,
        };
@@ -1505,7 +1505,7 @@ zone_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
        dns_slabheader_t *header = NULL, *header_next = NULL;
        dns_slabheader_t *found = NULL, *foundsig = NULL;
        uint32_t serial;
-       dns_rbtdb_version_t *rbtversion = version;
+       dns_rbtdb_version_t *rbtversion = (dns_rbtdb_version_t *)version;
        bool close_version = false;
        dns_typepair_t matchtype, sigmatchtype;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
@@ -1843,9 +1843,9 @@ endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
         * zone key, we consider the zone secure.
         */
        if (rbtdb->origin_node != NULL) {
-               dns_dbversion_t *version = rbtdb->current_version;
+               dns_rbtdb_version_t *rbtversion = rbtdb->current_version;
                RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
-               dns__rbtdb_setsecure(db, version,
+               dns__rbtdb_setsecure(db, rbtversion,
                                     (dns_dbnode_t *)rbtdb->origin_node);
        } else {
                RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
@@ -1879,7 +1879,7 @@ getnsec3parameters(dns_db_t *db, dns_dbversion_t *version, dns_hash_t *hash,
                   size_t *salt_length) {
        dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
        isc_result_t result = ISC_R_NOTFOUND;
-       dns_rbtdb_version_t *rbtversion = version;
+       dns_rbtdb_version_t *rbtversion = (dns_rbtdb_version_t *)version;
 
        REQUIRE(VALID_RBTDB(rbtdb));
        INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
@@ -1919,7 +1919,7 @@ getsize(dns_db_t *db, dns_dbversion_t *version, uint64_t *records,
        uint64_t *xfrsize) {
        dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
        isc_result_t result = ISC_R_SUCCESS;
-       dns_rbtdb_version_t *rbtversion = version;
+       dns_rbtdb_version_t *rbtversion = (dns_rbtdb_version_t *)version;
 
        REQUIRE(VALID_RBTDB(rbtdb));
        INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
@@ -2381,7 +2381,7 @@ static void
 addglue(dns_db_t *db, dns_dbversion_t *dbversion, dns_rdataset_t *rdataset,
        dns_message_t *msg) {
        dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
-       dns_rbtdb_version_t *version = dbversion;
+       dns_rbtdb_version_t *version = (dns_rbtdb_version_t *)dbversion;
        dns_rbtnode_t *node = (dns_rbtnode_t *)rdataset->slab.node;
        dns_gluenode_t *gluenode = NULL;
 
@@ -2413,7 +2413,7 @@ addglue(dns_db_t *db, dns_dbversion_t *dbversion, dns_rdataset_t *rdataset,
                                  ht_node);
        if (gluenode == NULL) {
                /* No cached glue was found in the table. Get new glue. */
-               gluenode = new_gluenode(db, version, node, rdataset);
+               gluenode = new_gluenode(db, dbversion, node, rdataset);
 
                struct cds_lfht_node *ht_node = cds_lfht_add_unique(
                        version->glue_table, gluenode_hash(gluenode),

diff --git a/lib/dns/rbtdb.c b/lib/dns/rbtdb.c
index e18dc08236de2ebcec5bc8ef5f43e34c14b60c7c..4b217b72e02020883907967dd378f3c04229e1a5 100644 (file)
--- a/lib/dns/rbtdb.c
+++ b/lib/dns/rbtdb.c
@@ -736,7 +736,7 @@ dns__rbtdb_newversion(dns_db_t *db, dns_dbversion_t **versionp) {
        rbtdb->future_version = version;
        RWUNLOCK(&rbtdb->lock, isc_rwlocktype_write);
 
-       *versionp = version;
+       *versionp = (dns_dbversion_t *)version;
 
        return (ISC_R_SUCCESS);
 }
@@ -745,14 +745,14 @@ void
 dns__rbtdb_attachversion(dns_db_t *db, dns_dbversion_t *source,
                         dns_dbversion_t **targetp) {
        dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
-       dns_rbtdb_version_t *rbtversion = source;
+       dns_rbtdb_version_t *rbtversion = (dns_rbtdb_version_t *)source;
 
        REQUIRE(VALID_RBTDB(rbtdb));
        INSIST(rbtversion != NULL && rbtversion->rbtdb == rbtdb);
 
        isc_refcount_increment(&rbtversion->references);
 
-       *targetp = rbtversion;
+       *targetp = source;
 }
 
 static rbtdb_changed_t *
@@ -1604,8 +1604,8 @@ dns__rbtdb_setsecure(dns_db_t *db, dns_rbtdb_version_t *version,
        REQUIRE(version != NULL);
 
        dns_rdataset_init(&keyset);
-       result = dns_db_findrdataset(db, origin, version, dns_rdatatype_dnskey,
-                                    0, 0, &keyset, NULL);
+       result = dns_db_findrdataset(db, origin, (dns_dbversion_t *)version,
+                                    dns_rdatatype_dnskey, 0, 0, &keyset, NULL);
        if (result == ISC_R_SUCCESS) {
                result = dns_rdataset_first(&keyset);
                while (result == ISC_R_SUCCESS) {
@@ -1627,8 +1627,9 @@ dns__rbtdb_setsecure(dns_db_t *db, dns_rbtdb_version_t *version,
 
        dns_rdataset_init(&nsecset);
        dns_rdataset_init(&signsecset);
-       result = dns_db_findrdataset(db, origin, version, dns_rdatatype_nsec, 0,
-                                    0, &nsecset, &signsecset);
+       result = dns_db_findrdataset(db, origin, (dns_dbversion_t *)version,
+                                    dns_rdatatype_nsec, 0, 0, &nsecset,
+                                    &signsecset);
        if (result == ISC_R_SUCCESS) {
                if (dns_rdataset_isassociated(&signsecset)) {
                        hasnsec = true;
@@ -2359,7 +2360,7 @@ dns__rbtdb_allrdatasets(dns_db_t *db, dns_dbnode_t *node,
                        dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) {
        dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
        dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
-       dns_rbtdb_version_t *rbtversion = version;
+       dns_rbtdb_version_t *rbtversion = (dns_rbtdb_version_t *)version;
        rbtdb_rdatasetiter_t *iterator = NULL;
        uint_fast32_t refs;
 
@@ -3258,7 +3259,7 @@ dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node,
                       dns_rdataset_t *addedrdataset DNS__DB_FLARG) {
        dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
        dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
-       dns_rbtdb_version_t *rbtversion = version;
+       dns_rbtdb_version_t *rbtversion = (dns_rbtdb_version_t *)version;
        isc_region_t region;
        dns_slabheader_t *newheader = NULL;
        isc_result_t result;
@@ -3488,7 +3489,7 @@ dns__rbtdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node,
                            dns_rdataset_t *newrdataset DNS__DB_FLARG) {
        dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
        dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
-       dns_rbtdb_version_t *rbtversion = version;
+       dns_rbtdb_version_t *rbtversion = (dns_rbtdb_version_t *)version;
        dns_fixedname_t fname;
        dns_name_t *nodename = dns_fixedname_initname(&fname);
        dns_slabheader_t *topheader = NULL, *topheader_prev = NULL;
@@ -3687,18 +3688,6 @@ dns__rbtdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node,
 unlock:
        NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
 
-       /*
-        * Update the zone's secure status.  If version is non-NULL
-        * this is deferred until dns__rbtdb_closeversion() is called.
-        */
-       if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(rbtdb)) {
-               RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
-               version = rbtdb->current_version;
-               RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
-               dns__rbtdb_setsecure(db, version,
-                                    (dns_dbnode_t *)rbtdb->origin_node);
-       }
-
        return (result);
 }
 
@@ -3708,7 +3697,7 @@ dns__rbtdb_deleterdataset(dns_db_t *db, dns_dbnode_t *node,
                          dns_rdatatype_t covers DNS__DB_FLARG) {
        dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
        dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
-       dns_rbtdb_version_t *rbtversion = version;
+       dns_rbtdb_version_t *rbtversion = (dns_rbtdb_version_t *)version;
        dns_fixedname_t fname;
        dns_name_t *nodename = dns_fixedname_initname(&fname);
        isc_result_t result;
@@ -3745,11 +3734,11 @@ dns__rbtdb_deleterdataset(dns_db_t *db, dns_dbnode_t *node,
         * Update the zone's secure status.  If version is non-NULL
         * this is deferred until dns__rbtdb_closeversion() is called.
         */
-       if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(rbtdb)) {
+       if (result == ISC_R_SUCCESS && rbtversion == NULL && !IS_CACHE(rbtdb)) {
                RWLOCK(&rbtdb->lock, isc_rwlocktype_read);
-               version = rbtdb->current_version;
+               rbtversion = rbtdb->current_version;
                RWUNLOCK(&rbtdb->lock, isc_rwlocktype_read);
-               dns__rbtdb_setsecure(db, version,
+               dns__rbtdb_setsecure(db, rbtversion,
                                     (dns_dbnode_t *)rbtdb->origin_node);
        }
 
@@ -4150,7 +4139,8 @@ rdatasetiter_first(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
        rbtdb_rdatasetiter_t *rbtiterator = (rbtdb_rdatasetiter_t *)iterator;
        dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)(rbtiterator->common.db);
        dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)rbtiterator->common.node;
-       dns_rbtdb_version_t *rbtversion = rbtiterator->common.version;
+       dns_rbtdb_version_t *rbtversion =
+               (dns_rbtdb_version_t *)rbtiterator->common.version;
        dns_slabheader_t *header = NULL, *top_next = NULL;
        uint32_t serial = IS_CACHE(rbtdb) ? 1 : rbtversion->serial;
        isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
@@ -4198,7 +4188,8 @@ rdatasetiter_next(dns_rdatasetiter_t *iterator DNS__DB_FLARG) {
        rbtdb_rdatasetiter_t *rbtiterator = (rbtdb_rdatasetiter_t *)iterator;
        dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)(rbtiterator->common.db);
        dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)rbtiterator->common.node;
-       dns_rbtdb_version_t *rbtversion = rbtiterator->common.version;
+       dns_rbtdb_version_t *rbtversion =
+               (dns_rbtdb_version_t *)rbtiterator->common.version;
        dns_slabheader_t *header = NULL, *top_next = NULL;
        uint32_t serial = IS_CACHE(rbtdb) ? 1 : rbtversion->serial;
        dns_typepair_t type, negtype;

diff --git a/lib/dns/sdlz.c b/lib/dns/sdlz.c
index cd5b18620e82ce14ca444cbbb713718508398102..46c20a6b09525f10c96620d02b87f3e743c5a6aa 100644 (file)
--- a/lib/dns/sdlz.c
+++ b/lib/dns/sdlz.c
@@ -336,7 +336,8 @@ newversion(dns_db_t *db, dns_dbversion_t **versionp) {
        dns_name_format(&sdlz->common.origin, origin, sizeof(origin));
 
        result = sdlz->dlzimp->methods->newversion(
-               origin, sdlz->dlzimp->driverarg, sdlz->dbdata, versionp);
+               origin, sdlz->dlzimp->driverarg, sdlz->dbdata,
+               (void **)versionp);
        if (result != ISC_R_SUCCESS) {
                sdlz_log(ISC_LOG_ERROR,
                         "sdlz newversion on origin %s failed : %s", origin,
@@ -380,7 +381,7 @@ closeversion(dns_db_t *db, dns_dbversion_t **versionp,
 
        sdlz->dlzimp->methods->closeversion(origin, commit,
                                            sdlz->dlzimp->driverarg,
-                                           sdlz->dbdata, versionp);
+                                           sdlz->dbdata, (void **)versionp);
        if (*versionp != NULL) {
                sdlz_log(ISC_LOG_ERROR, "sdlz closeversion on origin %s failed",
                         origin);

diff --git a/lib/dns/zone.c b/lib/dns/zone.c
index 828f61161c8c3e71264d592fdc2e5f2cdde44ace..f09da85cf72744bfb2cfebefcc7ed203a412b066 100644 (file)
--- a/lib/dns/zone.c
+++ b/lib/dns/zone.c
@@ -17285,7 +17285,7 @@ restore_nsec3param(dns_zone_t *zone, dns_db_t *db, dns_dbversion_t *version,
 }
 
 static isc_result_t
-copy_non_dnssec_records(dns_db_t *db, dns_db_t *version, dns_db_t *rawdb,
+copy_non_dnssec_records(dns_db_t *db, dns_dbversion_t *version, dns_db_t *rawdb,
                        dns_dbiterator_t *dbiterator, unsigned int *oldserial) {
        dns_dbnode_t *rawnode = NULL, *node = NULL;
        dns_fixedname_t fixed;