fixup!

review comments from ondrej, thanks!

CHANGES

@@ -1,3 +1,7 @@
+5873.	[cleanup]	The rdataset->privateN fields now have more helpful
+			names, to help programmers understand how BIND's
+			internals represent DNS records. [GL #3273]
+
 5872.	[bug]		udp_recv() in dispatch could trigger an INSIST when the
 			callback's result indicated success but the response
 			was canceled in the meantime. [GL #3300]

lib/dns/include/dns/rdataset.h

@@ -131,19 +131,69 @@ struct dns_rdataset {
 	 */
 	isc_stdtime_t resign;
 
-	/*@{*/
 	/*%
-	 * These are for use by the rdataset implementation, and MUST NOT
-	 * be changed by clients.
+	 * Extra fields used by various rdataset implementations, that is, by
+	 * the code referred to in the rdataset methods table. The names of
+	 * the structures roughly correspond to the file containing the
+	 * implementation, except that `rdlist` is used by `rdatalist.c`,
+	 * `sdb.c`, and `sdlz.c`.
+	 *
+	 * Pointers in these structs use incomplete structure types,
+	 * because the structure definitions and corresponding typedef
+	 * names might not be in scope in this header.
 	 */
-	void	     *private1;
-	void	     *private2;
-	void	     *private3;
-	unsigned int privateuint4;
-	void	     *private5;
-	const void  *private6;
-	const void  *private7;
-	/*@}*/
+	union {
+		struct {
+			struct dns_keynode *node;
+			dns_rdata_t	    *iter;
+		} keytable;
+		/*
+		 * An ncache rdataset is a view of memory held elsewhere:
+		 * raw can point to either a buffer on the stack or an
+		 * rbtdb rdataslab.
+		 */
+		struct {
+			unsigned char *raw;
+			unsigned char *iter_pos;
+			unsigned int   iter_count;
+		} ncache;
+		/*
+		 * An rbtdb rdataset refers to an rdataslab. There are two
+		 * sets of rdataset methods in rbtdb.c: full-fat
+		 * rdataset_methods and the reduced slab_methods.
+		 *
+		 * For the rdataset_methods, raw points to memory immediately
+		 * following an rdatasetheader.
+		 *
+		 * The slab_methods are used by rdatasets returned by the
+		 * `getnoqname` and `getclosest` methods; in these rdatasets,
+		 * raw refers to a bare rdataslab that belongs to an
+		 * rdatasetheader's `noqname` or `closest` fields.
+		 */
+		struct {
+			struct dns_db *db;
+			dns_dbnode_t  *node;
+			unsigned char *raw;
+			unsigned char *iter_pos;
+			unsigned int   iter_count;
+			/* struct noqname is declared inside rbtdb.c */
+			struct noqname *noqname, *closest;
+		} rbtdb;
+		struct {
+			struct dns_rdatalist *list;
+			struct dns_rdata	 *iter;
+			/*
+			 * These refer to names passed in by the caller of
+			 * dns_rdataset_addnoqname() and _addclosest()
+			 */
+			const struct dns_name *noqname, *closest;
+			/*
+			 * sdb and sdlz inherit from rdatalist,
+			 * and use this extra field
+			 */
+			dns_dbnode_t *node;
+		} rdlist;
+	};
 };
 
 /*!

lib/dns/keytable.c

@@ -232,11 +232,8 @@ add_ds(dns_keynode_t *knode, dns_rdata_ds_t *ds, isc_mem_t *mctx) {
 		knode->dsset.type = knode->dslist->type;
 		knode->dsset.covers = knode->dslist->covers;
 		knode->dsset.ttl = knode->dslist->ttl;
-		knode->dsset.private1 = knode;
-		knode->dsset.private2 = NULL;
-		knode->dsset.private3 = NULL;
-		knode->dsset.privateuint4 = 0;
-		knode->dsset.private5 = NULL;
+		knode->dsset.keytable.node = knode;
+		knode->dsset.keytable.iter = NULL;
 		knode->dsset.trust = dns_trust_ultimate;
 	}
 
@@ -851,31 +848,20 @@ dns_keynode_trust(dns_keynode_t *keynode) {
 
 static void
 keynode_disassociate(dns_rdataset_t *rdataset) {
-	dns_keynode_t *keynode;
-
-	REQUIRE(rdataset != NULL);
-	REQUIRE(rdataset->methods == &methods);
-
 	rdataset->methods = NULL;
-	keynode = rdataset->private1;
-	rdataset->private1 = NULL;
-
-	keynode_detach(keynode->mctx, &keynode);
+	keynode_detach(rdataset->keytable.node->mctx, &rdataset->keytable.node);
 }
 
 static isc_result_t
 keynode_first(dns_rdataset_t *rdataset) {
 	dns_keynode_t *keynode;
 
-	REQUIRE(rdataset != NULL);
-	REQUIRE(rdataset->methods == &methods);
-
-	keynode = rdataset->private1;
+	keynode = rdataset->keytable.node;
 	RWLOCK(&keynode->rwlock, isc_rwlocktype_read);
-	rdataset->private2 = ISC_LIST_HEAD(keynode->dslist->rdata);
+	rdataset->keytable.iter = ISC_LIST_HEAD(keynode->dslist->rdata);
 	RWUNLOCK(&keynode->rwlock, isc_rwlocktype_read);
 
-	if (rdataset->private2 == NULL) {
+	if (rdataset->keytable.iter == NULL) {
 		return (ISC_R_NOMORE);
 	}
 
@@ -887,20 +873,17 @@ keynode_next(dns_rdataset_t *rdataset) {
 	dns_keynode_t *keynode;
 	dns_rdata_t *rdata;
 
-	REQUIRE(rdataset != NULL);
-	REQUIRE(rdataset->methods == &methods);
-
-	rdata = rdataset->private2;
+	rdata = rdataset->keytable.iter;
 	if (rdata == NULL) {
 		return (ISC_R_NOMORE);
 	}
 
-	keynode = rdataset->private1;
+	keynode = rdataset->keytable.node;
 	RWLOCK(&keynode->rwlock, isc_rwlocktype_read);
-	rdataset->private2 = ISC_LIST_NEXT(rdata, link);
+	rdataset->keytable.iter = ISC_LIST_NEXT(rdata, link);
 	RWUNLOCK(&keynode->rwlock, isc_rwlocktype_read);
 
-	if (rdataset->private2 == NULL) {
+	if (rdataset->keytable.iter == NULL) {
 		return (ISC_R_NOMORE);
 	}
 
@@ -911,10 +894,7 @@ static void
 keynode_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) {
 	dns_rdata_t *list_rdata;
 
-	REQUIRE(rdataset != NULL);
-	REQUIRE(rdataset->methods == &methods);
-
-	list_rdata = rdataset->private2;
+	list_rdata = rdataset->keytable.iter;
 	INSIST(list_rdata != NULL);
 
 	dns_rdata_clone(list_rdata, rdata);
@@ -924,17 +904,9 @@ static void
 keynode_clone(dns_rdataset_t *source, dns_rdataset_t *target) {
 	dns_keynode_t *keynode;
 
-	REQUIRE(source != NULL);
-	REQUIRE(target != NULL);
-	REQUIRE(source->methods == &methods);
-
-	keynode = source->private1;
+	keynode = source->keytable.node;
 	isc_refcount_increment(&keynode->refcount);
 
 	*target = *source;
-
-	/*
-	 * Reset iterator state.
-	 */
-	target->private2 = NULL;
+	target->keytable.iter = NULL;
 }

lib/dns/ncache.c

@@ -424,24 +424,21 @@ rdataset_disassociate(dns_rdataset_t *rdataset) {
 
 static isc_result_t
 rdataset_first(dns_rdataset_t *rdataset) {
-	unsigned char *raw = rdataset->private3;
+	unsigned char *raw;
 	unsigned int count;
 
+	raw = rdataset->ncache.raw;
 	count = raw[0] * 256 + raw[1];
 	if (count == 0) {
-		rdataset->private5 = NULL;
+		rdataset->ncache.iter_pos = NULL;
 		return (ISC_R_NOMORE);
 	}
-	raw += 2;
 	/*
-	 * The privateuint4 field is the number of rdata beyond the cursor
-	 * position, so we decrement the total count by one before storing
-	 * it.
+	 * iter_count is the number of rdata beyond the cursor position,
+	 * so we decrement the total count by one before storing it.
 	 */
-	count--;
-	rdataset->privateuint4 = count;
-	rdataset->private5 = raw;
-
+	rdataset->ncache.iter_pos = raw + 2;
+	rdataset->ncache.iter_count = count - 1;
 	return (ISC_R_SUCCESS);
 }
 
@@ -451,49 +448,45 @@ rdataset_next(dns_rdataset_t *rdataset) {
 	unsigned int length;
 	unsigned char *raw;
 
-	count = rdataset->privateuint4;
+	raw = rdataset->ncache.iter_pos;
+	count = rdataset->ncache.iter_count;
 	if (count == 0) {
+		rdataset->ncache.iter_pos = NULL;
 		return (ISC_R_NOMORE);
 	}
-	count--;
-	rdataset->privateuint4 = count;
-	raw = rdataset->private5;
-	length = raw[0] * 256 + raw[1];
-	raw += length + 2;
-	rdataset->private5 = raw;
 
+	length = raw[0] * 256 + raw[1];
+	rdataset->ncache.iter_pos = raw + 2 + length;
+	rdataset->ncache.iter_count = count - 1;
 	return (ISC_R_SUCCESS);
 }
 
 static void
 rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) {
-	unsigned char *raw = rdataset->private5;
+	unsigned char *raw;
 	isc_region_t r;
 
+	raw = rdataset->ncache.iter_pos;
 	REQUIRE(raw != NULL);
 
 	r.length = raw[0] * 256 + raw[1];
-	raw += 2;
-	r.base = raw;
+	r.base = raw + 2;
 	dns_rdata_fromregion(rdata, rdataset->rdclass, rdataset->type, &r);
 }
 
 static void
 rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target) {
 	*target = *source;
-
-	/*
-	 * Reset iterator state.
-	 */
-	target->privateuint4 = 0;
-	target->private5 = NULL;
+	target->ncache.iter_pos = NULL;
+	target->ncache.iter_count = 0;
 }
 
 static unsigned int
 rdataset_count(dns_rdataset_t *rdataset) {
-	unsigned char *raw = rdataset->private3;
+	unsigned char *raw;
 	unsigned int count;
 
+	raw = rdataset->ncache.raw;
 	count = raw[0] * 256 + raw[1];
 
 	return (count);
@@ -501,8 +494,9 @@ rdataset_count(dns_rdataset_t *rdataset) {
 
 static void
 rdataset_settrust(dns_rdataset_t *rdataset, dns_trust_t trust) {
-	unsigned char *raw = rdataset->private3;
+	unsigned char *raw;
 
+	raw = rdataset->ncache.raw;
 	raw[-1] = (unsigned char)trust;
 	rdataset->trust = trust;
 }
@@ -539,6 +533,7 @@ dns_ncache_getrdataset(dns_rdataset_t *ncacherdataset, dns_name_t *name,
 	dns_rdataset_t rclone;
 
 	REQUIRE(ncacherdataset != NULL);
+	REQUIRE(DNS_RDATASET_VALID(ncacherdataset));
 	REQUIRE(ncacherdataset->type == 0);
 	REQUIRE((ncacherdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0);
 	REQUIRE(name != NULL);
@@ -587,17 +582,10 @@ dns_ncache_getrdataset(dns_rdataset_t *ncacherdataset, dns_name_t *name,
 	rdataset->covers = 0;
 	rdataset->ttl = ncacherdataset->ttl;
 	rdataset->trust = trust;
-	rdataset->private1 = NULL;
-	rdataset->private2 = NULL;
+	rdataset->ncache.raw = remaining.base;
+	rdataset->ncache.iter_pos = NULL;
+	rdataset->ncache.iter_count = 0;
 
-	rdataset->private3 = remaining.base;
-
-	/*
-	 * Reset iterator state.
-	 */
-	rdataset->privateuint4 = 0;
-	rdataset->private5 = NULL;
-	rdataset->private6 = NULL;
 	return (ISC_R_SUCCESS);
 }
 
@@ -687,17 +675,10 @@ dns_ncache_getsigrdataset(dns_rdataset_t *ncacherdataset, dns_name_t *name,
 	rdataset->covers = covers;
 	rdataset->ttl = ncacherdataset->ttl;
 	rdataset->trust = trust;
-	rdataset->private1 = NULL;
-	rdataset->private2 = NULL;
+	rdataset->ncache.raw = remaining.base;
+	rdataset->ncache.iter_pos = NULL;
+	rdataset->ncache.iter_count = 0;
 
-	rdataset->private3 = remaining.base;
-
-	/*
-	 * Reset iterator state.
-	 */
-	rdataset->privateuint4 = 0;
-	rdataset->private5 = NULL;
-	rdataset->private6 = NULL;
 	return (ISC_R_SUCCESS);
 }
 
@@ -709,7 +690,7 @@ dns_ncache_current(dns_rdataset_t *ncacherdataset, dns_name_t *found,
 	isc_region_t remaining, sigregion;
 	isc_buffer_t source;
 	dns_name_t tname;
-	dns_rdatatype_t type;
+	dns_rdatatype_t type, covers;
 	unsigned int count;
 	dns_rdata_rrsig_t rrsig;
 	unsigned char *raw;
@@ -737,9 +718,7 @@ dns_ncache_current(dns_rdataset_t *ncacherdataset, dns_name_t *found,
 	INSIST(trust <= dns_trust_ultimate);
 	isc_buffer_remainingregion(&source, &remaining);
 
-	rdataset->methods = &rdataset_methods;
-	rdataset->rdclass = ncacherdataset->rdclass;
-	rdataset->type = type;
+	covers = 0;
 	if (type == dns_rdatatype_rrsig) {
 		/*
 		 * Extract covers from RRSIG.
@@ -755,21 +734,16 @@ dns_ncache_current(dns_rdataset_t *ncacherdataset, dns_name_t *found,
 		dns_rdata_fromregion(&rdata, rdataset->rdclass, rdataset->type,
 				     &sigregion);
 		(void)dns_rdata_tostruct(&rdata, &rrsig, NULL);
-		rdataset->covers = rrsig.covered;
-	} else {
-		rdataset->covers = 0;
+		covers = rrsig.covered;
 	}
+
+	rdataset->methods = &rdataset_methods;
+	rdataset->rdclass = ncacherdataset->rdclass;
+	rdataset->type = type;
+	rdataset->covers = covers;
 	rdataset->ttl = ncacherdataset->ttl;
 	rdataset->trust = trust;
-	rdataset->private1 = NULL;
-	rdataset->private2 = NULL;
-
-	rdataset->private3 = remaining.base;
-
-	/*
-	 * Reset iterator state.
-	 */
-	rdataset->privateuint4 = 0;
-	rdataset->private5 = NULL;
-	rdataset->private6 = NULL;
+	rdataset->ncache.raw = remaining.base;
+	rdataset->ncache.iter_pos = NULL;
+	rdataset->ncache.iter_count = 0;
 }

lib/dns/rbtdb.c

@@ -241,6 +241,24 @@ typedef ISC_LIST(dns_rbtnode_t) rbtnodelist_t;
 #define RDATASET_ATTR_ANCIENT	   0x2000
 #define RDATASET_ATTR_STALE_WINDOW 0x4000
 
+/*
+ * Pointer arithmetic to get the address of the raw memory following
+ * an rdatasetheader.
+ */
+static rdatasetheader_t *
+header_from_raw(void *raw) {
+	rdatasetheader_t *header = raw;
+	return (header - 1);
+}
+
+static void *
+raw_from_header(rdatasetheader_t *header) {
+	return (header + 1);
+}
+
+#define RDATASET_RBTDB(r)   ((dns_rbtdb_t *)(r)->rbtdb.db)
+#define RDATASET_RBTNODE(r) ((dns_rbtnode_t *)(r)->rbtdb.node)
+
 /*
  * XXX
  * When the cache will pre-expire data (due to memory low or other
@@ -2298,7 +2316,7 @@ setnsec3parameters(dns_db_t *db, rbtdb_version_t *version) {
 			/*
 			 * Find A NSEC3PARAM with a supported algorithm.
 			 */
-			raw = (unsigned char *)header + sizeof(*header);
+			raw = raw_from_header(header);
 			count = raw[0] * 256 + raw[1]; /* count */
 			raw += DNS_RDATASET_COUNT + DNS_RDATASET_LENGTH;
 			while (count-- > 0U) {
@@ -2961,7 +2979,6 @@ static void
 bind_rdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, rdatasetheader_t *header,
 	      isc_stdtime_t now, isc_rwlocktype_t locktype,
 	      dns_rdataset_t *rdataset) {
-	unsigned char *raw; /* RDATASLAB */
 	bool stale = STALE(header);
 	bool ancient = ANCIENT(header);
 
@@ -3040,30 +3057,26 @@ bind_rdataset(dns_rbtdb_t *rbtdb, dns_rbtnode_t *node, rdatasetheader_t *header,
 		rdataset->ttl = header->rdh_ttl;
 	}
 
-	rdataset->private1 = rbtdb;
-	rdataset->private2 = node;
-	raw = (unsigned char *)header + sizeof(*header);
-	rdataset->private3 = raw;
 	rdataset->count = atomic_fetch_add_relaxed(&header->count, 1);
 	if (rdataset->count == UINT32_MAX) {
 		rdataset->count = 0;
 	}
 
-	/*
-	 * Reset iterator state.
-	 */
-	rdataset->privateuint4 = 0;
-	rdataset->private5 = NULL;
+	rdataset->rbtdb.db = (dns_db_t *)rbtdb;
+	rdataset->rbtdb.node = (dns_dbnode_t *)node;
+	rdataset->rbtdb.raw = raw_from_header(header);
+	rdataset->rbtdb.iter_pos = NULL;
+	rdataset->rbtdb.iter_count = 0;
 
 	/*
 	 * Add noqname proof.
 	 */
-	rdataset->private6 = header->noqname;
-	if (rdataset->private6 != NULL) {
+	rdataset->rbtdb.noqname = header->noqname;
+	if (header->noqname != NULL) {
 		rdataset->attributes |= DNS_RDATASETATTR_NOQNAME;
 	}
-	rdataset->private7 = header->closest;
-	if (rdataset->private7 != NULL) {
+	rdataset->rbtdb.closest = header->closest;
+	if (header->closest != NULL) {
 		rdataset->attributes |= DNS_RDATASETATTR_CLOSEST;
 	}
 
@@ -3147,7 +3160,6 @@ valid_glue(rbtdb_search_t *search, dns_name_t *name, rbtdb_rdatatype_t type,
 	bool valid = false;
 	dns_offsets_t offsets;
 	isc_region_t region;
-	rdatasetheader_t *header;
 
 	/*
 	 * No additional locking is required.
@@ -3167,8 +3179,7 @@ valid_glue(rbtdb_search_t *search, dns_name_t *name, rbtdb_rdatatype_t type,
 		return (false);
 	}
 
-	header = search->zonecut_rdataset;
-	raw = (unsigned char *)header + sizeof(*header);
+	raw = raw_from_header(search->zonecut_rdataset);
 	count = raw[0] * 256 + raw[1];
 	raw += DNS_RDATASET_COUNT + DNS_RDATASET_LENGTH;
 
@@ -7742,9 +7753,9 @@ setsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, isc_stdtime_t resign) {
 	REQUIRE(VALID_RBTDB(rbtdb));
 	REQUIRE(!IS_CACHE(rbtdb));
 	REQUIRE(rdataset != NULL);
+	REQUIRE(rdataset->methods == &rdataset_methods);
 
-	header = rdataset->private3;
-	header--;
+	header = header_from_raw(rdataset->rbtdb.raw);
 
 	NODE_LOCK(&rbtdb->node_locks[header->node->locknum].lock,
 		  isc_rwlocktype_write);
@@ -7875,11 +7886,11 @@ resigned(dns_db_t *db, dns_rdataset_t *rdataset, dns_dbversion_t *version) {
 	REQUIRE(rbtversion->writer);
 	REQUIRE(rbtversion->rbtdb == rbtdb);
 
-	node = rdataset->private2;
-	INSIST(node != NULL);
-	header = rdataset->private3;
-	INSIST(header != NULL);
-	header--;
+	INSIST(rdataset->rbtdb.node != NULL);
+	INSIST(rdataset->rbtdb.raw != NULL);
+
+	node = (dns_rbtnode_t *)rdataset->rbtdb.node;
+	header = header_from_raw(rdataset->rbtdb.raw);
 
 	if (header->heap_index == 0) {
 		return;
@@ -8359,20 +8370,22 @@ cleanup_tree_lock:
 
 static void
 rdataset_disassociate(dns_rdataset_t *rdataset) {
-	dns_db_t *db = rdataset->private1;
-	dns_dbnode_t *node = rdataset->private2;
+	dns_db_t *db = rdataset->rbtdb.db;
+	dns_dbnode_t *node = rdataset->rbtdb.node;
 
 	detachnode(db, &node);
 }
 
 static isc_result_t
 rdataset_first(dns_rdataset_t *rdataset) {
-	unsigned char *raw = rdataset->private3; /* RDATASLAB */
+	unsigned char *raw;
 	unsigned int count;
 
+	raw = rdataset->rbtdb.raw;
 	count = raw[0] * 256 + raw[1];
 	if (count == 0) {
-		rdataset->private5 = NULL;
+		rdataset->rbtdb.iter_pos = NULL;
+		rdataset->rbtdb.iter_count = 0;
 		return (ISC_R_NOMORE);
 	}
 
@@ -8380,20 +8393,17 @@ rdataset_first(dns_rdataset_t *rdataset) {
 		raw += DNS_RDATASET_COUNT;
 	}
 
-	raw += DNS_RDATASET_LENGTH;
-
 	/*
-	 * The privateuint4 field is the number of rdata beyond the
-	 * cursor position, so we decrement the total count by one
-	 * before storing it.
+	 * iter_count is the number of rdata beyond the cursor
+	 * position, so we decrement the total count by one before
+	 * storing it.
 	 *
 	 * If DNS_RDATASETATTR_LOADORDER is not set 'raw' points to the
 	 * first record.  If DNS_RDATASETATTR_LOADORDER is set 'raw' points
 	 * to the first entry in the offset table.
 	 */
-	count--;
-	rdataset->privateuint4 = count;
-	rdataset->private5 = raw;
+	rdataset->rbtdb.iter_pos = raw + DNS_RDATASET_LENGTH;
+	rdataset->rbtdb.iter_count = count - 1;
 
 	return (ISC_R_SUCCESS);
 }
@@ -8402,19 +8412,19 @@ static isc_result_t
 rdataset_next(dns_rdataset_t *rdataset) {
 	unsigned int count;
 	unsigned int length;
-	unsigned char *raw; /* RDATASLAB */
+	unsigned char *raw;
 
-	count = rdataset->privateuint4;
+	count = rdataset->rbtdb.iter_count;
 	if (count == 0) {
+		rdataset->rbtdb.iter_pos = NULL;
 		return (ISC_R_NOMORE);
 	}
-	count--;
-	rdataset->privateuint4 = count;
+	rdataset->rbtdb.iter_count = count - 1;
 
 	/*
 	 * Skip forward one record (length + 4) or one offset (4).
 	 */
-	raw = rdataset->private5;
+	raw = rdataset->rbtdb.iter_pos;
 #if DNS_RDATASET_FIXED
 	if ((rdataset->attributes & DNS_RDATASETATTR_LOADORDER) == 0)
 #endif /* DNS_RDATASET_FIXED */
@@ -8422,23 +8432,24 @@ rdataset_next(dns_rdataset_t *rdataset) {
 		length = raw[0] * 256 + raw[1];
 		raw += length;
 	}
-
-	rdataset->private5 = raw + DNS_RDATASET_ORDER + DNS_RDATASET_LENGTH;
+	rdataset->rbtdb.iter_pos = raw + DNS_RDATASET_ORDER +
+				     DNS_RDATASET_LENGTH;
 
 	return (ISC_R_SUCCESS);
 }
 
 static void
 rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) {
-	unsigned char *raw = rdataset->private5; /* RDATASLAB */
+	unsigned char *raw;
 	unsigned int length;
 	isc_region_t r;
 	unsigned int flags = 0;
 
+	raw = rdataset->rbtdb.iter_pos;
 	REQUIRE(raw != NULL);
 
 	/*
-	 * Find the start of the record if not already in private5
+	 * Find the start of the record if not already in iter_pos
 	 * then skip the length and order fields.
 	 */
 #if DNS_RDATASET_FIXED
@@ -8447,8 +8458,7 @@ rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) {
 		offset = ((unsigned int)raw[0] << 24) +
 			 ((unsigned int)raw[1] << 16) +
 			 ((unsigned int)raw[2] << 8) + (unsigned int)raw[3];
-		raw = rdataset->private3;
-		raw += offset;
+		raw = rdataset->rbtdb.raw + offset;
 	}
 #endif /* if DNS_RDATASET_FIXED */
 
@@ -8471,8 +8481,8 @@ rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) {
 
 static void
 rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target) {
-	dns_db_t *db = source->private1;
-	dns_dbnode_t *node = source->private2;
+	dns_db_t *db = source->rbtdb.db;
+	dns_dbnode_t *node = source->rbtdb.node;
 	dns_dbnode_t *cloned_node = NULL;
 
 	attachnode(db, node, &cloned_node);
@@ -8480,18 +8490,16 @@ rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target) {
 	*target = *source;
 	ISC_LINK_INIT(target, link);
 
-	/*
-	 * Reset iterator state.
-	 */
-	target->privateuint4 = 0;
-	target->private5 = NULL;
+	target->rbtdb.iter_pos = NULL;
+	target->rbtdb.iter_count = 0;
 }
 
 static unsigned int
 rdataset_count(dns_rdataset_t *rdataset) {
-	unsigned char *raw = rdataset->private3; /* RDATASLAB */
+	unsigned char *raw;
 	unsigned int count;
 
+	raw = rdataset->rbtdb.raw;
 	count = raw[0] * 256 + raw[1];
 
 	return (count);
@@ -8500,10 +8508,10 @@ rdataset_count(dns_rdataset_t *rdataset) {
 static isc_result_t
 rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
 		    dns_rdataset_t *nsec, dns_rdataset_t *nsecsig) {
-	dns_db_t *db = rdataset->private1;
-	dns_dbnode_t *node = rdataset->private2;
+	dns_db_t *db = rdataset->rbtdb.db;
+	dns_dbnode_t *node = rdataset->rbtdb.node;
 	dns_dbnode_t *cloned_node;
-	const struct noqname *noqname = rdataset->private6;
+	const struct noqname *noqname = rdataset->rbtdb.noqname;
 
 	cloned_node = NULL;
 	attachnode(db, node, &cloned_node);
@@ -8513,13 +8521,9 @@ rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
 	nsec->covers = 0;
 	nsec->ttl = rdataset->ttl;
 	nsec->trust = rdataset->trust;
-	nsec->private1 = rdataset->private1;
-	nsec->private2 = rdataset->private2;
-	nsec->private3 = noqname->neg;
-	nsec->privateuint4 = 0;
-	nsec->private5 = NULL;
-	nsec->private6 = NULL;
-	nsec->private7 = NULL;
+	nsec->rbtdb.db = db;
+	nsec->rbtdb.node = node;
+	nsec->rbtdb.raw = noqname->neg;
 
 	cloned_node = NULL;
 	attachnode(db, node, &cloned_node);
@@ -8529,13 +8533,9 @@ rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
 	nsecsig->covers = noqname->type;
 	nsecsig->ttl = rdataset->ttl;
 	nsecsig->trust = rdataset->trust;
-	nsecsig->private1 = rdataset->private1;
-	nsecsig->private2 = rdataset->private2;
-	nsecsig->private3 = noqname->negsig;
-	nsecsig->privateuint4 = 0;
-	nsecsig->private5 = NULL;
-	nsec->private6 = NULL;
-	nsec->private7 = NULL;
+	nsecsig->rbtdb.db = db;
+	nsecsig->rbtdb.node = node;
+	nsecsig->rbtdb.raw = noqname->negsig;
 
 	dns_name_clone(&noqname->name, name);
 
@@ -8545,10 +8545,10 @@ rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
 static isc_result_t
 rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
 		    dns_rdataset_t *nsec, dns_rdataset_t *nsecsig) {
-	dns_db_t *db = rdataset->private1;
-	dns_dbnode_t *node = rdataset->private2;
+	dns_db_t *db = rdataset->rbtdb.db;
+	dns_dbnode_t *node = rdataset->rbtdb.node;
 	dns_dbnode_t *cloned_node;
-	const struct noqname *closest = rdataset->private7;
+	const struct noqname *closest = rdataset->rbtdb.closest;
 
 	cloned_node = NULL;
 	attachnode(db, node, &cloned_node);
@@ -8558,13 +8558,9 @@ rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
 	nsec->covers = 0;
 	nsec->ttl = rdataset->ttl;
 	nsec->trust = rdataset->trust;
-	nsec->private1 = rdataset->private1;
-	nsec->private2 = rdataset->private2;
-	nsec->private3 = closest->neg;
-	nsec->privateuint4 = 0;
-	nsec->private5 = NULL;
-	nsec->private6 = NULL;
-	nsec->private7 = NULL;
+	nsec->rbtdb.db = db;
+	nsec->rbtdb.node = node;
+	nsec->rbtdb.raw = closest->neg;
 
 	cloned_node = NULL;
 	attachnode(db, node, &cloned_node);
@@ -8574,13 +8570,9 @@ rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
 	nsecsig->covers = closest->type;
 	nsecsig->ttl = rdataset->ttl;
 	nsecsig->trust = rdataset->trust;
-	nsecsig->private1 = rdataset->private1;
-	nsecsig->private2 = rdataset->private2;
-	nsecsig->private3 = closest->negsig;
-	nsecsig->privateuint4 = 0;
-	nsecsig->private5 = NULL;
-	nsec->private6 = NULL;
-	nsec->private7 = NULL;
+	nsecsig->rbtdb.db = db;
+	nsecsig->rbtdb.node = node;
+	nsecsig->rbtdb.raw = closest->negsig;
 
 	dns_name_clone(&closest->name, name);
 
@@ -8589,11 +8581,10 @@ rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
 
 static void
 rdataset_settrust(dns_rdataset_t *rdataset, dns_trust_t trust) {
-	dns_rbtdb_t *rbtdb = rdataset->private1;
-	dns_rbtnode_t *rbtnode = rdataset->private2;
-	rdatasetheader_t *header = rdataset->private3;
+	dns_rbtdb_t *rbtdb = RDATASET_RBTDB(rdataset);
+	dns_rbtnode_t *rbtnode = RDATASET_RBTNODE(rdataset);
+	rdatasetheader_t *header = header_from_raw(rdataset->rbtdb.raw);
 
-	header--;
 	NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
 		  isc_rwlocktype_write);
 	header->trust = rdataset->trust = trust;
@@ -8603,11 +8594,10 @@ rdataset_settrust(dns_rdataset_t *rdataset, dns_trust_t trust) {
 
 static void
 rdataset_expire(dns_rdataset_t *rdataset) {
-	dns_rbtdb_t *rbtdb = rdataset->private1;
-	dns_rbtnode_t *rbtnode = rdataset->private2;
-	rdatasetheader_t *header = rdataset->private3;
+	dns_rbtdb_t *rbtdb = RDATASET_RBTDB(rdataset);
+	dns_rbtnode_t *rbtnode = RDATASET_RBTNODE(rdataset);
+	rdatasetheader_t *header = header_from_raw(rdataset->rbtdb.raw);
 
-	header--;
 	NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
 		  isc_rwlocktype_write);
 	expire_header(rbtdb, header, false, expire_flush);
@@ -8617,11 +8607,10 @@ rdataset_expire(dns_rdataset_t *rdataset) {
 
 static void
 rdataset_clearprefetch(dns_rdataset_t *rdataset) {
-	dns_rbtdb_t *rbtdb = rdataset->private1;
-	dns_rbtnode_t *rbtnode = rdataset->private2;
-	rdatasetheader_t *header = rdataset->private3;
+	dns_rbtdb_t *rbtdb = RDATASET_RBTDB(rdataset);
+	dns_rbtnode_t *rbtnode = RDATASET_RBTNODE(rdataset);
+	rdatasetheader_t *header = header_from_raw(rdataset->rbtdb.raw);
 
-	header--;
 	NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
 		  isc_rwlocktype_write);
 	RDATASET_ATTR_CLR(header, RDATASET_ATTR_PREFETCH);
@@ -9365,12 +9354,9 @@ setownercase(rdatasetheader_t *header, const dns_name_t *name) {
 
 static void
 rdataset_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) {
-	dns_rbtdb_t *rbtdb = rdataset->private1;
-	dns_rbtnode_t *rbtnode = rdataset->private2;
-	unsigned char *raw = rdataset->private3; /* RDATASLAB */
-	rdatasetheader_t *header;
-
-	header = (struct rdatasetheader *)(raw - sizeof(*header));
+	dns_rbtdb_t *rbtdb = RDATASET_RBTDB(rdataset);
+	dns_rbtnode_t *rbtnode = RDATASET_RBTNODE(rdataset);
+	rdatasetheader_t *header = header_from_raw(rdataset->rbtdb.raw);
 
 	NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
 		  isc_rwlocktype_write);
@@ -9381,15 +9367,12 @@ rdataset_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) {
 
 static void
 rdataset_getownercase(const dns_rdataset_t *rdataset, dns_name_t *name) {
-	dns_rbtdb_t *rbtdb = rdataset->private1;
-	dns_rbtnode_t *rbtnode = rdataset->private2;
-	unsigned char *raw = rdataset->private3; /* RDATASLAB */
-	rdatasetheader_t *header = NULL;
+	dns_rbtdb_t *rbtdb = RDATASET_RBTDB(rdataset);
+	dns_rbtnode_t *rbtnode = RDATASET_RBTNODE(rdataset);
+	rdatasetheader_t *header = header_from_raw(rdataset->rbtdb.raw);
 	uint8_t mask = (1 << 7);
 	uint8_t bits = 0;
 
-	header = (struct rdatasetheader *)(raw - sizeof(*header));
-
 	NODE_LOCK(&rbtdb->node_locks[rbtnode->locknum].lock,
 		  isc_rwlocktype_read);
 
@@ -9690,8 +9673,8 @@ glue_nsdname_cb(void *arg, const dns_name_t *name, dns_rdatatype_t qtype,
 static isc_result_t
 rdataset_addglue(dns_rdataset_t *rdataset, dns_dbversion_t *version,
 		 dns_message_t *msg) {
-	dns_rbtdb_t *rbtdb = rdataset->private1;
-	dns_rbtnode_t *node = rdataset->private2;
+	dns_rbtdb_t *rbtdb = RDATASET_RBTDB(rdataset);
+	dns_rbtnode_t *node = RDATASET_RBTNODE(rdataset);
 	rbtdb_version_t *rbtversion = version;
 	uint32_t idx;
 	rbtdb_glue_table_node_t *cur;

lib/dns/rdatalist.c

@@ -85,11 +85,7 @@ dns_rdatalist_tordataset(dns_rdatalist_t *rdatalist, dns_rdataset_t *rdataset) {
 	rdataset->covers = rdatalist->covers;
 	rdataset->ttl = rdatalist->ttl;
 	rdataset->trust = 0;
-	rdataset->private1 = rdatalist;
-	rdataset->private2 = NULL;
-	rdataset->private3 = NULL;
-	rdataset->privateuint4 = 0;
-	rdataset->private5 = NULL;
+	rdataset->rdlist.list = rdatalist;
 
 	return (ISC_R_SUCCESS);
 }
@@ -98,7 +94,9 @@ isc_result_t
 dns_rdatalist_fromrdataset(dns_rdataset_t *rdataset,
 			   dns_rdatalist_t **rdatalist) {
 	REQUIRE(rdatalist != NULL && rdataset != NULL);
-	*rdatalist = rdataset->private1;
+	REQUIRE(rdataset->methods == &methods);
+
+	*rdatalist = rdataset->rdlist.list;
 
 	return (ISC_R_SUCCESS);
 }
@@ -110,15 +108,10 @@ isc__rdatalist_disassociate(dns_rdataset_t *rdataset) {
 
 isc_result_t
 isc__rdatalist_first(dns_rdataset_t *rdataset) {
-	dns_rdatalist_t *rdatalist;
-
-	rdatalist = rdataset->private1;
-	rdataset->private2 = ISC_LIST_HEAD(rdatalist->rdata);
-
-	if (rdataset->private2 == NULL) {
+	rdataset->rdlist.iter = ISC_LIST_HEAD(rdataset->rdlist.list->rdata);
+	if (rdataset->rdlist.iter == NULL) {
 		return (ISC_R_NOMORE);
 	}
-
 	return (ISC_R_SUCCESS);
 }
 
@@ -126,16 +119,14 @@ isc_result_t
 isc__rdatalist_next(dns_rdataset_t *rdataset) {
 	dns_rdata_t *rdata;
 
-	REQUIRE(rdataset != NULL);
-
-	rdata = rdataset->private2;
+	rdata = rdataset->rdlist.iter;
 	if (rdata == NULL) {
 		return (ISC_R_NOMORE);
 	}
 
-	rdataset->private2 = ISC_LIST_NEXT(rdata, link);
+	rdataset->rdlist.iter = ISC_LIST_NEXT(rdata, link);
 
-	if (rdataset->private2 == NULL) {
+	if (rdataset->rdlist.iter == NULL) {
 		return (ISC_R_NOMORE);
 	}
 
@@ -146,9 +137,7 @@ void
 isc__rdatalist_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) {
 	dns_rdata_t *list_rdata;
 
-	REQUIRE(rdataset != NULL);
-
-	list_rdata = rdataset->private2;
+	list_rdata = rdataset->rdlist.iter;
 	INSIST(list_rdata != NULL);
 
 	dns_rdata_clone(list_rdata, rdata);
@@ -161,10 +150,7 @@ isc__rdatalist_clone(dns_rdataset_t *source, dns_rdataset_t *target) {
 
 	*target = *source;
 
-	/*
-	 * Reset iterator state.
-	 */
-	target->private2 = NULL;
+	target->rdlist.iter = NULL;
 }
 
 unsigned int
@@ -175,7 +161,7 @@ isc__rdatalist_count(dns_rdataset_t *rdataset) {
 
 	REQUIRE(rdataset != NULL);
 
-	rdatalist = rdataset->private1;
+	rdatalist = rdataset->rdlist.list;
 
 	count = 0;
 	for (rdata = ISC_LIST_HEAD(rdatalist->rdata); rdata != NULL;
@@ -235,7 +221,7 @@ isc__rdatalist_addnoqname(dns_rdataset_t *rdataset, const dns_name_t *name) {
 	}
 	rdataset->ttl = neg->ttl = negsig->ttl = ttl;
 	rdataset->attributes |= DNS_RDATASETATTR_NOQNAME;
-	rdataset->private6 = name;
+	rdataset->rdlist.noqname = name;
 	return (ISC_R_SUCCESS);
 }
 
@@ -251,7 +237,7 @@ isc__rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
 	REQUIRE((rdataset->attributes & DNS_RDATASETATTR_NOQNAME) != 0);
 
 	rdclass = rdataset->rdclass;
-	noqname = rdataset->private6;
+	noqname = rdataset->rdlist.noqname;
 
 	(void)dns_name_dynamic(noqname); /* Sanity Check. */
 
@@ -337,7 +323,7 @@ isc__rdatalist_addclosest(dns_rdataset_t *rdataset, const dns_name_t *name) {
 	}
 	rdataset->ttl = neg->ttl = negsig->ttl = ttl;
 	rdataset->attributes |= DNS_RDATASETATTR_CLOSEST;
-	rdataset->private7 = name;
+	rdataset->rdlist.closest = name;
 	return (ISC_R_SUCCESS);
 }
 
@@ -353,7 +339,7 @@ isc__rdatalist_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
 	REQUIRE((rdataset->attributes & DNS_RDATASETATTR_CLOSEST) != 0);
 
 	rdclass = rdataset->rdclass;
-	closest = rdataset->private7;
+	closest = rdataset->rdlist.closest;
 
 	(void)dns_name_dynamic(closest); /* Sanity Check. */
 
@@ -400,14 +386,11 @@ isc__rdatalist_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) {
 	 * We do not need to worry about label lengths as they are all
 	 * less than or equal to 63.
 	 */
-	rdatalist = rdataset->private1;
+	rdatalist = rdataset->rdlist.list;
 	memset(rdatalist->upper, 0, sizeof(rdatalist->upper));
 	for (i = 1; i < name->length; i++) {
 		if (name->ndata[i] >= 0x41 && name->ndata[i] <= 0x5a) {
 			rdatalist->upper[i / 8] |= 1 << (i % 8);
-			/*
-			 * Record that upper has been set.
-			 */
 		}
 	}
 	/*
@@ -421,7 +404,7 @@ isc__rdatalist_getownercase(const dns_rdataset_t *rdataset, dns_name_t *name) {
 	dns_rdatalist_t *rdatalist;
 	unsigned int i;
 
-	rdatalist = rdataset->private1;
+	rdatalist = rdataset->rdlist.list;
 	if ((rdatalist->upper[0] & 0x01) == 0) {
 		return;
 	}

lib/dns/rdataset.c

@@ -56,24 +56,11 @@ dns_rdataset_init(dns_rdataset_t *rdataset) {
 
 	REQUIRE(rdataset != NULL);
 
-	rdataset->magic = DNS_RDATASET_MAGIC;
-	rdataset->methods = NULL;
+	*rdataset = (dns_rdataset_t){
+		.magic = DNS_RDATASET_MAGIC,
+		.count = DNS_RDATASET_COUNT_UNDEFINED,
+	};
 	ISC_LINK_INIT(rdataset, link);
-	rdataset->rdclass = 0;
-	rdataset->type = 0;
-	rdataset->ttl = 0;
-	rdataset->trust = 0;
-	rdataset->covers = 0;
-	rdataset->attributes = 0;
-	rdataset->count = DNS_RDATASET_COUNT_UNDEFINED;
-	rdataset->private1 = NULL;
-	rdataset->private2 = NULL;
-	rdataset->private3 = NULL;
-	rdataset->privateuint4 = 0;
-	rdataset->private5 = NULL;
-	rdataset->private6 = NULL;
-	rdataset->private7 = NULL;
-	rdataset->resign = 0;
 }
 
 void
@@ -85,20 +72,11 @@ dns_rdataset_invalidate(dns_rdataset_t *rdataset) {
 	REQUIRE(DNS_RDATASET_VALID(rdataset));
 	REQUIRE(rdataset->methods == NULL);
 
-	rdataset->magic = 0;
+	*rdataset = (dns_rdataset_t){
+		.magic = 0,
+		.count = DNS_RDATASET_COUNT_UNDEFINED,
+	};
 	ISC_LINK_INIT(rdataset, link);
-	rdataset->rdclass = 0;
-	rdataset->type = 0;
-	rdataset->ttl = 0;
-	rdataset->trust = 0;
-	rdataset->covers = 0;
-	rdataset->attributes = 0;
-	rdataset->count = DNS_RDATASET_COUNT_UNDEFINED;
-	rdataset->private1 = NULL;
-	rdataset->private2 = NULL;
-	rdataset->private3 = NULL;
-	rdataset->privateuint4 = 0;
-	rdataset->private5 = NULL;
 }
 
 void
@@ -111,21 +89,11 @@ dns_rdataset_disassociate(dns_rdataset_t *rdataset) {
 	REQUIRE(rdataset->methods != NULL);
 
 	(rdataset->methods->disassociate)(rdataset);
-	rdataset->methods = NULL;
+	*rdataset = (dns_rdataset_t){
+		.magic = DNS_RDATASET_MAGIC,
+		.count = DNS_RDATASET_COUNT_UNDEFINED,
+	};
 	ISC_LINK_INIT(rdataset, link);
-	rdataset->rdclass = 0;
-	rdataset->type = 0;
-	rdataset->ttl = 0;
-	rdataset->trust = 0;
-	rdataset->covers = 0;
-	rdataset->attributes = 0;
-	rdataset->count = DNS_RDATASET_COUNT_UNDEFINED;
-	rdataset->private1 = NULL;
-	rdataset->private2 = NULL;
-	rdataset->private3 = NULL;
-	rdataset->privateuint4 = 0;
-	rdataset->private5 = NULL;
-	rdataset->private6 = NULL;
 }
 
 bool

lib/dns/sdb.c

@@ -1376,12 +1376,12 @@ cleanup_lock:
 }
 
 /*
- * Rdataset Methods
+ * Rdataset Methods. The SDLZ driver is very similar.
  */
 
 static void
 disassociate(dns_rdataset_t *rdataset) {
-	dns_dbnode_t *node = rdataset->private5;
+	dns_dbnode_t *node = rdataset->rdlist.node;
 	dns_sdbnode_t *sdbnode = (dns_sdbnode_t *)node;
 	dns_db_t *db = (dns_db_t *)sdbnode->sdb;
 
@@ -1391,14 +1391,11 @@ disassociate(dns_rdataset_t *rdataset) {
 
 static void
 rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target) {
-	dns_dbnode_t *node = source->private5;
-	dns_sdbnode_t *sdbnode = (dns_sdbnode_t *)node;
+	dns_sdbnode_t *sdbnode = source->rdlist.node;
 	dns_db_t *db = (dns_db_t *)sdbnode->sdb;
-	dns_dbnode_t *tempdb = NULL;
 
 	isc__rdatalist_clone(source, target);
-	attachnode(db, node, &tempdb);
-	source->private5 = tempdb;
+	attachnode(db, source->rdlist.node, &target->rdlist.node);
 }
 
 static dns_rdatasetmethods_t sdb_rdataset_methods = {
@@ -1424,10 +1421,7 @@ static void
 list_tordataset(dns_rdatalist_t *rdatalist, dns_db_t *db, dns_dbnode_t *node,
 		dns_rdataset_t *rdataset) {
 	/*
-	 * The sdb rdataset is an rdatalist with some additions.
-	 *	- private1 & private2 are used by the rdatalist.
-	 *	- private3 & private 4 are unused.
-	 *	- private5 is the node.
+	 * The sdb rdataset is an rdatalist with an extra node pointer
 	 */
 
 	/* This should never fail. */
@@ -1435,7 +1429,7 @@ list_tordataset(dns_rdatalist_t *rdatalist, dns_db_t *db, dns_dbnode_t *node,
 		      ISC_R_SUCCESS);
 
 	rdataset->methods = &sdb_rdataset_methods;
-	dns_db_attachnode(db, node, &rdataset->private5);
+	dns_db_attachnode(db, node, &rdataset->rdlist.node);
 }
 
 /*

lib/dns/sdlz.c

@@ -1385,7 +1385,7 @@ dbiterator_origin(dns_dbiterator_t *iterator, dns_name_t *name) {
 
 static void
 disassociate(dns_rdataset_t *rdataset) {
-	dns_dbnode_t *node = rdataset->private5;
+	dns_dbnode_t *node = rdataset->rdlist.node;
 	dns_sdlznode_t *sdlznode = (dns_sdlznode_t *)node;
 	dns_db_t *db = (dns_db_t *)sdlznode->sdlz;
 
@@ -1395,14 +1395,11 @@ disassociate(dns_rdataset_t *rdataset) {
 
 static void
 rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target) {
-	dns_dbnode_t *node = source->private5;
-	dns_sdlznode_t *sdlznode = (dns_sdlznode_t *)node;
+	dns_sdlznode_t *sdlznode = source->rdlist.node;
 	dns_db_t *db = (dns_db_t *)sdlznode->sdlz;
-	dns_dbnode_t *tempdb = NULL;
 
 	isc__rdatalist_clone(source, target);
-	attachnode(db, node, &tempdb);
-	source->private5 = tempdb;
+	attachnode(db, source->rdlist.node, &target->rdlist.node);
 }
 
 static dns_rdatasetmethods_t rdataset_methods = {
@@ -1439,7 +1436,7 @@ list_tordataset(dns_rdatalist_t *rdatalist, dns_db_t *db, dns_dbnode_t *node,
 		      ISC_R_SUCCESS);
 
 	rdataset->methods = &rdataset_methods;
-	dns_db_attachnode(db, node, &rdataset->private5);
+	dns_db_attachnode(db, node, &rdataset->rdlist.node);
 }
 
 /*

lib/dns/tests/rbtdb_test.c

@@ -118,9 +118,9 @@ ownercase_test_one(const char *str1, const char *str2) {
 	unsigned char *raw = (unsigned char *)(&header) + sizeof(header);
 	dns_rdataset_t rdataset = {
 		.magic = DNS_RDATASET_MAGIC,
-		.private1 = &rbtdb,
-		.private2 = &rbtnode,
-		.private3 = raw,
+		.rbtdb = { .db = (dns_db_t *)&rbtdb,
+			   .node = &rbtnode,
+			   .raw = raw },
 		.methods = &rdataset_methods,
 	};
 
@@ -182,9 +182,9 @@ setownercase_test(void **state) {
 	unsigned char *raw = (unsigned char *)(&header) + sizeof(header);
 	dns_rdataset_t rdataset = {
 		.magic = DNS_RDATASET_MAGIC,
-		.private1 = &rbtdb,
-		.private2 = &rbtnode,
-		.private3 = raw,
+		.rbtdb = { .db = (dns_db_t *)&rbtdb,
+			   .node = &rbtnode,
+			   .raw = raw },
 		.methods = &rdataset_methods,
 	};
 	const char *str1 =