*/
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;
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 = {
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);
}
/*
#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;
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,
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));
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);
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 ||
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));
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);
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;
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;
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);
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);
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);
static void
rpsdb_rdataset_disassociate(dns_rdataset_t *rdataset) {
- dns_db_t *db;
+ dns_db_t *db = NULL;
/*
* Detach the last RR delivered.
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);
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);
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);
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;
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));
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;
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;
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;
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);
*
* 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.
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;
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.
*/
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
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;
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;
}
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);
}
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);
}
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);
}
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);
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;
}
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);
}
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);
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;
}
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);
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);
}
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);
}
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;
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.
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;
}
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)
/*
* 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) {
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);
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;
}
bool valid = false;
dns_offsets_t offsets;
isc_region_t region;
- rdatasetheader_t *header;
/*
* No additional locking is required.
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;
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);
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;
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);
}
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);
}
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 */
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
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 */
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);
*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);
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
.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,
.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,
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
.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,
.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,
*/
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);
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);
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);
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);
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)) {
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);
/*
* 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.
*/
/* 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
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);
}
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);
}
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);
*target = *source;
- /*
- * Reset iterator state.
- */
- target->private2 = NULL;
+ target->rdlist.iter = NULL;
}
unsigned int
REQUIRE(rdataset != NULL);
- rdatalist = rdataset->private1;
+ rdatalist = rdataset->rdlist.list;
count = 0;
for (rdata = ISC_LIST_HEAD(rdatalist->rdata); rdata != NULL;
}
rdataset->ttl = neg->ttl = negsig->ttl = ttl;
rdataset->attributes |= DNS_RDATASETATTR_NOQNAME;
- rdataset->private6 = name;
+ rdataset->rdlist.noqname = name;
return (ISC_R_SUCCESS);
}
REQUIRE((rdataset->attributes & DNS_RDATASETATTR_NOQNAME) != 0);
rdclass = rdataset->rdclass;
- noqname = rdataset->private6;
+ noqname = rdataset->rdlist.noqname;
(void)dns_name_dynamic(noqname); /* Sanity Check. */
}
rdataset->ttl = neg->ttl = negsig->ttl = ttl;
rdataset->attributes |= DNS_RDATASETATTR_CLOSEST;
- rdataset->private7 = name;
+ rdataset->rdlist.closest = name;
return (ISC_R_SUCCESS);
}
REQUIRE((rdataset->attributes & DNS_RDATASETATTR_CLOSEST) != 0);
rdclass = rdataset->rdclass;
- closest = rdataset->private7;
+ closest = rdataset->rdlist.closest;
(void)dns_name_dynamic(closest); /* Sanity Check. */
* 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.
- */
}
}
/*
dns_rdatalist_t *rdatalist;
unsigned int i;
- rdatalist = rdataset->private1;
+ rdatalist = rdataset->rdlist.list;
if ((rdatalist->upper[0] & 0x01) == 0) {
return;
}
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
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
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
REQUIRE(DNS_RDATASET_VALID(rdataset));
REQUIRE(rdataset->methods != NULL);
+ REQUIRE(rdataset->methods->count != NULL);
return ((rdataset->methods->count)(rdataset));
}
REQUIRE(DNS_RDATASET_VALID(rdataset));
REQUIRE(rdataset->methods != NULL);
+ REQUIRE(rdataset->methods->first != NULL);
return ((rdataset->methods->first)(rdataset));
}
REQUIRE(DNS_RDATASET_VALID(rdataset));
REQUIRE(rdataset->methods != NULL);
+ REQUIRE(rdataset->methods->next != NULL);
return ((rdataset->methods->next)(rdataset));
}
REQUIRE(DNS_RDATASET_VALID(rdataset));
REQUIRE(rdataset->methods != NULL);
+ REQUIRE(rdataset->methods->current != NULL);
(rdataset->methods->current)(rdataset, rdata);
}
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;
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'.
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);
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;
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 = {
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);
}
/*
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);
}
* 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;
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;
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);
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;
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) {
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;
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) {
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);
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);
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);
projects / thirdparty / bind9.git / commitdiff
