From: Tony Finch Date: Fri, 28 Apr 2023 00:12:39 +0000 (+0100) Subject: Give the rdataset->privateN fields more helpful names X-Git-Tag: v9.19.16~43^2~7 X-Git-Url: http://git.ipfire.org/gitweb/?a=commitdiff_plain;h=856a6e4afbfd1c0f274c1aa519c003304acd4ec3;p=thirdparty%2Fbind9.git Give the rdataset->privateN fields more helpful names BIND's rdataset structure is a view of some DNS records. It is polymorphic, so the details of how the records are stored can vary. For instance, the records can be held in an rdatalist, or in an rdataslab in the rbtdb. The dns_rdataset structure previously had a number of fields called `private1` up to `private7`, which were used by the various rdataset implementations. It was not at all clear what these fields were for, without reading the code and working it out from context. This change makes the rdataset inheritance hierarchy more clear. The polymorphic part of a `struct dns_rdataset` is now a union of structs, each of which is named for the class of implementation using it. The fields of these structs replace the old `privateN` fields. (Note: the term "inheritance hierarchy" refers to the fact that the builtin and SDLZ implementations are based on and inherit from the rdatalist implementation, which in turn inherits from the generic rdataset. Most of this change is mechanical, but there are a few extras. In keynode.c there were a number of REQUIRE()ments that were not necessary: they had already been checked by the rdataset method dispatch code. On the other hand, In ncache.c there was a public function which needed to REQUIRE() that an rdataset was valid. I have removed lots of "reset iterator state" comments, because it should now be clear from `target->iter = NULL` where before `target->private5 = NULL` could have been doing anything. Initialization is a bit neater in a few places, using C structure literals where appropriate. The pointer arithmetic for translating between an rdataslab header and its raw contents is now fractionally safer. --- diff --git a/bin/named/builtin.c b/bin/named/builtin.c index f2e6f2ed755..1f46f0ad4fe 100644 --- a/bin/named/builtin.c +++ b/bin/named/builtin.c @@ -608,7 +608,7 @@ ipv4reverse_lookup(bdbnode_t *node) { */ static void disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { - dns_dbnode_t *node = rdataset->private5; + dns_dbnode_t *node = rdataset->rdlist.node; bdbnode_t *bdbnode = (bdbnode_t *)node; dns_db_t *db = (dns_db_t *)bdbnode->bdb; @@ -618,13 +618,12 @@ disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { static void rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG) { - dns_dbnode_t *node = source->private5; + dns_dbnode_t *node = source->rdlist.node; bdbnode_t *bdbnode = (bdbnode_t *)node; dns_db_t *db = (dns_db_t *)bdbnode->bdb; dns_rdatalist_clone(source, target DNS__DB_FLARG_PASS); - attachnode(db, node, - (dns_dbnode_t **)&target->private5 DNS__DB_FLARG_PASS); + attachnode(db, node, &target->rdlist.node DNS__DB_FLARG_PASS); } static dns_rdatasetmethods_t bdb_rdataset_methods = { @@ -644,7 +643,7 @@ new_rdataset(dns_rdatalist_t *rdatalist, dns_db_t *db, dns_dbnode_t *node, dns_rdatalist_tordataset(rdatalist, rdataset); rdataset->methods = &bdb_rdataset_methods; - dns_db_attachnode(db, node, &rdataset->private5); + dns_db_attachnode(db, node, &rdataset->rdlist.node); } /* diff --git a/lib/dns/dnsrps.c b/lib/dns/dnsrps.c index e47ab411eae..26fce6253e0 100644 --- a/lib/dns/dnsrps.c +++ b/lib/dns/dnsrps.c @@ -40,10 +40,10 @@ static void *librpz_handle = NULL; #define RPSDB_MAGIC ISC_MAGIC('R', 'P', 'Z', 'F') #define VALID_RPSDB(rpsdb) ((rpsdb)->common.impmagic == RPSDB_MAGIC) -#define RD_DB(r) ((r)->private1) -#define RD_CUR_RR(r) ((r)->private2) +#define RD_DB(r) ((r)->rps.db) +#define RD_CUR_RR(r) ((r)->rps.iter_pos) #define RD_NEXT_RR(r) ((r)->resign) -#define RD_COUNT(r) ((r)->privateuint4) +#define RD_COUNT(r) ((r)->rps.iter_count) typedef struct { dns_rdatasetiter_t common; @@ -251,10 +251,10 @@ isc_result_t dns_dnsrps_rewrite_init(librpz_emsg_t *emsg, dns_rpz_st_t *st, dns_rpz_zones_t *rpzs, const dns_name_t *qname, isc_mem_t *mctx, bool have_rd) { - rpsdb_t *rpsdb = NULL; + dns_rpsdb_t *rpsdb = NULL; rpsdb = isc_mem_get(mctx, sizeof(*rpsdb)); - *rpsdb = (rpsdb_t){ + *rpsdb = (dns_rpsdb_t){ .common = { .methods = &rpsdb_db_methods, .rdclass = dns_rdataclass_in, @@ -359,7 +359,7 @@ dns_dnsrps_type2trig(dns_rpz_type_t type) { static void rpsdb_destroy(dns_db_t *db) { - rpsdb_t *rpsdb = (rpsdb_t *)db; + dns_rpsdb_t *rpsdb = (dns_rpsdb_t *)db; REQUIRE(VALID_RPSDB(rpsdb)); @@ -371,7 +371,7 @@ rpsdb_destroy(dns_db_t *db) { static void rpsdb_attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp) { - rpsdb_t *rpsdb = (rpsdb_t *)db; + dns_rpsdb_t *rpsdb = (dns_rpsdb_t *)db; REQUIRE(VALID_RPSDB(rpsdb)); REQUIRE(targetp != NULL && *targetp == NULL); @@ -383,7 +383,7 @@ rpsdb_attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp) { static void rpsdb_detachnode(dns_db_t *db, dns_dbnode_t **targetp) { - rpsdb_t *rpsdb = (rpsdb_t *)db; + dns_rpsdb_t *rpsdb = (dns_rpsdb_t *)db; REQUIRE(VALID_RPSDB(rpsdb)); REQUIRE(*targetp == &rpsdb->origin_node || @@ -396,7 +396,7 @@ rpsdb_detachnode(dns_db_t *db, dns_dbnode_t **targetp) { static isc_result_t rpsdb_findnode(dns_db_t *db, const dns_name_t *name, bool create, dns_dbnode_t **nodep) { - rpsdb_t *rpsdb = (rpsdb_t *)db; + dns_rpsdb_t *rpsdb = (dns_rpsdb_t *)db; dns_db_t *dbp = NULL; REQUIRE(VALID_RPSDB(rpsdb)); @@ -422,8 +422,8 @@ rpsdb_findnode(dns_db_t *db, const dns_name_t *name, bool create, static void rpsdb_bind_rdataset(dns_rdataset_t *rdataset, uint count, librpz_idx_t next_rr, dns_rdatatype_t type, uint16_t class, uint32_t ttl, - rpsdb_t *rpsdb) { - dns_db_t *dbp; + dns_rpsdb_t *rpsdb) { + dns_db_t *dbp = NULL; INSIST(rdataset->methods == NULL); /* We must be disassociated. */ REQUIRE(type != dns_rdatatype_none); @@ -434,14 +434,14 @@ rpsdb_bind_rdataset(dns_rdataset_t *rdataset, uint count, librpz_idx_t next_rr, rdataset->ttl = ttl; dbp = NULL; dns_db_attach(&rpsdb->common, &dbp); - RD_DB(rdataset) = dbp; + RD_DB(rdataset) = (dns_rpsdb_t *)dbp; RD_COUNT(rdataset) = count; RD_NEXT_RR(rdataset) = next_rr; RD_CUR_RR(rdataset) = NULL; } static isc_result_t -rpsdb_bind_soa(dns_rdataset_t *rdataset, rpsdb_t *rpsdb) { +rpsdb_bind_soa(dns_rdataset_t *rdataset, dns_rpsdb_t *rpsdb) { uint32_t ttl; librpz_emsg_t emsg; @@ -466,7 +466,7 @@ rpsdb_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, dns_rdatatype_t type, dns_rdatatype_t covers, isc_stdtime_t now, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { - rpsdb_t *rpsdb = (rpsdb_t *)db; + dns_rpsdb_t *rpsdb = (dns_rpsdb_t *)db; dns_rdatatype_t foundtype; dns_rdataclass_t class; uint32_t ttl; @@ -576,7 +576,7 @@ rpsdb_finddb(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version, dns_rdatatype_t type, unsigned int options, isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname, dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { - dns_dbnode_t *node; + dns_dbnode_t *node = NULL; UNUSED(version); UNUSED(options); @@ -597,8 +597,8 @@ static isc_result_t rpsdb_allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version, unsigned int options, isc_stdtime_t now, dns_rdatasetiter_t **iteratorp) { - rpsdb_t *rpsdb = (rpsdb_t *)db; - rpsdb_rdatasetiter_t *rpsdb_iter; + dns_rpsdb_t *rpsdb = (dns_rpsdb_t *)db; + rpsdb_rdatasetiter_t *rpsdb_iter = NULL; UNUSED(version); UNUSED(now); @@ -632,7 +632,7 @@ rpsdb_issecure(dns_db_t *db) { static isc_result_t rpsdb_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep) { - rpsdb_t *rpsdb = (rpsdb_t *)db; + dns_rpsdb_t *rpsdb = (dns_rpsdb_t *)db; REQUIRE(VALID_RPSDB(rpsdb)); REQUIRE(nodep != NULL && *nodep == NULL); @@ -643,7 +643,7 @@ rpsdb_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep) { static void rpsdb_rdataset_disassociate(dns_rdataset_t *rdataset) { - dns_db_t *db; + dns_db_t *db = NULL; /* * Detach the last RR delivered. @@ -653,17 +653,17 @@ rpsdb_rdataset_disassociate(dns_rdataset_t *rdataset) { RD_CUR_RR(rdataset) = NULL; } - db = RD_DB(rdataset); + db = (dns_db_t *)RD_DB(rdataset); RD_DB(rdataset) = NULL; dns_db_detach(&db); } static isc_result_t rpsdb_rdataset_next(dns_rdataset_t *rdataset) { - rpsdb_t *rpsdb; + dns_rpsdb_t *rpsdb = NULL; uint16_t type; dns_rdataclass_t class; - librpz_rr_t *rr; + librpz_rr_t *rr = NULL; librpz_emsg_t emsg; rpsdb = RD_DB(rdataset); @@ -718,7 +718,7 @@ rpsdb_rdataset_next(dns_rdataset_t *rdataset) { static isc_result_t rpsdb_rdataset_first(dns_rdataset_t *rdataset) { - rpsdb_t *rpsdb; + dns_rpsdb_t *rpsdb = NULL; librpz_emsg_t emsg; rpsdb = RD_DB(rdataset); @@ -744,8 +744,8 @@ rpsdb_rdataset_first(dns_rdataset_t *rdataset) { static void rpsdb_rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { - rpsdb_t *rpsdb; - librpz_rr_t *rr; + dns_rpsdb_t *rpsdb = NULL; + librpz_rr_t *rr = NULL; isc_region_t r; rpsdb = RD_DB(rdataset); @@ -760,8 +760,8 @@ rpsdb_rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { static void rpsdb_rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target) { - rpsdb_t *rpsdb; - dns_db_t *dbp; + dns_rpsdb_t *rpsdb = NULL; + dns_db_t *dbp = NULL; INSIST(!ISC_LINK_LINKED(target, link)); *target = *source; @@ -770,14 +770,14 @@ rpsdb_rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target) { REQUIRE(VALID_RPSDB(rpsdb)); dbp = NULL; dns_db_attach(&rpsdb->common, &dbp); - RD_DB(target) = dbp; + RD_DB(target) = (dns_rpsdb_t *)dbp; RD_CUR_RR(target) = NULL; RD_NEXT_RR(target) = LIBRPZ_IDX_NULL; } static unsigned int rpsdb_rdataset_count(dns_rdataset_t *rdataset) { - rpsdb_t *rpsdb; + dns_rpsdb_t *rpsdb = NULL; rpsdb = RD_DB(rdataset); REQUIRE(VALID_RPSDB(rpsdb)); @@ -787,13 +787,13 @@ rpsdb_rdataset_count(dns_rdataset_t *rdataset) { static void rpsdb_rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp) { - rpsdb_t *rpsdb; - dns_rdatasetiter_t *iterator; - isc_mem_t *mctx; + dns_rpsdb_t *rpsdb = NULL; + dns_rdatasetiter_t *iterator = NULL; + isc_mem_t *mctx = NULL; iterator = *iteratorp; *iteratorp = NULL; - rpsdb = (rpsdb_t *)iterator->db; + rpsdb = (dns_rpsdb_t *)iterator->db; REQUIRE(VALID_RPSDB(rpsdb)); mctx = iterator->db->mctx; @@ -803,14 +803,14 @@ rpsdb_rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp) { static isc_result_t rpsdb_rdatasetiter_next(dns_rdatasetiter_t *iter) { - rpsdb_t *rpsdb; - rpsdb_rdatasetiter_t *rpsdb_iter; + dns_rpsdb_t *rpsdb = NULL; + rpsdb_rdatasetiter_t *rpsdb_iter = NULL; dns_rdatatype_t next_type, type; dns_rdataclass_t next_class, class; uint32_t ttl; librpz_emsg_t emsg; - rpsdb = (rpsdb_t *)iter->db; + rpsdb = (dns_rpsdb_t *)iter->db; REQUIRE(VALID_RPSDB(rpsdb)); rpsdb_iter = (rpsdb_rdatasetiter_t *)iter; @@ -873,10 +873,10 @@ rpsdb_rdatasetiter_next(dns_rdatasetiter_t *iter) { static isc_result_t rpsdb_rdatasetiter_first(dns_rdatasetiter_t *iterator) { - rpsdb_t *rpsdb; - rpsdb_rdatasetiter_t *rpsdb_iter; + dns_rpsdb_t *rpsdb = NULL; + rpsdb_rdatasetiter_t *rpsdb_iter = NULL; - rpsdb = (rpsdb_t *)iterator->db; + rpsdb = (dns_rpsdb_t *)iterator->db; REQUIRE(VALID_RPSDB(rpsdb)); rpsdb_iter = (rpsdb_rdatasetiter_t *)iterator; @@ -888,10 +888,10 @@ rpsdb_rdatasetiter_first(dns_rdatasetiter_t *iterator) { static void rpsdb_rdatasetiter_current(dns_rdatasetiter_t *iterator, dns_rdataset_t *rdataset) { - rpsdb_t *rpsdb; - rpsdb_rdatasetiter_t *rpsdb_iter; + dns_rpsdb_t *rpsdb = NULL; + rpsdb_rdatasetiter_t *rpsdb_iter = NULL; - rpsdb = (rpsdb_t *)iterator->db; + rpsdb = (dns_rpsdb_t *)iterator->db; REQUIRE(VALID_RPSDB(rpsdb)); rpsdb_iter = (rpsdb_rdatasetiter_t *)iterator; REQUIRE(rpsdb_iter->type != dns_rdatatype_none); diff --git a/lib/dns/include/dns/dnsrps.h b/lib/dns/include/dns/dnsrps.h index ed297ddcc3e..219142b328c 100644 --- a/lib/dns/include/dns/dnsrps.h +++ b/lib/dns/include/dns/dnsrps.h @@ -35,9 +35,9 @@ extern librpz_emsg_t librpz_lib_open_emsg; * * All of these structures are used by a single thread and so need no locks. * - * rpsdb_t holds the state for a set of RPZ queries. + * dns_rpsdb_t holds the state for a set of RPZ queries. * - * rpsnode_t is a link to the rpsdb_t for the set of RPZ queries + * rpsnode_t is a link to the dns_rpsdb_t for the set of RPZ queries * and a flag saying whether it is pretending to be a node with RRs for * the qname or the node with the SOA for the zone containing the rewritten * RRs or justifying NXDOMAIN. @@ -45,7 +45,8 @@ extern librpz_emsg_t librpz_lib_open_emsg; typedef struct { uint8_t unused; } rpsnode_t; -typedef struct rpsdb { + +struct dns_rpsdb { dns_db_t common; int ref_cnt; librpz_result_id_t hit_id; @@ -55,7 +56,7 @@ typedef struct rpsdb { const dns_name_t *qname; rpsnode_t origin_node; rpsnode_t data_node; -} rpsdb_t; +}; /* * Convert a dnsrps policy to a classic BIND9 RPZ policy. diff --git a/lib/dns/include/dns/rdataset.h b/lib/dns/include/dns/rdataset.h index 2504edf4971..eeb433e32fd 100644 --- a/lib/dns/include/dns/rdataset.h +++ b/lib/dns/include/dns/rdataset.h @@ -134,19 +134,80 @@ 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 to an + * rdataslab, such as in an rbtdb database. + */ + struct { + unsigned char *raw; + unsigned char *iter_pos; + unsigned int iter_count; + } ncache; + + /* + * A slab rdataset provides access to an rdataslab. In + * an rbtdb database, 'raw' will generally point to the + * memory immediately following an rdatasetheader. (There + * is an exception in the case of rdatasets returned by + * the `getnoqname` and `getclosest` methods; see + * comments in rbtdb.c for details.) + */ + 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; + } slab; + + /* + * A simple rdatalist, plus an optional dbnode used by + * builtin and sdlz. + */ + 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; + dns_dbnode_t *node; + } rdlist; + +#ifdef USE_DNSRPS + /* + * DNSRPS rdatasets. dns_rpsdb_t is defined in dnsrps.h. + */ + struct { + dns_rpsdb_t *db; + void *iter_pos; + unsigned int iter_count; + } rps; +#endif /* USE_DNSRPS */ + }; }; #define DNS_RDATASET_COUNT_UNDEFINED UINT32_MAX diff --git a/lib/dns/include/dns/types.h b/lib/dns/include/dns/types.h index e0a0b27f785..27854f0b192 100644 --- a/lib/dns/include/dns/types.h +++ b/lib/dns/include/dns/types.h @@ -135,6 +135,7 @@ typedef struct dns_remote dns_remote_t; typedef struct dns_request dns_request_t; typedef struct dns_requestmgr dns_requestmgr_t; typedef struct dns_resolver dns_resolver_t; +typedef struct dns_rpsdb dns_rpsdb_t; typedef uint8_t dns_secalg_t; typedef uint8_t dns_secproto_t; typedef struct dns_signature dns_signature_t; diff --git a/lib/dns/keytable.c b/lib/dns/keytable.c index a4acc89098e..aa8c66ef81e 100644 --- a/lib/dns/keytable.c +++ b/lib/dns/keytable.c @@ -220,11 +220,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; } @@ -858,12 +855,9 @@ static void keynode_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { dns_keynode_t *keynode; - REQUIRE(rdataset != NULL); - REQUIRE(rdataset->methods == &methods); - rdataset->methods = NULL; - keynode = rdataset->private1; - rdataset->private1 = NULL; + keynode = rdataset->keytable.node; + rdataset->keytable.node = NULL; keynode_detach(keynode->mctx, &keynode); } @@ -872,15 +866,12 @@ 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); } @@ -892,20 +883,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); } @@ -916,10 +904,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); @@ -929,17 +914,9 @@ static void keynode_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG) { 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; } diff --git a/lib/dns/ncache.c b/lib/dns/ncache.c index 162309b2259..7a85368145b 100644 --- a/lib/dns/ncache.c +++ b/lib/dns/ncache.c @@ -423,24 +423,21 @@ rdataset_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { 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); } @@ -450,49 +447,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 DNS__DB_FLARG) { *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); @@ -500,8 +493,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; } @@ -529,6 +523,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); @@ -577,17 +572,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); } @@ -678,17 +666,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->private3 = remaining.base; + rdataset->ncache.raw = remaining.base; + rdataset->ncache.iter_pos = NULL; + rdataset->ncache.iter_count = 0; - /* - * Reset iterator state. - */ - rdataset->privateuint4 = 0; - rdataset->private5 = NULL; - rdataset->private6 = NULL; return (ISC_R_SUCCESS); } @@ -700,7 +681,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; @@ -728,9 +709,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. @@ -746,21 +725,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; } diff --git a/lib/dns/rbtdb.c b/lib/dns/rbtdb.c index 4db0c8cd20c..f8d3d7e55c9 100644 --- a/lib/dns/rbtdb.c +++ b/lib/dns/rbtdb.c @@ -317,6 +317,24 @@ enum { RDATASET_ATTR_STALE_WINDOW = 1 << 13, }; +/* + * 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)->slab.db) +#define RDATASET_DBNODE(r) ((dns_rbtnode_t *)(r)->slab.node) + #define EXISTS(header) \ ((atomic_load_acquire(&(header)->attributes) & \ RDATASET_ATTR_NONEXISTENT) == 0) @@ -2361,7 +2379,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) { @@ -3039,7 +3057,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 DNS__DB_FLARG) { - unsigned char *raw; /* RDATASLAB */ bool stale = STALE(header); bool ancient = ANCIENT(header); @@ -3120,27 +3137,23 @@ 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); - /* - * Reset iterator state. - */ - rdataset->privateuint4 = 0; - rdataset->private5 = NULL; + rdataset->slab.db = (dns_db_t *)rbtdb; + rdataset->slab.node = (dns_dbnode_t *)node; + rdataset->slab.raw = raw_from_header(header); + rdataset->slab.iter_pos = NULL; + rdataset->slab.iter_count = 0; /* * Add noqname proof. */ - rdataset->private6 = header->noqname; - if (rdataset->private6 != NULL) { + rdataset->slab.noqname = header->noqname; + if (header->noqname != NULL) { rdataset->attributes |= DNS_RDATASETATTR_NOQNAME; } - rdataset->private7 = header->closest; - if (rdataset->private7 != NULL) { + rdataset->slab.closest = header->closest; + if (header->closest != NULL) { rdataset->attributes |= DNS_RDATASETATTR_CLOSEST; } @@ -3227,7 +3240,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. @@ -3247,8 +3259,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; @@ -7890,9 +7901,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->slab.raw); NODE_WRLOCK(&rbtdb->node_locks[header->node->locknum].lock, &nlocktype); @@ -8026,11 +8037,11 @@ resigned(dns_db_t *db, dns_rdataset_t *rdataset, REQUIRE(rbtversion->writer); REQUIRE(rbtversion->rbtdb == rbtdb); - node = rdataset->private2; - INSIST(node != NULL); - header = rdataset->private3; - INSIST(header != NULL); - header--; + INSIST(rdataset->slab.node != NULL); + INSIST(rdataset->slab.raw != NULL); + + node = (dns_rbtnode_t *)rdataset->slab.node; + header = header_from_raw(rdataset->slab.raw); if (header->heap_index == 0) { return; @@ -8485,20 +8496,22 @@ cleanup_tree_lock: static void rdataset_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { - dns_db_t *db = rdataset->private1; - dns_dbnode_t *node = rdataset->private2; + dns_db_t *db = rdataset->slab.db; + dns_dbnode_t *node = rdataset->slab.node; dns__db_detachnode(db, &node DNS__DB_FLARG_PASS); } static isc_result_t rdataset_first(dns_rdataset_t *rdataset) { - unsigned char *raw = rdataset->private3; /* RDATASLAB */ + unsigned char *raw; unsigned int count; + raw = rdataset->slab.raw; count = raw[0] * 256 + raw[1]; if (count == 0) { - rdataset->private5 = NULL; + rdataset->slab.iter_pos = NULL; + rdataset->slab.iter_count = 0; return (ISC_R_NOMORE); } @@ -8506,20 +8519,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->slab.iter_pos = raw + DNS_RDATASET_LENGTH; + rdataset->slab.iter_count = count - 1; return (ISC_R_SUCCESS); } @@ -8528,19 +8538,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->slab.iter_count; if (count == 0) { + rdataset->slab.iter_pos = NULL; return (ISC_R_NOMORE); } - count--; - rdataset->privateuint4 = count; + rdataset->slab.iter_count = count - 1; /* * Skip forward one record (length + 4) or one offset (4). */ - raw = rdataset->private5; + raw = rdataset->slab.iter_pos; #if DNS_RDATASET_FIXED if ((rdataset->attributes & DNS_RDATASETATTR_LOADORDER) == 0) #endif /* DNS_RDATASET_FIXED */ @@ -8548,23 +8558,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->slab.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->slab.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 @@ -8573,8 +8584,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->slab.raw + offset; } #endif /* if DNS_RDATASET_FIXED */ @@ -8597,8 +8607,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_FLARG) { - dns_db_t *db = source->private1; - dns_dbnode_t *node = source->private2; + dns_db_t *db = source->slab.db; + dns_dbnode_t *node = source->slab.node; dns_dbnode_t *cloned_node = NULL; dns__db_attachnode(db, node, &cloned_node DNS__DB_FLARG_PASS); @@ -8606,18 +8616,16 @@ rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG) { *target = *source; ISC_LINK_INIT(target, link); - /* - * Reset iterator state. - */ - target->privateuint4 = 0; - target->private5 = NULL; + target->slab.iter_pos = NULL; + target->slab.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->slab.raw; count = raw[0] * 256 + raw[1]; return (count); @@ -8627,9 +8635,9 @@ static isc_result_t rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name, dns_rdataset_t *nsec, dns_rdataset_t *nsecsig DNS__DB_FLARG) { - dns_db_t *db = rdataset->private1; - dns_dbnode_t *node = rdataset->private2; - const struct noqname *noqname = rdataset->private6; + dns_db_t *db = rdataset->slab.db; + dns_dbnode_t *node = rdataset->slab.node; + const struct noqname *noqname = rdataset->slab.noqname; /* * Usually, rdataset->slab.raw refers the data following an @@ -8647,9 +8655,9 @@ rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name, .type = noqname->type, .ttl = rdataset->ttl, .trust = rdataset->trust, - .private1 = rdataset->private1, - .private2 = rdataset->private2, - .private3 = noqname->neg, + .slab.db = db, + .slab.node = node, + .slab.raw = noqname->neg, .link = nsec->link, .count = nsec->count, .attributes = nsec->attributes | DNS_RDATASETATTR_KEEPCASE, @@ -8665,9 +8673,9 @@ rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name, .covers = noqname->type, .ttl = rdataset->ttl, .trust = rdataset->trust, - .private1 = rdataset->private1, - .private2 = rdataset->private2, - .private3 = noqname->negsig, + .slab.db = db, + .slab.node = node, + .slab.raw = noqname->negsig, .link = nsecsig->link, .count = nsecsig->count, .attributes = nsecsig->attributes | DNS_RDATASETATTR_KEEPCASE, @@ -8683,9 +8691,9 @@ static isc_result_t rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name, dns_rdataset_t *nsec, dns_rdataset_t *nsecsig DNS__DB_FLARG) { - dns_db_t *db = rdataset->private1; - dns_dbnode_t *node = rdataset->private2; - const struct noqname *closest = rdataset->private7; + dns_db_t *db = rdataset->slab.db; + dns_dbnode_t *node = rdataset->slab.node; + const struct noqname *closest = rdataset->slab.closest; /* * As mentioned above, rdataset->slab.raw usually refers the data @@ -8700,9 +8708,9 @@ rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name, .type = closest->type, .ttl = rdataset->ttl, .trust = rdataset->trust, - .private1 = rdataset->private1, - .private2 = rdataset->private2, - .private3 = closest->neg, + .slab.db = db, + .slab.node = node, + .slab.raw = closest->neg, .link = nsec->link, .count = nsec->count, .attributes = nsec->attributes | DNS_RDATASETATTR_KEEPCASE, @@ -8718,9 +8726,9 @@ rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name, .covers = closest->type, .ttl = rdataset->ttl, .trust = rdataset->trust, - .private1 = rdataset->private1, - .private2 = rdataset->private2, - .private3 = closest->negsig, + .slab.db = db, + .slab.node = node, + .slab.raw = closest->negsig, .link = nsecsig->link, .count = nsecsig->count, .attributes = nsecsig->attributes | DNS_RDATASETATTR_KEEPCASE, @@ -8738,12 +8746,11 @@ 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_DBNODE(rdataset); + rdatasetheader_t *header = header_from_raw(rdataset->slab.raw); isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - header--; NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); header->trust = rdataset->trust = trust; NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); @@ -8751,13 +8758,12 @@ rdataset_settrust(dns_rdataset_t *rdataset, dns_trust_t trust) { static void rdataset_expire(dns_rdataset_t *rdataset DNS__DB_FLARG) { - 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_DBNODE(rdataset); + rdatasetheader_t *header = header_from_raw(rdataset->slab.raw); isc_rwlocktype_t nlocktype = isc_rwlocktype_none; isc_rwlocktype_t tlocktype = isc_rwlocktype_none; - header--; NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); expire_header(rbtdb, header, &nlocktype, &tlocktype, expire_flush DNS__DB_FLARG_PASS); @@ -8767,12 +8773,11 @@ rdataset_expire(dns_rdataset_t *rdataset DNS__DB_FLARG) { 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_DBNODE(rdataset); + rdatasetheader_t *header = header_from_raw(rdataset->slab.raw); isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - header--; NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); RDATASET_ATTR_CLR(header, RDATASET_ATTR_PREFETCH); NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); @@ -9464,14 +9469,11 @@ 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; + dns_rbtdb_t *rbtdb = RDATASET_RBTDB(rdataset); + dns_rbtnode_t *rbtnode = RDATASET_DBNODE(rdataset); + rdatasetheader_t *header = header_from_raw(rdataset->slab.raw); isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - header = (struct rdatasetheader *)(raw - sizeof(*header)); - NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); setownercase(header, name); NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); @@ -9479,16 +9481,13 @@ 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_DBNODE(rdataset); + rdatasetheader_t *header = header_from_raw(rdataset->slab.raw); uint8_t mask = (1 << 7); uint8_t bits = 0; isc_rwlocktype_t nlocktype = isc_rwlocktype_none; - header = (struct rdatasetheader *)(raw - sizeof(*header)); - NODE_RDLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype); if (!CASESET(header)) { @@ -9840,18 +9839,15 @@ rdataset_newglue(dns_rbtdb_t *rbtdb, rbtdb_version_t *rbtversion, 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; - unsigned char *raw = rdataset->private3; /* RDATASLAB */ + dns_rbtdb_t *rbtdb = RDATASET_RBTDB(rdataset); + dns_rbtnode_t *node = RDATASET_DBNODE(rdataset); + rdatasetheader_t *header = header_from_raw(rdataset->slab.raw); rbtdb_version_t *rbtversion = version; REQUIRE(rdataset->type == dns_rdatatype_ns); REQUIRE(rbtdb == rbtversion->rbtdb); REQUIRE(!IS_CACHE(rbtdb) && !IS_STUB(rbtdb)); - rdatasetheader_t *header = - (struct rdatasetheader *)(raw - sizeof(*header)); - rcu_read_lock(); rbtdb_glue_t *glue = rcu_dereference(header->glue_list); diff --git a/lib/dns/rdatalist.c b/lib/dns/rdatalist.c index dee769d7cfc..dabc9ba95c3 100644 --- a/lib/dns/rdatalist.c +++ b/lib/dns/rdatalist.c @@ -46,14 +46,12 @@ dns_rdatalist_init(dns_rdatalist_t *rdatalist) { /* * Initialize rdatalist. */ - - rdatalist->rdclass = 0; - rdatalist->type = 0; - rdatalist->covers = 0; - rdatalist->ttl = 0; - ISC_LIST_INIT(rdatalist->rdata); - ISC_LINK_INIT(rdatalist, link); + *rdatalist = (dns_rdatalist_t){ + .rdata = ISC_LIST_INITIALIZER, + .link = ISC_LINK_INITIALIZER, + }; memset(rdatalist->upper, 0xeb, sizeof(rdatalist->upper)); + /* * Clear upper set bit. */ @@ -73,24 +71,28 @@ dns_rdatalist_tordataset(dns_rdatalist_t *rdatalist, dns_rdataset_t *rdataset) { /* Check if dns_rdatalist_init has was called. */ REQUIRE(rdatalist->upper[0] == 0xea); - rdataset->methods = &methods; - rdataset->rdclass = rdatalist->rdclass; - rdataset->type = rdatalist->type; - 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 = (dns_rdataset_t){ + .methods = &methods, + .rdclass = rdatalist->rdclass, + .type = rdatalist->type, + .covers = rdatalist->covers, + .ttl = rdatalist->ttl, + .rdlist.list = rdatalist, + + .link = rdataset->link, + .count = rdataset->count, + .attributes = rdataset->attributes, + .magic = rdataset->magic, + }; } void 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; } void @@ -100,12 +102,12 @@ dns_rdatalist_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { isc_result_t dns_rdatalist_first(dns_rdataset_t *rdataset) { - dns_rdatalist_t *rdatalist; + dns_rdatalist_t *rdatalist = NULL; - rdatalist = rdataset->private1; - rdataset->private2 = ISC_LIST_HEAD(rdatalist->rdata); + rdatalist = rdataset->rdlist.list; + rdataset->rdlist.iter = ISC_LIST_HEAD(rdatalist->rdata); - if (rdataset->private2 == NULL) { + if (rdataset->rdlist.iter == NULL) { return (ISC_R_NOMORE); } @@ -116,16 +118,14 @@ isc_result_t dns_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); } @@ -136,9 +136,7 @@ void dns_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); @@ -152,10 +150,7 @@ dns_rdatalist_clone(dns_rdataset_t *source, *target = *source; - /* - * Reset iterator state. - */ - target->private2 = NULL; + target->rdlist.iter = NULL; } unsigned int @@ -166,7 +161,7 @@ dns_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; @@ -228,7 +223,7 @@ dns_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); } @@ -245,7 +240,7 @@ dns_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. */ @@ -334,7 +329,7 @@ dns_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); } @@ -351,7 +346,7 @@ dns_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. */ @@ -399,14 +394,11 @@ dns_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. - */ } } /* @@ -420,7 +412,7 @@ dns_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; } diff --git a/lib/dns/rdataset.c b/lib/dns/rdataset.c index 796ddce6572..93609c4b77a 100644 --- a/lib/dns/rdataset.c +++ b/lib/dns/rdataset.c @@ -70,20 +70,11 @@ dns_rdataset_invalidate(dns_rdataset_t *rdataset) { REQUIRE(DNS_RDATASET_VALID(rdataset)); REQUIRE(rdataset->methods == NULL); - rdataset->magic = 0; - 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 = (dns_rdataset_t){ + .magic = 0, + .link = ISC_LINK_INITIALIZER, + .count = DNS_RDATASET_COUNT_UNDEFINED, + }; } void @@ -95,22 +86,14 @@ dns__rdataset_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { REQUIRE(DNS_RDATASET_VALID(rdataset)); REQUIRE(rdataset->methods != NULL); - (rdataset->methods->disassociate)(rdataset DNS__DB_FLARG_PASS); - rdataset->methods = NULL; - 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; + if (rdataset->methods->disassociate != NULL) { + (rdataset->methods->disassociate)(rdataset DNS__DB_FLARG_PASS); + } + *rdataset = (dns_rdataset_t){ + .magic = DNS_RDATASET_MAGIC, + .link = ISC_LINK_INITIALIZER, + .count = DNS_RDATASET_COUNT_UNDEFINED, + }; } bool @@ -128,52 +111,20 @@ dns_rdataset_isassociated(dns_rdataset_t *rdataset) { return (false); } -static void -question_disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { - UNUSED(rdataset); -} - static isc_result_t -question_cursor(dns_rdataset_t *rdataset) { - UNUSED(rdataset); - +question_cursor(dns_rdataset_t *rdataset ISC_ATTR_UNUSED) { return (ISC_R_NOMORE); } -static void -question_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { - /* - * This routine should never be called. - */ - UNUSED(rdataset); - UNUSED(rdata); - - REQUIRE(0); -} - static void question_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG) { *target = *source; } -static unsigned int -question_count(dns_rdataset_t *rdataset) { - /* - * This routine should never be called. - */ - UNUSED(rdataset); - REQUIRE(0); - - return (0); -} - static dns_rdatasetmethods_t question_methods = { - .disassociate = question_disassociate, .first = question_cursor, .next = question_cursor, - .current = question_current, .clone = question_clone, - .count = question_count, }; void @@ -201,6 +152,7 @@ dns_rdataset_count(dns_rdataset_t *rdataset) { REQUIRE(DNS_RDATASET_VALID(rdataset)); REQUIRE(rdataset->methods != NULL); + REQUIRE(rdataset->methods->count != NULL); return ((rdataset->methods->count)(rdataset)); } @@ -228,6 +180,7 @@ dns_rdataset_first(dns_rdataset_t *rdataset) { REQUIRE(DNS_RDATASET_VALID(rdataset)); REQUIRE(rdataset->methods != NULL); + REQUIRE(rdataset->methods->first != NULL); return ((rdataset->methods->first)(rdataset)); } @@ -240,6 +193,7 @@ dns_rdataset_next(dns_rdataset_t *rdataset) { REQUIRE(DNS_RDATASET_VALID(rdataset)); REQUIRE(rdataset->methods != NULL); + REQUIRE(rdataset->methods->next != NULL); return ((rdataset->methods->next)(rdataset)); } @@ -252,6 +206,7 @@ dns_rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) { REQUIRE(DNS_RDATASET_VALID(rdataset)); REQUIRE(rdataset->methods != NULL); + REQUIRE(rdataset->methods->current != NULL); (rdataset->methods->current)(rdataset, rdata); } @@ -284,7 +239,8 @@ static isc_result_t towiresorted(dns_rdataset_t *rdataset, const dns_name_t *owner_name, dns_compress_t *cctx, isc_buffer_t *target, dns_rdatasetorderfunc_t order, const void *order_arg, bool partial, - unsigned int options, unsigned int *countp, void **state) { + unsigned int options, unsigned int *countp, + void **state ISC_ATTR_UNUSED) { isc_region_t r; isc_result_t result; unsigned int i, count = 0, added; @@ -298,11 +254,9 @@ towiresorted(dns_rdataset_t *rdataset, const dns_name_t *owner_name, struct towire_sort out_fixed[MAX_SHUFFLE]; struct towire_sort *out = out_fixed; dns_fixedname_t fixed; - dns_name_t *name; + dns_name_t *name = NULL; uint16_t offset; - UNUSED(state); - /* * Convert 'rdataset' to wire format, compressing names as specified * in cctx, and storing the result in 'target'. @@ -332,7 +286,7 @@ towiresorted(dns_rdataset_t *rdataset, const dns_name_t *owner_name, return (dns_ncache_towire(rdataset, cctx, target, ncache_opts, countp)); } else { - count = (rdataset->methods->count)(rdataset); + count = dns_rdataset_count(rdataset); result = dns_rdataset_first(rdataset); if (result == ISC_R_NOMORE) { return (ISC_R_SUCCESS); diff --git a/lib/dns/sdlz.c b/lib/dns/sdlz.c index 2580823a24e..932215415a6 100644 --- a/lib/dns/sdlz.c +++ b/lib/dns/sdlz.c @@ -1322,7 +1322,7 @@ dbiterator_origin(dns_dbiterator_t *iterator, dns_name_t *name) { static void disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { - 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; @@ -1332,14 +1332,12 @@ disassociate(dns_rdataset_t *rdataset DNS__DB_FLARG) { static void rdataset_clone(dns_rdataset_t *source, dns_rdataset_t *target DNS__DB_FLARG) { - dns_dbnode_t *node = source->private5; + dns_dbnode_t *node = source->rdlist.node; dns_sdlznode_t *sdlznode = (dns_sdlznode_t *)node; dns_db_t *db = (dns_db_t *)sdlznode->sdlz; - dns_dbnode_t *tempdb = NULL; dns_rdatalist_clone(source, target DNS__DB_FLARG_PASS); - attachnode(db, node, &tempdb DNS__DB_FLARG_PASS); - source->private5 = tempdb; + attachnode(db, node, &target->rdlist.node DNS__DB_FLARG_PASS); } static dns_rdatasetmethods_t rdataset_methods = { @@ -1357,16 +1355,13 @@ static void list_tordataset(dns_rdatalist_t *rdatalist, dns_db_t *db, dns_dbnode_t *node, dns_rdataset_t *rdataset) { /* - * The sdlz rdataset is an rdatalist with some additions. - * - private1 & private2 are used by the rdatalist. - * - private3 & private 4 are unused. - * - private5 is the node. + * The sdlz rdataset is an rdatalist, but additionally holds + * a database node reference. */ dns_rdatalist_tordataset(rdatalist, rdataset); - rdataset->methods = &rdataset_methods; - dns_db_attachnode(db, node, &rdataset->private5); + dns_db_attachnode(db, node, &rdataset->rdlist.node); } /* diff --git a/lib/ns/query.c b/lib/ns/query.c index 67461f78cde..09f2671b780 100644 --- a/lib/ns/query.c +++ b/lib/ns/query.c @@ -2860,7 +2860,7 @@ rpz_get_zbits(ns_client_t *client, dns_rdatatype_t ip_type, if (st->rpsdb == NULL || librpz->have_trig(dns_dnsrps_type2trig(rpz_type), ip_type == dns_rdatatype_aaaa, - ((rpsdb_t *)st->rpsdb)->rsp)) + ((dns_rpsdb_t *)st->rpsdb)->rsp)) { return (DNS_RPZ_ALL_ZBITS); } @@ -3338,7 +3338,7 @@ rpz_save_p(dns_rpz_st_t *st, dns_rpz_zone_t *rpz, dns_rpz_type_t rpz_type, * Continue after a hit on a disabled zone (>0). */ static int -dnsrps_ck(librpz_emsg_t *emsg, ns_client_t *client, rpsdb_t *rpsdb, +dnsrps_ck(librpz_emsg_t *emsg, ns_client_t *client, dns_rpsdb_t *rpsdb, bool recursed) { isc_region_t region; librpz_domain_buf_t pname_buf; @@ -3393,7 +3393,7 @@ static bool dnsrps_set_p(librpz_emsg_t *emsg, ns_client_t *client, dns_rpz_st_t *st, dns_rdatatype_t qtype, dns_rdataset_t **p_rdatasetp, bool recursed) { - rpsdb_t *rpsdb = NULL; + dns_rpsdb_t *rpsdb = NULL; librpz_domain_buf_t pname_buf; isc_region_t region; dns_zone_t *p_zone = NULL; @@ -3405,7 +3405,7 @@ dnsrps_set_p(librpz_emsg_t *emsg, ns_client_t *client, dns_rpz_st_t *st, CTRACE(ISC_LOG_DEBUG(3), "dnsrps_set_p"); - rpsdb = (rpsdb_t *)st->rpsdb; + rpsdb = (dns_rpsdb_t *)st->rpsdb; if (!librpz->rsp_result(emsg, &rpsdb->result, recursed, rpsdb->rsp)) { return (false); @@ -3505,7 +3505,7 @@ static isc_result_t dnsrps_rewrite_ip(ns_client_t *client, const isc_netaddr_t *netaddr, dns_rpz_type_t rpz_type, dns_rdataset_t **p_rdatasetp) { dns_rpz_st_t *st; - rpsdb_t *rpsdb; + dns_rpsdb_t *rpsdb; librpz_trig_t trig = LIBRPZ_TRIG_CLIENT_IP; bool recursed = false; int res; @@ -3515,7 +3515,7 @@ dnsrps_rewrite_ip(ns_client_t *client, const isc_netaddr_t *netaddr, CTRACE(ISC_LOG_DEBUG(3), "dnsrps_rewrite_ip"); st = client->query.rpz_st; - rpsdb = (rpsdb_t *)st->rpsdb; + rpsdb = (dns_rpsdb_t *)st->rpsdb; result = rpz_ready(client, p_rdatasetp); if (result != ISC_R_SUCCESS) { @@ -3563,7 +3563,7 @@ static isc_result_t dnsrps_rewrite_name(ns_client_t *client, dns_name_t *trig_name, bool recursed, dns_rpz_type_t rpz_type, dns_rdataset_t **p_rdatasetp) { dns_rpz_st_t *st; - rpsdb_t *rpsdb; + dns_rpsdb_t *rpsdb; librpz_trig_t trig = LIBRPZ_TRIG_CLIENT_IP; isc_region_t r; int res; @@ -3573,7 +3573,7 @@ dnsrps_rewrite_name(ns_client_t *client, dns_name_t *trig_name, bool recursed, CTRACE(ISC_LOG_DEBUG(3), "dnsrps_rewrite_name"); st = client->query.rpz_st; - rpsdb = (rpsdb_t *)st->rpsdb; + rpsdb = (dns_rpsdb_t *)st->rpsdb; result = rpz_ready(client, p_rdatasetp); if (result != ISC_R_SUCCESS) { diff --git a/tests/dns/rbtdb_test.c b/tests/dns/rbtdb_test.c index 681c0776812..7ab73261f2e 100644 --- a/tests/dns/rbtdb_test.c +++ b/tests/dns/rbtdb_test.c @@ -102,27 +102,25 @@ 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, + .slab = { .db = (dns_db_t *)&rbtdb, + .node = &rbtnode, + .raw = raw }, .methods = &rdataset_methods, }; - isc_buffer_t b; dns_fixedname_t fname1, fname2; - dns_name_t *name1, *name2; + dns_name_t *name1 = dns_fixedname_initname(&fname1); + dns_name_t *name2 = dns_fixedname_initname(&fname2); memset(node_locks, 0, sizeof(node_locks)); /* Minimal initialization of the mock objects */ NODE_INITLOCK(&rbtdb.node_locks[0].lock); - name1 = dns_fixedname_initname(&fname1); isc_buffer_constinit(&b, str1, strlen(str1)); isc_buffer_add(&b, strlen(str1)); result = dns_name_fromtext(name1, &b, dns_rootname, 0, NULL); assert_int_equal(result, ISC_R_SUCCESS); - name2 = dns_fixedname_initname(&fname2); isc_buffer_constinit(&b, str2, strlen(str2)); isc_buffer_add(&b, strlen(str2)); result = dns_name_fromtext(name2, &b, dns_rootname, 0, NULL); @@ -164,17 +162,17 @@ ISC_RUN_TEST_IMPL(setownercase) { unsigned char *raw = (unsigned char *)(&header) + sizeof(header); dns_rdataset_t rdataset = { .magic = DNS_RDATASET_MAGIC, - .private1 = &rbtdb, - .private2 = &rbtnode, - .private3 = raw, + .slab = { .db = (dns_db_t *)&rbtdb, + .node = &rbtnode, + .raw = raw }, .methods = &rdataset_methods, }; const char *str1 = "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz"; - isc_buffer_t b; dns_fixedname_t fname1, fname2; - dns_name_t *name1, *name2; + dns_name_t *name1 = dns_fixedname_initname(&fname1); + dns_name_t *name2 = dns_fixedname_initname(&fname2); UNUSED(state); @@ -182,13 +180,11 @@ ISC_RUN_TEST_IMPL(setownercase) { memset(node_locks, 0, sizeof(node_locks)); NODE_INITLOCK(&rbtdb.node_locks[0].lock); - name1 = dns_fixedname_initname(&fname1); isc_buffer_constinit(&b, str1, strlen(str1)); isc_buffer_add(&b, strlen(str1)); result = dns_name_fromtext(name1, &b, dns_rootname, 0, NULL); assert_int_equal(result, ISC_R_SUCCESS); - name2 = dns_fixedname_initname(&fname2); isc_buffer_constinit(&b, str1, strlen(str1)); isc_buffer_add(&b, strlen(str1)); result = dns_name_fromtext(name2, &b, dns_rootname, 0, NULL);