mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-22 18:19:42 +00:00
Code Issues Releases Wiki Activity

Convert DNS_RDATASETATTR_ bitfield manipulation to struct of bools

Browse Source 
RRset ordering is now an enum inside struct rdataset attributes. This
was done to keep size to of the structure to its original value before
this MR.

I expect zero performance impact but it should be easier to deal with
attributes in debuggers and language servers.
This commit is contained in:
Petr Špaček 2025-07-09 16:56:22 +02:00
parent 338bd67a10
commit 750d8a61b6
23 changed files with 213 additions and 260 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
bin/delv/delv.c
View File

@ -369,7 +369,7 @@ print_status(dns_rdataset_t *rdataset) {
buf[0] = '\0'; buf[0] = '\0';
if ((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0) { if (rdataset->attributes.negative) {
strlcat(buf, "negative response", sizeof(buf)); strlcat(buf, "negative response", sizeof(buf));
strlcat(buf, yaml ? "_" : ", ", sizeof(buf)); strlcat(buf, yaml ? "_" : ", ", sizeof(buf));
} }
@ -474,9 +474,7 @@ printdata(dns_rdataset_t *rdataset, dns_name_t *owner) {
DNS_RDATASET_FOREACH (rdataset) { DNS_RDATASET_FOREACH (rdataset) {
dns_rdata_t rdata = DNS_RDATA_INIT; dns_rdata_t rdata = DNS_RDATA_INIT;
if ((rdataset->attributes & if (rdataset->attributes.negative) {
DNS_RDATASETATTR_NEGATIVE) != 0)
{
continue; continue;
} }
@ -497,9 +495,7 @@ printdata(dns_rdataset_t *rdataset, dns_name_t *owner) {
} }
} else { } else {
dns_indent_t indent = { " ", 2 }; dns_indent_t indent = { " ", 2 };
if (!yaml && (rdataset->attributes & if (!yaml && rdataset->attributes.negative) {
DNS_RDATASETATTR_NEGATIVE) != 0)
{
isc_buffer_putstr(&target, "; "); isc_buffer_putstr(&target, "; ");
} }
result = dns_master_rdatasettotext( result = dns_master_rdatasettotext(

8
bin/named/server.c
View File

@ -1325,7 +1325,7 @@ configure_order(dns_order_t *order, const cfg_obj_t *ent) {
dns_rdatatype_t rdtype; dns_rdatatype_t rdtype;
const cfg_obj_t *obj; const cfg_obj_t *obj;
dns_fixedname_t fixed; dns_fixedname_t fixed;
unsigned int mode = 0; dns_orderopt_t mode = dns_order_none;
const char *str; const char *str;
isc_buffer_t b; isc_buffer_t b;
isc_result_t result; isc_result_t result;
@ -1363,11 +1363,11 @@ configure_order(dns_order_t *order, const cfg_obj_t *ent) {
INSIST(cfg_obj_isstring(obj)); INSIST(cfg_obj_isstring(obj));
str = cfg_obj_asstring(obj); str = cfg_obj_asstring(obj);
if (!strcasecmp(str, "random")) { if (!strcasecmp(str, "random")) {
mode = DNS_RDATASETATTR_RANDOMIZE; mode = dns_order_randomize;
} else if (!strcasecmp(str, "cyclic")) { } else if (!strcasecmp(str, "cyclic")) {
mode = DNS_RDATASETATTR_CYCLIC; mode = dns_order_cyclic;
} else if (!strcasecmp(str, "none")) { } else if (!strcasecmp(str, "none")) {
mode = DNS_RDATASETATTR_NONE; mode = dns_order_none;
} else { } else {
UNREACHABLE(); UNREACHABLE();
} }

4
bin/plugins/filter-a.c
View File

@ -518,10 +518,10 @@ client_state_destroy(const query_ctx_t *qctx, filter_instance_t *inst) {
static void static void
mark_as_rendered(dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { mark_as_rendered(dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) {
if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) {
rdataset->attributes |= DNS_RDATASETATTR_RENDERED; rdataset->attributes.rendered = true;
} }
if (sigrdataset != NULL && dns_rdataset_isassociated(sigrdataset)) { if (sigrdataset != NULL && dns_rdataset_isassociated(sigrdataset)) {
sigrdataset->attributes |= DNS_RDATASETATTR_RENDERED; sigrdataset->attributes.rendered = true;
} }
} }

4
bin/plugins/filter-aaaa.c
View File

@ -522,10 +522,10 @@ client_state_destroy(const query_ctx_t *qctx, filter_instance_t *inst) {
static void static void
mark_as_rendered(dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) { mark_as_rendered(dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) {
if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) { if (rdataset != NULL && dns_rdataset_isassociated(rdataset)) {
rdataset->attributes |= DNS_RDATASETATTR_RENDERED; rdataset->attributes.rendered = true;
} }
if (sigrdataset != NULL && dns_rdataset_isassociated(sigrdataset)) { if (sigrdataset != NULL && dns_rdataset_isassociated(sigrdataset)) {
sigrdataset->attributes |= DNS_RDATASETATTR_RENDERED; sigrdataset->attributes.rendered = true;
} }
} }

2
lib/dns/include/dns/ncache.h
View File

@ -73,7 +73,7 @@ dns_ncache_addoptout(dns_message_t *message, dns_db_t *cache,
* The 'covers' argument is the RR type whose nonexistence we are caching, * The 'covers' argument is the RR type whose nonexistence we are caching,
* or dns_rdatatype_any when caching a NXDOMAIN response. * or dns_rdatatype_any when caching a NXDOMAIN response.
* *
* 'optout' indicates a DNS_RDATASETATTR_OPTOUT should be set. * 'optout' parameter indicates if 'optout' attribute should be set.
* *
* Note: * Note:
*\li If 'addedrdataset' is not NULL, then it will be attached to the added *\li If 'addedrdataset' is not NULL, then it will be attached to the added

6
lib/dns/include/dns/order.h
View File

@ -32,18 +32,16 @@ dns_order_create(isc_mem_t *mctx, dns_order_t **orderp);
void void
dns_order_add(dns_order_t *order, const dns_name_t *name, dns_order_add(dns_order_t *order, const dns_name_t *name,
dns_rdatatype_t rdtype, dns_rdataclass_t rdclass, dns_rdatatype_t rdtype, dns_rdataclass_t rdclass,
unsigned int mode); dns_orderopt_t mode);
/*%< /*%<
* Add a entry to the end of the order list. * Add a entry to the end of the order list.
* *
* Requires: * Requires:
* \li 'order' to be valid. * \li 'order' to be valid.
*\li 'name' to be valid. *\li 'name' to be valid.
*\li 'mode' to be one of #DNS_RDATASETATTR_RANDOMIZE,
* #DNS_RDATASETATTR_FIXEDORDER or zero (#DNS_RDATASETATTR_CYCLIC).
*/ */
unsigned int dns_orderopt_t
dns_order_find(dns_order_t *order, const dns_name_t *name, dns_order_find(dns_order_t *order, const dns_name_t *name,
dns_rdatatype_t rdtype, dns_rdataclass_t rdclass); dns_rdatatype_t rdtype, dns_rdataclass_t rdclass);
/*%< /*%<

100
lib/dns/include/dns/rdataset.h
View File

@ -128,10 +128,40 @@ struct dns_rdataset {
dns_trust_t trust; dns_trust_t trust;
dns_rdatatype_t covers; dns_rdatatype_t covers;
/* struct {
* attributes bool question : 1;
bool rendered : 1; /*%< message.c: was rendered */
bool answered : 1; /*%< server. */
bool cache : 1; /*%< resolver. */
bool answer : 1; /*%< resolver. */
bool answersig : 1; /*%< resolver. */
bool external : 1; /*%< resolver. */
bool ncache : 1; /*%< resolver. */
bool chaining : 1; /*%< resolver. */
bool ttladjusted : 1; /*%< message.c: data had differing TTL
values, and the rdataset->ttl holds the smallest */
bool chase : 1; /*%< Used by resolver. */
bool nxdomain : 1;
bool noqname : 1;
bool checknames : 1; /*%< Used by resolver. */
bool required : 1;
bool resign : 1;
bool closest : 1;
bool optout : 1; /*%< OPTOUT proof */
bool negative : 1;
bool prefetch : 1;
bool stale : 1;
bool ancient : 1;
bool stale_window : 1;
bool stale_added : 1; /*%< Added during a
stale-answer-client-timeout lookup. In other words, the
RRset was added during a lookup of stale data and does
not necessarily mean that the rdataset itself is stale.
*/ */
unsigned int attributes; bool keepcase : 1;
bool staticstub : 1;
dns_orderopt_t order : 2;
} attributes;
/*% /*%
* the counter provides the starting point in the "cyclic" order. * the counter provides the starting point in the "cyclic" order.
@ -143,7 +173,7 @@ struct dns_rdataset {
/* /*
* This RRSIG RRset should be re-generated around this time. * This RRSIG RRset should be re-generated around this time.
* Only valid if DNS_RDATASETATTR_RESIGN is set in attributes. * Only valid if 'resign' attribute is set.
*/ */
union { union {
isc_stdtime_t resign; isc_stdtime_t resign;
@ -237,56 +267,6 @@ struct dns_rdataset {
DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__)) DNS_RDATASET_FOREACH_RES(rds, DNS__RDATASET_CONCAT(x, __LINE__))
/* clang-format on */ /* clang-format on */
/*!
* \def DNS_RDATASETATTR_RENDERED
* Used by message.c to indicate that the rdataset was rendered.
*
* \def DNS_RDATASETATTR_TTLADJUSTED
* Used by message.c to indicate that the rdataset's rdata had differing
* TTL values, and the rdataset->ttl holds the smallest.
*
* \def DNS_RDATASETATTR_LOADORDER
* Output the RRset in load order.
*
* \def DNS_RDATASETATTR_STALE_ADDED
* Set on rdatasets that were added during a stale-answer-client-timeout
* lookup. In other words, the RRset was added during a lookup of stale
* data and does not necessarily mean that the rdataset itself is stale.
*/
#define DNS_RDATASETATTR_NONE 0x00000000 /*%< No ordering. */
#define DNS_RDATASETATTR_QUESTION 0x00000001
#define DNS_RDATASETATTR_RENDERED 0x00000002 /*%< Used by message.c */
#define DNS_RDATASETATTR_ANSWERED 0x00000004 /*%< Used by server. */
#define DNS_RDATASETATTR_CACHE 0x00000008 /*%< Used by resolver. */
#define DNS_RDATASETATTR_ANSWER 0x00000010 /*%< Used by resolver. */
#define DNS_RDATASETATTR_ANSWERSIG 0x00000020 /*%< Used by resolver. */
#define DNS_RDATASETATTR_EXTERNAL 0x00000040 /*%< Used by resolver. */
#define DNS_RDATASETATTR_NCACHE 0x00000080 /*%< Used by resolver. */
#define DNS_RDATASETATTR_CHAINING 0x00000100 /*%< Used by resolver. */
#define DNS_RDATASETATTR_TTLADJUSTED 0x00000200 /*%< Used by message.c */
#define DNS_RDATASETATTR_FIXEDORDER 0x00000400 /*%< Fixed ordering. */
#define DNS_RDATASETATTR_RANDOMIZE 0x00000800 /*%< Random ordering. */
#define DNS_RDATASETATTR_CHASE 0x00001000 /*%< Used by resolver. */
#define DNS_RDATASETATTR_NXDOMAIN 0x00002000
#define DNS_RDATASETATTR_NOQNAME 0x00004000
#define DNS_RDATASETATTR_CHECKNAMES 0x00008000 /*%< Used by resolver. */
#define DNS_RDATASETATTR_REQUIRED 0x00010000
#define DNS_RDATASETATTR_REQUIREDGLUE DNS_RDATASETATTR_REQUIRED
#define DNS_RDATASETATTR_UNUSED1 0x00020000
#define DNS_RDATASETATTR_RESIGN 0x00040000
#define DNS_RDATASETATTR_CLOSEST 0x00080000
#define DNS_RDATASETATTR_OPTOUT 0x00100000 /*%< OPTOUT proof */
#define DNS_RDATASETATTR_NEGATIVE 0x00200000
#define DNS_RDATASETATTR_PREFETCH 0x00400000
#define DNS_RDATASETATTR_CYCLIC 0x00800000 /*%< Cyclic ordering. */
#define DNS_RDATASETATTR_STALE 0x01000000
#define DNS_RDATASETATTR_ANCIENT 0x02000000
#define DNS_RDATASETATTR_STALE_WINDOW 0x04000000
#define DNS_RDATASETATTR_STALE_ADDED 0x08000000
#define DNS_RDATASETATTR_KEEPCASE 0x10000000
#define DNS_RDATASETATTR_STATICSTUB 0x20000000
/*% /*%
* _OMITDNSSEC: * _OMITDNSSEC:
* Omit DNSSEC records when rendering ncache records. * Omit DNSSEC records when rendering ncache records.
@ -574,7 +554,7 @@ dns__rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
* Return the noqname proof for this record. * Return the noqname proof for this record.
* *
* Requires: * Requires:
*\li 'rdataset' to be valid and #DNS_RDATASETATTR_NOQNAME to be set. *\li 'rdataset' to be valid and 'noqname' attribute to be set.
*\li 'name' to be valid. *\li 'name' to be valid.
*\li 'neg' and 'negsig' to be valid and not associated. *\li 'neg' and 'negsig' to be valid and not associated.
*/ */
@ -583,12 +563,12 @@ isc_result_t
dns_rdataset_addnoqname(dns_rdataset_t *rdataset, dns_name_t *name); dns_rdataset_addnoqname(dns_rdataset_t *rdataset, dns_name_t *name);
/*%< /*%<
* Associate a noqname proof with this record. * Associate a noqname proof with this record.
* Sets #DNS_RDATASETATTR_NOQNAME if successful. * Sets 'noqname' attribute if successful.
* Adjusts the 'rdataset->ttl' to minimum of the 'rdataset->ttl' and * Adjusts the 'rdataset->ttl' to minimum of the 'rdataset->ttl' and
* the 'nsec'/'nsec3' and 'rrsig(nsec)'/'rrsig(nsec3)' ttl. * the 'nsec'/'nsec3' and 'rrsig(nsec)'/'rrsig(nsec3)' ttl.
* *
* Requires: * Requires:
*\li 'rdataset' to be valid and #DNS_RDATASETATTR_NOQNAME to be set. *\li 'rdataset' to be valid and 'noqname' attribute to be set.
*\li 'name' to be valid and have NSEC or NSEC3 and associated RRSIG *\li 'name' to be valid and have NSEC or NSEC3 and associated RRSIG
* rdatasets. * rdatasets.
*/ */
@ -603,7 +583,7 @@ dns__rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
* Return the closest encloser for this record. * Return the closest encloser for this record.
* *
* Requires: * Requires:
*\li 'rdataset' to be valid and #DNS_RDATASETATTR_CLOSEST to be set. *\li 'rdataset' to be valid and 'closest' attribute to be set.
*\li 'name' to be valid. *\li 'name' to be valid.
*\li 'nsec' and 'nsecsig' to be valid and not associated. *\li 'nsec' and 'nsecsig' to be valid and not associated.
*/ */
@ -612,12 +592,12 @@ isc_result_t
dns_rdataset_addclosest(dns_rdataset_t *rdataset, dns_name_t *name); dns_rdataset_addclosest(dns_rdataset_t *rdataset, dns_name_t *name);
/*%< /*%<
* Associate a closest encloset proof with this record. * Associate a closest encloset proof with this record.
* Sets #DNS_RDATASETATTR_CLOSEST if successful. * Sets 'closest' attribute if successful.
* Adjusts the 'rdataset->ttl' to minimum of the 'rdataset->ttl' and * Adjusts the 'rdataset->ttl' to minimum of the 'rdataset->ttl' and
* the 'nsec' and 'rrsig(nsec)' ttl. * the 'nsec' and 'rrsig(nsec)' ttl.
* *
* Requires: * Requires:
*\li 'rdataset' to be valid and #DNS_RDATASETATTR_CLOSEST to be set. *\li 'rdataset' to be valid and 'closest' attribute to be set.
*\li 'name' to be valid and have NSEC3 and RRSIG(NSEC3) rdatasets. *\li 'name' to be valid and have NSEC3 and RRSIG(NSEC3) rdatasets.
*/ */

6
lib/dns/include/dns/types.h
View File

@ -236,6 +236,12 @@ typedef enum {
dns_masterformat_raw = 2, dns_masterformat_raw = 2,
} dns_masterformat_t; } dns_masterformat_t;
typedef enum {
dns_order_none,
dns_order_cyclic,
dns_order_randomize
} dns_orderopt_t;
typedef enum { typedef enum {
dns_expire_lru = 0, dns_expire_lru = 0,
dns_expire_ttl = 1, dns_expire_ttl = 1,

2
lib/dns/master.c
View File

@ -2898,7 +2898,7 @@ commit(dns_rdatacallbacks_t *callbacks, dns_loadctx_t *lctx,
if (dataset.type == dns_rdatatype_rrsig && if (dataset.type == dns_rdatatype_rrsig &&
(lctx->options & DNS_MASTER_RESIGN) != 0) (lctx->options & DNS_MASTER_RESIGN) != 0)
{ {
dataset.attributes |= DNS_RDATASETATTR_RESIGN; dataset.attributes.resign = true;
dataset.resign = resign_fromlist(this, lctx); dataset.resign = resign_fromlist(this, lctx);
} }
result = callbacks->add(callbacks->add_private, owner, result = callbacks->add(callbacks->add_private, owner,

18
lib/dns/masterdump.c
View File

@ -83,9 +83,9 @@ struct dns_master_style {
#define DNS_TOTEXT_LINEBREAK_MAXLEN 100 #define DNS_TOTEXT_LINEBREAK_MAXLEN 100
/*% Does the rdataset 'r' contain a stale answer? */ /*% Does the rdataset 'r' contain a stale answer? */
#define STALE(r) (((r)->attributes & DNS_RDATASETATTR_STALE) != 0) #define STALE(r) (((r)->attributes.stale))
/*% Does the rdataset 'r' contain an expired answer? */ /*% Does the rdataset 'r' contain an expired answer? */
#define ANCIENT(r) (((r)->attributes & DNS_RDATASETATTR_ANCIENT) != 0) #define ANCIENT(r) (((r)->attributes.ancient))
/*% /*%
* Context structure for a masterfile dump in progress. * Context structure for a masterfile dump in progress.
@ -271,7 +271,7 @@ struct dns_dumpctx {
FILE *f); FILE *f);
}; };
#define NXDOMAIN(x) (((x)->attributes & DNS_RDATASETATTR_NXDOMAIN) != 0) #define NXDOMAIN(x) (((x)->attributes.nxdomain))
static const dns_indent_t default_indent = { "\t", 1 }; static const dns_indent_t default_indent = { "\t", 1 };
static const dns_indent_t default_yamlindent = { " ", 1 }; static const dns_indent_t default_yamlindent = { " ", 1 };
@ -717,7 +717,7 @@ rdataset_totext(dns_rdataset_t *rdataset, const dns_name_t *owner_name,
* Type. * Type.
*/ */
if ((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0) { if (rdataset->attributes.negative) {
type = rdataset->covers; type = rdataset->covers;
} else { } else {
type = rdataset->type; type = rdataset->type;
@ -725,7 +725,7 @@ rdataset_totext(dns_rdataset_t *rdataset, const dns_name_t *owner_name,
INDENT_TO(type_column); INDENT_TO(type_column);
type_start = target->used; type_start = target->used;
if ((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0) { if (rdataset->attributes.negative) {
RETERR(str_totext("\\-", target)); RETERR(str_totext("\\-", target));
} }
switch (type) { switch (type) {
@ -760,7 +760,7 @@ rdataset_totext(dns_rdataset_t *rdataset, const dns_name_t *owner_name,
* Rdata. * Rdata.
*/ */
INDENT_TO(rdata_column); INDENT_TO(rdata_column);
if ((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0) { if (rdataset->attributes.negative) {
if (NXDOMAIN(rdataset)) { if (NXDOMAIN(rdataset)) {
RETERR(str_totext(";-$NXDOMAIN", target)); RETERR(str_totext(";-$NXDOMAIN", target));
} else { } else {
@ -1143,7 +1143,7 @@ again:
} }
fprintf(f, "; %s\n", dns_trust_totext(rds->trust)); fprintf(f, "; %s\n", dns_trust_totext(rds->trust));
} }
if (((rds->attributes & DNS_RDATASETATTR_NEGATIVE) != 0) && if ((rds->attributes.negative) &&
(ctx->style.flags & DNS_STYLEFLAG_NCACHE) == 0) (ctx->style.flags & DNS_STYLEFLAG_NCACHE) == 0)
{ {
/* Omit negative cache entries */ /* Omit negative cache entries */
@ -1169,7 +1169,7 @@ again:
} }
} }
if (((ctx->style.flags & DNS_STYLEFLAG_RESIGN) != 0) && if (((ctx->style.flags & DNS_STYLEFLAG_RESIGN) != 0) &&
((rds->attributes & DNS_RDATASETATTR_RESIGN) != 0)) (rds->attributes.resign))
{ {
isc_buffer_t b; isc_buffer_t b;
char buf[sizeof("YYYYMMDDHHMMSS")]; char buf[sizeof("YYYYMMDDHHMMSS")];
@ -1323,7 +1323,7 @@ dump_rdatasets_raw(isc_mem_t *mctx, const dns_name_t *owner_name,
dns_rdataset_getownercase(&rdataset, name); dns_rdataset_getownercase(&rdataset, name);
if (((rdataset.attributes & DNS_RDATASETATTR_NEGATIVE) != 0) && if (rdataset.attributes.negative &&
(ctx->style.flags & DNS_STYLEFLAG_NCACHE) == 0) (ctx->style.flags & DNS_STYLEFLAG_NCACHE) == 0)
{ {
/* Omit negative cache entries */ /* Omit negative cache entries */

25
lib/dns/message.c
View File

@ -114,7 +114,7 @@ hexdump(const char *msg, const char *msg2, void *base, size_t len) {
#define VALID_PSEUDOSECTION(s) \ #define VALID_PSEUDOSECTION(s) \
(((s) >= DNS_PSEUDOSECTION_ANY) && ((s) < DNS_PSEUDOSECTION_MAX)) (((s) >= DNS_PSEUDOSECTION_ANY) && ((s) < DNS_PSEUDOSECTION_MAX))
#define OPTOUT(x) (((x)->attributes & DNS_RDATASETATTR_OPTOUT) != 0) #define OPTOUT(x) (((x)->attributes.optout))
/*% /*%
* This is the size of each individual scratchpad buffer, and the numbers * This is the size of each individual scratchpad buffer, and the numbers
@ -998,7 +998,7 @@ getquestions(isc_buffer_t *source, dns_message_t *msg, dns_decompress_t dctx,
dns_message_gettemprdataset(msg, &rdataset); dns_message_gettemprdataset(msg, &rdataset);
dns_rdatalist_tordataset(rdatalist, rdataset); dns_rdatalist_tordataset(rdatalist, rdataset);
rdataset->attributes |= DNS_RDATASETATTR_QUESTION; rdataset->attributes.question = true;
ISC_LIST_APPEND(name->list, rdataset, link); ISC_LIST_APPEND(name->list, rdataset, link);
@ -1452,7 +1452,7 @@ getsection(isc_buffer_t *source, dns_message_t *msg, dns_decompress_t dctx,
* minimize them. * minimize them.
*/ */
if (ttl != rdataset->ttl) { if (ttl != rdataset->ttl) {
rdataset->attributes |= DNS_RDATASETATTR_TTLADJUSTED; rdataset->attributes.ttladjusted = true;
if (ttl < rdataset->ttl) { if (ttl < rdataset->ttl) {
rdataset->ttl = ttl; rdataset->ttl = ttl;
} }
@ -1927,10 +1927,8 @@ dns_message_rendersection(dns_message_t *msg, dns_section_t sectionid,
name = ISC_LIST_HEAD(*section); name = ISC_LIST_HEAD(*section);
if (name != NULL) { if (name != NULL) {
rdataset = ISC_LIST_HEAD(name->list); rdataset = ISC_LIST_HEAD(name->list);
if (rdataset != NULL && if (rdataset != NULL && rdataset->attributes.required &&
(rdataset->attributes & DNS_RDATASETATTR_REQUIREDGLUE) != !rdataset->attributes.rendered)
0 &&
(rdataset->attributes & DNS_RDATASETATTR_RENDERED) == 0)
{ {
st = *(msg->buffer); st = *(msg->buffer);
count = 0; count = 0;
@ -1963,7 +1961,7 @@ dns_message_rendersection(dns_message_t *msg, dns_section_t sectionid,
update_min_section_ttl(msg, sectionid, rdataset); update_min_section_ttl(msg, sectionid, rdataset);
rdataset->attributes |= DNS_RDATASETATTR_RENDERED; rdataset->attributes.rendered = true;
} }
} }
@ -1977,9 +1975,7 @@ dns_message_rendersection(dns_message_t *msg, dns_section_t sectionid,
ISC_LIST_FOREACH (*section, n, link) { ISC_LIST_FOREACH (*section, n, link) {
ISC_LIST_FOREACH (n->list, rds, link) { ISC_LIST_FOREACH (n->list, rds, link) {
if ((rds->attributes & if (rds->attributes.rendered) {
DNS_RDATASETATTR_RENDERED) != 0)
{
continue; continue;
} }
@ -2051,7 +2047,7 @@ dns_message_rendersection(dns_message_t *msg, dns_section_t sectionid,
update_min_section_ttl(msg, sectionid, rds); update_min_section_ttl(msg, sectionid, rds);
rds->attributes |= DNS_RDATASETATTR_RENDERED; rds->attributes.rendered = true;
} }
} }
} while (--pass != 0); } while (--pass != 0);
@ -2282,7 +2278,7 @@ dns_message_renderreset(dns_message_t *msg) {
msg->counts[i] = 0; msg->counts[i] = 0;
MSG_SECTION_FOREACH (msg, i, name) { MSG_SECTION_FOREACH (msg, i, name) {
ISC_LIST_FOREACH (name->list, rds, link) { ISC_LIST_FOREACH (name->list, rds, link) {
rds->attributes &= ~DNS_RDATASETATTR_RENDERED; rds->attributes.rendered = false;
} }
} }
} }
@ -5027,8 +5023,7 @@ message_authority_soa_min(dns_message_t *msg, dns_ttl_t *ttlp) {
MSG_SECTION_FOREACH (msg, DNS_SECTION_AUTHORITY, name) { MSG_SECTION_FOREACH (msg, DNS_SECTION_AUTHORITY, name) {
ISC_LIST_FOREACH (name->list, rds, link) { ISC_LIST_FOREACH (name->list, rds, link) {
if ((rds->attributes & DNS_RDATASETATTR_RENDERED) == 0) if (!rds->attributes.rendered) {
{
continue; continue;
} }

18
lib/dns/ncache.c
View File

@ -164,9 +164,7 @@ addoptout(dns_message_t *message, dns_db_t *cache, dns_dbnode_t *node,
if (name->attributes.ncache) { if (name->attributes.ncache) {
ISC_LIST_FOREACH (name->list, rdataset, link) { ISC_LIST_FOREACH (name->list, rdataset, link) {
if ((rdataset->attributes & if (!rdataset->attributes.ncache) {
DNS_RDATASETATTR_NCACHE) == 0)
{
continue; continue;
} }
type = rdataset->type; type = rdataset->type;
@ -261,12 +259,12 @@ addoptout(dns_message_t *message, dns_db_t *cache, dns_dbnode_t *node,
trust = dns_trust_answer; trust = dns_trust_answer;
} }
ncrdataset.trust = trust; ncrdataset.trust = trust;
ncrdataset.attributes |= DNS_RDATASETATTR_NEGATIVE; ncrdataset.attributes.negative = true;
if (message->rcode == dns_rcode_nxdomain) { if (message->rcode == dns_rcode_nxdomain) {
ncrdataset.attributes |= DNS_RDATASETATTR_NXDOMAIN; ncrdataset.attributes.nxdomain = true;
} }
if (optout) { if (optout) {
ncrdataset.attributes |= DNS_RDATASETATTR_OPTOUT; ncrdataset.attributes.optout = true;
} }
return dns_db_addrdataset(cache, node, NULL, now, &ncrdataset, 0, return dns_db_addrdataset(cache, node, NULL, now, &ncrdataset, 0,
@ -292,7 +290,7 @@ dns_ncache_towire(dns_rdataset_t *rdataset, dns_compress_t *cctx,
REQUIRE(rdataset != NULL); REQUIRE(rdataset != NULL);
REQUIRE(rdataset->type == 0); REQUIRE(rdataset->type == 0);
REQUIRE((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0); REQUIRE(rdataset->attributes.negative);
savedbuffer = *target; savedbuffer = *target;
count = 0; count = 0;
@ -508,7 +506,7 @@ dns_ncache_getrdataset(dns_rdataset_t *ncacherdataset, dns_name_t *name,
REQUIRE(ncacherdataset != NULL); REQUIRE(ncacherdataset != NULL);
REQUIRE(DNS_RDATASET_VALID(ncacherdataset)); REQUIRE(DNS_RDATASET_VALID(ncacherdataset));
REQUIRE(ncacherdataset->type == 0); REQUIRE(ncacherdataset->type == 0);
REQUIRE((ncacherdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0); REQUIRE(ncacherdataset->attributes.negative);
REQUIRE(name != NULL); REQUIRE(name != NULL);
REQUIRE(!dns_rdataset_isassociated(rdataset)); REQUIRE(!dns_rdataset_isassociated(rdataset));
REQUIRE(type != dns_rdatatype_rrsig); REQUIRE(type != dns_rdatatype_rrsig);
@ -574,7 +572,7 @@ dns_ncache_getsigrdataset(dns_rdataset_t *ncacherdataset, dns_name_t *name,
REQUIRE(ncacherdataset != NULL); REQUIRE(ncacherdataset != NULL);
REQUIRE(ncacherdataset->type == 0); REQUIRE(ncacherdataset->type == 0);
REQUIRE((ncacherdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0); REQUIRE(ncacherdataset->attributes.negative);
REQUIRE(name != NULL); REQUIRE(name != NULL);
REQUIRE(!dns_rdataset_isassociated(rdataset)); REQUIRE(!dns_rdataset_isassociated(rdataset));
@ -659,7 +657,7 @@ dns_ncache_current(dns_rdataset_t *ncacherdataset, dns_name_t *found,
REQUIRE(ncacherdataset != NULL); REQUIRE(ncacherdataset != NULL);
REQUIRE(ncacherdataset->type == 0); REQUIRE(ncacherdataset->type == 0);
REQUIRE((ncacherdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0); REQUIRE(ncacherdataset->attributes.negative);
REQUIRE(found != NULL); REQUIRE(found != NULL);
REQUIRE(!dns_rdataset_isassociated(rdataset)); REQUIRE(!dns_rdataset_isassociated(rdataset));

12
lib/dns/order.c
View File

@ -32,7 +32,7 @@ struct dns_order_ent {
dns_fixedname_t name; dns_fixedname_t name;
dns_rdataclass_t rdclass; dns_rdataclass_t rdclass;
dns_rdatatype_t rdtype; dns_rdatatype_t rdtype;
unsigned int mode; dns_orderopt_t mode;
ISC_LINK(dns_order_ent_t) link; ISC_LINK(dns_order_ent_t) link;
}; };
@ -66,14 +66,10 @@ dns_order_create(isc_mem_t *mctx, dns_order_t **orderp) {
void void
dns_order_add(dns_order_t *order, const dns_name_t *name, dns_order_add(dns_order_t *order, const dns_name_t *name,
dns_rdatatype_t rdtype, dns_rdataclass_t rdclass, dns_rdatatype_t rdtype, dns_rdataclass_t rdclass,
unsigned int mode) { dns_orderopt_t mode) {
dns_order_ent_t *ent = NULL; dns_order_ent_t *ent = NULL;
REQUIRE(DNS_ORDER_VALID(order)); REQUIRE(DNS_ORDER_VALID(order));
REQUIRE(mode == DNS_RDATASETATTR_RANDOMIZE ||
mode == DNS_RDATASETATTR_FIXEDORDER ||
mode == DNS_RDATASETATTR_CYCLIC ||
mode == DNS_RDATASETATTR_NONE);
ent = isc_mem_get(order->mctx, sizeof(*ent)); ent = isc_mem_get(order->mctx, sizeof(*ent));
*ent = (dns_order_ent_t){ *ent = (dns_order_ent_t){
@ -97,7 +93,7 @@ match(const dns_name_t *name1, const dns_name_t *name2) {
return dns_name_equal(name1, name2); return dns_name_equal(name1, name2);
} }
unsigned int dns_orderopt_t
dns_order_find(dns_order_t *order, const dns_name_t *name, dns_order_find(dns_order_t *order, const dns_name_t *name,
dns_rdatatype_t rdtype, dns_rdataclass_t rdclass) { dns_rdatatype_t rdtype, dns_rdataclass_t rdclass) {
REQUIRE(DNS_ORDER_VALID(order)); REQUIRE(DNS_ORDER_VALID(order));
@ -115,7 +111,7 @@ dns_order_find(dns_order_t *order, const dns_name_t *name,
return ent->mode; return ent->mode;
} }
} }
return DNS_RDATASETATTR_NONE; return dns_order_none;
} }
void void

30
lib/dns/qpcache.c
View File

@ -1013,16 +1013,16 @@ bindrdataset(qpcache_t *qpdb, qpcnode_t *node, dns_slabheader_t *header,
rdataset->resign = 0; rdataset->resign = 0;
if (NEGATIVE(header)) { if (NEGATIVE(header)) {
rdataset->attributes |= DNS_RDATASETATTR_NEGATIVE; rdataset->attributes.negative = true;
} }
if (NXDOMAIN(header)) { if (NXDOMAIN(header)) {
rdataset->attributes |= DNS_RDATASETATTR_NXDOMAIN; rdataset->attributes.nxdomain = true;
} }
if (OPTOUT(header)) { if (OPTOUT(header)) {
rdataset->attributes |= DNS_RDATASETATTR_OPTOUT; rdataset->attributes.optout = true;
} }
if (PREFETCH(header)) { if (PREFETCH(header)) {
rdataset->attributes |= DNS_RDATASETATTR_PREFETCH; rdataset->attributes.prefetch = true;
} }
if (stale && !ancient) { if (stale && !ancient) {
@ -1033,12 +1033,12 @@ bindrdataset(qpcache_t *qpdb, qpcnode_t *node, dns_slabheader_t *header,
rdataset->ttl = 0; rdataset->ttl = 0;
} }
if (STALE_WINDOW(header)) { if (STALE_WINDOW(header)) {
rdataset->attributes |= DNS_RDATASETATTR_STALE_WINDOW; rdataset->attributes.stale_window = true;
} }
rdataset->attributes |= DNS_RDATASETATTR_STALE; rdataset->attributes.stale = true;
rdataset->expire = header->expire; rdataset->expire = header->expire;
} else if (!ACTIVE(header, now)) { } else if (!ACTIVE(header, now)) {
rdataset->attributes |= DNS_RDATASETATTR_ANCIENT; rdataset->attributes.ancient = true;
rdataset->ttl = 0; rdataset->ttl = 0;
} }
@ -1055,11 +1055,11 @@ bindrdataset(qpcache_t *qpdb, qpcnode_t *node, dns_slabheader_t *header,
*/ */
rdataset->slab.noqname = header->noqname; rdataset->slab.noqname = header->noqname;
if (header->noqname != NULL) { if (header->noqname != NULL) {
rdataset->attributes |= DNS_RDATASETATTR_NOQNAME; rdataset->attributes.noqname = true;
} }
rdataset->slab.closest = header->closest; rdataset->slab.closest = header->closest;
if (header->closest != NULL) { if (header->closest != NULL) {
rdataset->attributes |= DNS_RDATASETATTR_CLOSEST; rdataset->attributes.closest = true;
} }
} }
@ -2962,19 +2962,19 @@ qpcache_addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
atomic_init(&newheader->count, atomic_init(&newheader->count,
atomic_fetch_add_relaxed(&init_count, 1)); atomic_fetch_add_relaxed(&init_count, 1));
if ((rdataset->attributes & DNS_RDATASETATTR_PREFETCH) != 0) { if (rdataset->attributes.prefetch) {
DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_PREFETCH); DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_PREFETCH);
} }
if ((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0) { if (rdataset->attributes.negative) {
DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_NEGATIVE); DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_NEGATIVE);
} }
if ((rdataset->attributes & DNS_RDATASETATTR_NXDOMAIN) != 0) { if (rdataset->attributes.nxdomain) {
DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_NXDOMAIN); DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_NXDOMAIN);
} }
if ((rdataset->attributes & DNS_RDATASETATTR_OPTOUT) != 0) { if (rdataset->attributes.optout) {
DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_OPTOUT); DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_OPTOUT);
} }
if ((rdataset->attributes & DNS_RDATASETATTR_NOQNAME) != 0) { if (rdataset->attributes.noqname) {
result = addnoqname(qpdb->common.mctx, newheader, result = addnoqname(qpdb->common.mctx, newheader,
qpdb->maxrrperset, rdataset); qpdb->maxrrperset, rdataset);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {
@ -2982,7 +2982,7 @@ qpcache_addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
return result; return result;
} }
} }
if ((rdataset->attributes & DNS_RDATASETATTR_CLOSEST) != 0) { if (rdataset->attributes.closest) {
result = addclosest(qpdb->common.mctx, newheader, result = addclosest(qpdb->common.mctx, newheader,
qpdb->maxrrperset, rdataset); qpdb->maxrrperset, rdataset);
if (result != ISC_R_SUCCESS) { if (result != ISC_R_SUCCESS) {

24
lib/dns/qpzone.c
View File

@ -1058,7 +1058,7 @@ bindrdataset(qpzonedb_t *qpdb, qpznode_t *node, dns_slabheader_t *header,
rdataset->trust = header->trust; rdataset->trust = header->trust;
if (OPTOUT(header)) { if (OPTOUT(header)) {
rdataset->attributes |= DNS_RDATASETATTR_OPTOUT; rdataset->attributes.optout = true;
} }
rdataset->count = atomic_fetch_add_relaxed(&header->count, 1); rdataset->count = atomic_fetch_add_relaxed(&header->count, 1);
@ -1074,18 +1074,18 @@ bindrdataset(qpzonedb_t *qpdb, qpznode_t *node, dns_slabheader_t *header,
*/ */
rdataset->slab.noqname = header->noqname; rdataset->slab.noqname = header->noqname;
if (header->noqname != NULL) { if (header->noqname != NULL) {
rdataset->attributes |= DNS_RDATASETATTR_NOQNAME; rdataset->attributes.noqname = true;
} }
rdataset->slab.closest = header->closest; rdataset->slab.closest = header->closest;
if (header->closest != NULL) { if (header->closest != NULL) {
rdataset->attributes |= DNS_RDATASETATTR_CLOSEST; rdataset->attributes.closest = true;
} }
/* /*
* Copy out re-signing information. * Copy out re-signing information.
*/ */
if (RESIGN(header)) { if (RESIGN(header)) {
rdataset->attributes |= DNS_RDATASETATTR_RESIGN; rdataset->attributes.resign = true;
rdataset->resign = (header->resign << 1) | header->resign_lsb; rdataset->resign = (header->resign << 1) | header->resign_lsb;
} else { } else {
rdataset->resign = 0; rdataset->resign = 0;
@ -2228,7 +2228,7 @@ loading_addrdataset(void *arg, const dns_name_t *name,
dns_slabheader_setownercase(newheader, name); dns_slabheader_setownercase(newheader, name);
if ((rdataset->attributes & DNS_RDATASETATTR_RESIGN) != 0) { if (rdataset->attributes.resign) {
DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_RESIGN); DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_RESIGN);
newheader->resign = newheader->resign =
(isc_stdtime_t)(dns_time64_from32(rdataset->resign) >> (isc_stdtime_t)(dns_time64_from32(rdataset->resign) >>
@ -4745,7 +4745,7 @@ qpzone_addrdataset(dns_db_t *db, dns_dbnode_t *dbnode,
atomic_fetch_add_relaxed(&init_count, 1)); atomic_fetch_add_relaxed(&init_count, 1));
newheader->serial = version->serial; newheader->serial = version->serial;
if ((rdataset->attributes & DNS_RDATASETATTR_RESIGN) != 0) { if (rdataset->attributes.resign) {
DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_RESIGN); DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_RESIGN);
newheader->resign = newheader->resign =
(isc_stdtime_t)(dns_time64_from32(rdataset->resign) >> (isc_stdtime_t)(dns_time64_from32(rdataset->resign) >>
@ -4857,7 +4857,7 @@ qpzone_subtractrdataset(dns_db_t *db, dns_dbnode_t *dbnode,
newheader->serial = version->serial; newheader->serial = version->serial;
atomic_init(&newheader->count, atomic_init(&newheader->count,
atomic_fetch_add_relaxed(&init_count, 1)); atomic_fetch_add_relaxed(&init_count, 1));
if ((rdataset->attributes & DNS_RDATASETATTR_RESIGN) != 0) { if (rdataset->attributes.resign) {
DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_RESIGN); DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_RESIGN);
newheader->resign = newheader->resign =
(isc_stdtime_t)(dns_time64_from32(rdataset->resign) >> (isc_stdtime_t)(dns_time64_from32(rdataset->resign) >>
@ -5161,7 +5161,7 @@ glue_nsdname_cb(void *arg, const dns_name_t *name, dns_rdatatype_t qtype,
/* /*
* If the currently processed NS record is in-bailiwick, mark any glue * If the currently processed NS record is in-bailiwick, mark any glue
* RRsets found for it with DNS_RDATASETATTR_REQUIRED. Note that for * RRsets found for it with 'required' attribute. Note that for
* simplicity, glue RRsets for all in-bailiwick NS records are marked * simplicity, glue RRsets for all in-bailiwick NS records are marked
* this way, even though dns_message_rendersection() only checks the * this way, even though dns_message_rendersection() only checks the
* attributes for the first rdataset associated with the first name * attributes for the first rdataset associated with the first name
@ -5169,12 +5169,10 @@ glue_nsdname_cb(void *arg, const dns_name_t *name, dns_rdatatype_t qtype,
*/ */
if (glue != NULL && dns_name_issubdomain(name, &node->name)) { if (glue != NULL && dns_name_issubdomain(name, &node->name)) {
if (dns_rdataset_isassociated(&glue->rdataset_a)) { if (dns_rdataset_isassociated(&glue->rdataset_a)) {
glue->rdataset_a.attributes |= glue->rdataset_a.attributes.required = true;
DNS_RDATASETATTR_REQUIRED;
} }
if (dns_rdataset_isassociated(&glue->rdataset_aaaa)) { if (dns_rdataset_isassociated(&glue->rdataset_aaaa)) {
glue->rdataset_aaaa.attributes |= glue->rdataset_aaaa.attributes.required = true;
DNS_RDATASETATTR_REQUIRED;
} }
} }
@ -5212,7 +5210,7 @@ glue_nsdname_cb(void *arg, const dns_name_t *name, dns_rdatatype_t qtype,
return result; return result;
} }
#define IS_REQUIRED_GLUE(r) (((r)->attributes & DNS_RDATASETATTR_REQUIRED) != 0) #define IS_REQUIRED_GLUE(r) (((r)->attributes.required))
static void static void
addglue_to_message(dns_glue_t *ge, dns_message_t *msg) { addglue_to_message(dns_glue_t *ge, dns_message_t *msg) {

8
lib/dns/rdatalist.c
View File

@ -215,7 +215,7 @@ dns_rdatalist_addnoqname(dns_rdataset_t *rdataset, dns_name_t *name) {
ttl = negsig->ttl; ttl = negsig->ttl;
} }
rdataset->ttl = neg->ttl = negsig->ttl = ttl; rdataset->ttl = neg->ttl = negsig->ttl = ttl;
rdataset->attributes |= DNS_RDATASETATTR_NOQNAME; rdataset->attributes.noqname = true;
rdataset->rdlist.noqname = name; rdataset->rdlist.noqname = name;
return ISC_R_SUCCESS; return ISC_R_SUCCESS;
} }
@ -230,7 +230,7 @@ dns_rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
dns_name_t *noqname = NULL; dns_name_t *noqname = NULL;
REQUIRE(rdataset != NULL); REQUIRE(rdataset != NULL);
REQUIRE((rdataset->attributes & DNS_RDATASETATTR_NOQNAME) != 0); REQUIRE(rdataset->attributes.noqname);
rdclass = rdataset->rdclass; rdclass = rdataset->rdclass;
noqname = rdataset->rdlist.noqname; noqname = rdataset->rdlist.noqname;
@ -312,7 +312,7 @@ dns_rdatalist_addclosest(dns_rdataset_t *rdataset, dns_name_t *name) {
ttl = negsig->ttl; ttl = negsig->ttl;
} }
rdataset->ttl = neg->ttl = negsig->ttl = ttl; rdataset->ttl = neg->ttl = negsig->ttl = ttl;
rdataset->attributes |= DNS_RDATASETATTR_CLOSEST; rdataset->attributes.closest = true;
rdataset->rdlist.closest = name; rdataset->rdlist.closest = name;
return ISC_R_SUCCESS; return ISC_R_SUCCESS;
} }
@ -327,7 +327,7 @@ dns_rdatalist_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
dns_name_t *closest = NULL; dns_name_t *closest = NULL;
REQUIRE(rdataset != NULL); REQUIRE(rdataset != NULL);
REQUIRE((rdataset->attributes & DNS_RDATASETATTR_CLOSEST) != 0); REQUIRE(rdataset->attributes.closest);
rdclass = rdataset->rdclass; rdclass = rdataset->rdclass;
closest = rdataset->rdlist.closest; closest = rdataset->rdlist.closest;

18
lib/dns/rdataset.c
View File

@ -29,6 +29,7 @@
#include <dns/ncache.h> #include <dns/ncache.h>
#include <dns/rdata.h> #include <dns/rdata.h>
#include <dns/rdataset.h> #include <dns/rdataset.h>
#include <dns/types.h>
static const char *trustnames[] = { static const char *trustnames[] = {
"none", "pending-additional", "none", "pending-additional",
@ -141,7 +142,7 @@ dns_rdataset_makequestion(dns_rdataset_t *rdataset, dns_rdataclass_t rdclass,
rdataset->methods = &question_methods; rdataset->methods = &question_methods;
rdataset->rdclass = rdclass; rdataset->rdclass = rdclass;
rdataset->type = type; rdataset->type = type;
rdataset->attributes |= DNS_RDATASETATTR_QUESTION; rdataset->attributes.question = true;
} }
unsigned int unsigned int
@ -208,9 +209,8 @@ dns_rdataset_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) {
} }
#define MAX_SHUFFLE 32 #define MAX_SHUFFLE 32
#define WANT_FIXED(r) (((r)->attributes & DNS_RDATASETATTR_FIXEDORDER) != 0) #define WANT_RANDOM(r) (((r)->attributes.order == dns_order_randomize))
#define WANT_RANDOM(r) (((r)->attributes & DNS_RDATASETATTR_RANDOMIZE) != 0) #define WANT_CYCLIC(r) (((r)->attributes.order == dns_order_cyclic))
#define WANT_CYCLIC(r) (((r)->attributes & DNS_RDATASETATTR_CYCLIC) != 0)
struct towire_sort { struct towire_sort {
int key; int key;
@ -257,12 +257,12 @@ towire(dns_rdataset_t *rdataset, const dns_name_t *owner_name,
want_random = WANT_RANDOM(rdataset); want_random = WANT_RANDOM(rdataset);
want_cyclic = WANT_CYCLIC(rdataset); want_cyclic = WANT_CYCLIC(rdataset);
if ((rdataset->attributes & DNS_RDATASETATTR_QUESTION) != 0) { if (rdataset->attributes.question) {
question = true; question = true;
count = 1; count = 1;
result = dns_rdataset_first(rdataset); result = dns_rdataset_first(rdataset);
INSIST(result == ISC_R_NOMORE); INSIST(result == ISC_R_NOMORE);
} else if ((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0) { } else if (rdataset->attributes.negative) {
/* /*
* This is a negative caching rdataset. * This is a negative caching rdataset.
*/ */
@ -481,7 +481,7 @@ dns_rdataset_additionaldata(dns_rdataset_t *rdataset,
*/ */
REQUIRE(DNS_RDATASET_VALID(rdataset)); REQUIRE(DNS_RDATASET_VALID(rdataset));
REQUIRE((rdataset->attributes & DNS_RDATASETATTR_QUESTION) == 0); REQUIRE(!rdataset->attributes.question);
if (limit != 0 && dns_rdataset_count(rdataset) > limit) { if (limit != 0 && dns_rdataset_count(rdataset) > limit) {
return DNS_R_TOOMANYRECORDS; return DNS_R_TOOMANYRECORDS;
@ -586,7 +586,7 @@ dns_rdataset_setownercase(dns_rdataset_t *rdataset, const dns_name_t *name) {
REQUIRE(rdataset->methods != NULL); REQUIRE(rdataset->methods != NULL);
if (rdataset->methods->setownercase != NULL && if (rdataset->methods->setownercase != NULL &&
(rdataset->attributes & DNS_RDATASETATTR_KEEPCASE) == 0) !rdataset->attributes.keepcase)
{ {
(rdataset->methods->setownercase)(rdataset, name); (rdataset->methods->setownercase)(rdataset, name);
} }
@ -598,7 +598,7 @@ dns_rdataset_getownercase(const dns_rdataset_t *rdataset, dns_name_t *name) {
REQUIRE(rdataset->methods != NULL); REQUIRE(rdataset->methods != NULL);
if (rdataset->methods->getownercase != NULL && if (rdataset->methods->getownercase != NULL &&
(rdataset->attributes & DNS_RDATASETATTR_KEEPCASE) == 0) !rdataset->attributes.keepcase)
{ {
(rdataset->methods->getownercase)(rdataset, name); (rdataset->methods->getownercase)(rdataset, name);
} }

12
lib/dns/rdataslab.c
View File

@ -1099,9 +1099,10 @@ rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
.slab.raw = noqname->neg, .slab.raw = noqname->neg,
.link = nsec->link, .link = nsec->link,
.count = nsec->count, .count = nsec->count,
.attributes = nsec->attributes | DNS_RDATASETATTR_KEEPCASE, .attributes = nsec->attributes,
.magic = nsec->magic, .magic = nsec->magic,
}; };
nsec->attributes.keepcase = true;
dns__db_attachnode(db, node, dns__db_attachnode(db, node,
&(dns_dbnode_t *){ NULL } DNS__DB_FLARG_PASS); &(dns_dbnode_t *){ NULL } DNS__DB_FLARG_PASS);
@ -1117,9 +1118,10 @@ rdataset_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
.slab.raw = noqname->negsig, .slab.raw = noqname->negsig,
.link = nsecsig->link, .link = nsecsig->link,
.count = nsecsig->count, .count = nsecsig->count,
.attributes = nsecsig->attributes | DNS_RDATASETATTR_KEEPCASE, .attributes = nsecsig->attributes,
.magic = nsecsig->magic, .magic = nsecsig->magic,
}; };
nsecsig->attributes.keepcase = true;
dns_name_clone(&noqname->name, name); dns_name_clone(&noqname->name, name);
@ -1152,9 +1154,10 @@ rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
.slab.raw = closest->neg, .slab.raw = closest->neg,
.link = nsec->link, .link = nsec->link,
.count = nsec->count, .count = nsec->count,
.attributes = nsec->attributes | DNS_RDATASETATTR_KEEPCASE, .attributes = nsec->attributes,
.magic = nsec->magic, .magic = nsec->magic,
}; };
nsec->attributes.keepcase = true;
dns__db_attachnode(db, node, dns__db_attachnode(db, node,
&(dns_dbnode_t *){ NULL } DNS__DB_FLARG_PASS); &(dns_dbnode_t *){ NULL } DNS__DB_FLARG_PASS);
@ -1170,9 +1173,10 @@ rdataset_getclosest(dns_rdataset_t *rdataset, dns_name_t *name,
.slab.raw = closest->negsig, .slab.raw = closest->negsig,
.link = nsecsig->link, .link = nsecsig->link,
.count = nsecsig->count, .count = nsecsig->count,
.attributes = nsecsig->attributes | DNS_RDATASETATTR_KEEPCASE, .attributes = nsecsig->attributes,
.magic = nsecsig->magic, .magic = nsecsig->magic,
}; };
nsecsig->attributes.keepcase = true;
dns_name_clone(&closest->name, name); dns_name_clone(&closest->name, name);

83
lib/dns/resolver.c
View File

@ -629,9 +629,9 @@ enum {
#define BADCOOKIE(a) (((a)->flags & FCTX_ADDRINFO_BADCOOKIE) != 0) #define BADCOOKIE(a) (((a)->flags & FCTX_ADDRINFO_BADCOOKIE) != 0)
#define ISDUALSTACK(a) (((a)->flags & FCTX_ADDRINFO_DUALSTACK) != 0) #define ISDUALSTACK(a) (((a)->flags & FCTX_ADDRINFO_DUALSTACK) != 0)
#define NXDOMAIN(r) (((r)->attributes & DNS_RDATASETATTR_NXDOMAIN) != 0) #define NXDOMAIN(r) (((r)->attributes.nxdomain))
#define NEGATIVE(r) (((r)->attributes & DNS_RDATASETATTR_NEGATIVE) != 0) #define NEGATIVE(r) (((r)->attributes.negative))
#define STATICSTUB(r) (((r)->attributes & DNS_RDATASETATTR_STATICSTUB) != 0) #define STATICSTUB(r) (((r)->attributes.staticstub))
#ifdef ENABLE_AFL #ifdef ENABLE_AFL
bool dns_fuzzing_resolver = false; bool dns_fuzzing_resolver = false;
@ -5052,13 +5052,13 @@ clone_results(fetchctx_t *fctx) {
} }
} }
#define CACHE(r) (((r)->attributes & DNS_RDATASETATTR_CACHE) != 0) #define CACHE(r) (((r)->attributes.cache))
#define ANSWER(r) (((r)->attributes & DNS_RDATASETATTR_ANSWER) != 0) #define ANSWER(r) (((r)->attributes.answer))
#define ANSWERSIG(r) (((r)->attributes & DNS_RDATASETATTR_ANSWERSIG) != 0) #define ANSWERSIG(r) (((r)->attributes.answersig))
#define EXTERNAL(r) (((r)->attributes & DNS_RDATASETATTR_EXTERNAL) != 0) #define EXTERNAL(r) (((r)->attributes.external))
#define CHAINING(r) (((r)->attributes & DNS_RDATASETATTR_CHAINING) != 0) #define CHAINING(r) (((r)->attributes.chaining))
#define CHASE(r) (((r)->attributes & DNS_RDATASETATTR_CHASE) != 0) #define CHASE(r) (((r)->attributes.chase))
#define CHECKNAMES(r) (((r)->attributes & DNS_RDATASETATTR_CHECKNAMES) != 0) #define CHECKNAMES(r) (((r)->attributes.checknames))
/* /*
* Cancel validators associated with '*fctx' if it is ready to be * Cancel validators associated with '*fctx' if it is ready to be
@ -5953,7 +5953,7 @@ cache_name(fetchctx_t *fctx, dns_name_t *name, dns_message_t *message,
* Mark the rdataset as being prefetch eligible. * Mark the rdataset as being prefetch eligible.
*/ */
if (rdataset->ttl >= fctx->res->view->prefetch_eligible) { if (rdataset->ttl >= fctx->res->view->prefetch_eligible) {
rdataset->attributes |= DNS_RDATASETATTR_PREFETCH; rdataset->attributes.prefetch = true;
} }
/* /*
@ -6016,8 +6016,7 @@ cache_name(fetchctx_t *fctx, dns_name_t *name, dns_message_t *message,
*/ */
if (rdataset->ttl >= fctx->res->view->prefetch_eligible) if (rdataset->ttl >= fctx->res->view->prefetch_eligible)
{ {
rdataset->attributes |= rdataset->attributes.prefetch = true;
DNS_RDATASETATTR_PREFETCH;
} }
/* /*
@ -6584,11 +6583,11 @@ mark_related(dns_name_t *name, dns_rdataset_t *rdataset, bool external,
*/ */
if (!CACHE(rdataset)) { if (!CACHE(rdataset)) {
name->attributes.chase = true; name->attributes.chase = true;
rdataset->attributes |= DNS_RDATASETATTR_CHASE; rdataset->attributes.chase = true;
} }
rdataset->attributes |= DNS_RDATASETATTR_CACHE; rdataset->attributes.cache = true;
if (external) { if (external) {
rdataset->attributes |= DNS_RDATASETATTR_EXTERNAL; rdataset->attributes.external = true;
} }
} }
@ -7154,8 +7153,7 @@ checknamessection(dns_message_t *message, dns_section_t section) {
rdata.type, false) || rdata.type, false) ||
!dns_rdata_checknames(&rdata, name, NULL)) !dns_rdata_checknames(&rdata, name, NULL))
{ {
rdataset->attributes |= rdataset->attributes.checknames = true;
DNS_RDATASETATTR_CHECKNAMES;
} }
} }
} }
@ -8489,8 +8487,8 @@ rctx_answer_any(respctx_t *rctx) {
rctx->aname->attributes.cache = true; rctx->aname->attributes.cache = true;
rctx->aname->attributes.answer = true; rctx->aname->attributes.answer = true;
rdataset->attributes |= DNS_RDATASETATTR_ANSWER; rdataset->attributes.answer = true;
rdataset->attributes |= DNS_RDATASETATTR_CACHE; rdataset->attributes.cache = true;
rdataset->trust = rctx->trust; rdataset->trust = rctx->trust;
} }
@ -8532,8 +8530,8 @@ rctx_answer_match(respctx_t *rctx) {
rctx->aname->attributes.cache = true; rctx->aname->attributes.cache = true;
rctx->aname->attributes.answer = true; rctx->aname->attributes.answer = true;
rctx->ardataset->attributes |= DNS_RDATASETATTR_ANSWER; rctx->ardataset->attributes.answer = true;
rctx->ardataset->attributes |= DNS_RDATASETATTR_CACHE; rctx->ardataset->attributes.cache = true;
rctx->ardataset->trust = rctx->trust; rctx->ardataset->trust = rctx->trust;
(void)dns_rdataset_additionaldata(rctx->ardataset, rctx->aname, (void)dns_rdataset_additionaldata(rctx->ardataset, rctx->aname,
check_related, rctx, check_related, rctx,
@ -8551,8 +8549,8 @@ rctx_answer_match(respctx_t *rctx) {
continue; continue;
} }
sigrdataset->attributes |= DNS_RDATASETATTR_ANSWERSIG; sigrdataset->attributes.answersig = true;
sigrdataset->attributes |= DNS_RDATASETATTR_CACHE; sigrdataset->attributes.cache = true;
sigrdataset->trust = rctx->trust; sigrdataset->trust = rctx->trust;
break; break;
} }
@ -8594,9 +8592,9 @@ rctx_answer_cname(respctx_t *rctx) {
rctx->cname->attributes.cache = true; rctx->cname->attributes.cache = true;
rctx->cname->attributes.answer = true; rctx->cname->attributes.answer = true;
rctx->cname->attributes.chaining = true; rctx->cname->attributes.chaining = true;
rctx->crdataset->attributes |= DNS_RDATASETATTR_ANSWER; rctx->crdataset->attributes.answer = true;
rctx->crdataset->attributes |= DNS_RDATASETATTR_CACHE; rctx->crdataset->attributes.cache = true;
rctx->crdataset->attributes |= DNS_RDATASETATTR_CHAINING; rctx->crdataset->attributes.chaining = true;
rctx->crdataset->trust = rctx->trust; rctx->crdataset->trust = rctx->trust;
ISC_LIST_FOREACH (rctx->cname->list, sigrdataset, link) { ISC_LIST_FOREACH (rctx->cname->list, sigrdataset, link) {
@ -8611,8 +8609,8 @@ rctx_answer_cname(respctx_t *rctx) {
continue; continue;
} }
sigrdataset->attributes |= DNS_RDATASETATTR_ANSWERSIG; sigrdataset->attributes.answersig = true;
sigrdataset->attributes |= DNS_RDATASETATTR_CACHE; sigrdataset->attributes.cache = true;
sigrdataset->trust = rctx->trust; sigrdataset->trust = rctx->trust;
break; break;
} }
@ -8644,9 +8642,9 @@ rctx_answer_dname(respctx_t *rctx) {
rctx->dname->attributes.cache = true; rctx->dname->attributes.cache = true;
rctx->dname->attributes.answer = true; rctx->dname->attributes.answer = true;
rctx->dname->attributes.chaining = true; rctx->dname->attributes.chaining = true;
rctx->drdataset->attributes |= DNS_RDATASETATTR_ANSWER; rctx->drdataset->attributes.answer = true;
rctx->drdataset->attributes |= DNS_RDATASETATTR_CACHE; rctx->drdataset->attributes.cache = true;
rctx->drdataset->attributes |= DNS_RDATASETATTR_CHAINING; rctx->drdataset->attributes.chaining = true;
rctx->drdataset->trust = rctx->trust; rctx->drdataset->trust = rctx->trust;
ISC_LIST_FOREACH (rctx->dname->list, sigrdataset, link) { ISC_LIST_FOREACH (rctx->dname->list, sigrdataset, link) {
@ -8661,8 +8659,8 @@ rctx_answer_dname(respctx_t *rctx) {
continue; continue;
} }
sigrdataset->attributes |= DNS_RDATASETATTR_ANSWERSIG; sigrdataset->attributes.answersig = true;
sigrdataset->attributes |= DNS_RDATASETATTR_CACHE; sigrdataset->attributes.cache = true;
sigrdataset->trust = rctx->trust; sigrdataset->trust = rctx->trust;
break; break;
} }
@ -8698,8 +8696,7 @@ rctx_authority_positive(respctx_t *rctx) {
rdataset->covers == dns_rdatatype_ns)) rdataset->covers == dns_rdatatype_ns))
{ {
name->attributes.cache = true; name->attributes.cache = true;
rdataset->attributes |= rdataset->attributes.cache = true;
DNS_RDATASETATTR_CACHE;
if (rctx->aa) { if (rctx->aa) {
rdataset->trust = rdataset->trust =
@ -8933,7 +8930,7 @@ rctx_authority_negative(respctx_t *rctx) {
rctx->ns_rdataset = rdataset; rctx->ns_rdataset = rdataset;
} }
name->attributes.cache = true; name->attributes.cache = true;
rdataset->attributes |= DNS_RDATASETATTR_CACHE; rdataset->attributes.cache = true;
rdataset->trust = dns_trust_glue; rdataset->trust = dns_trust_glue;
break; break;
case dns_rdatatype_soa: case dns_rdatatype_soa:
@ -8957,7 +8954,7 @@ rctx_authority_negative(respctx_t *rctx) {
rctx->soa_name = name; rctx->soa_name = name;
} }
name->attributes.ncache = true; name->attributes.ncache = true;
rdataset->attributes |= DNS_RDATASETATTR_NCACHE; rdataset->attributes.ncache = true;
if (rctx->aa) { if (rctx->aa) {
rdataset->trust = rdataset->trust =
dns_trust_authauthority; dns_trust_authauthority;
@ -9049,12 +9046,10 @@ rctx_authority_dnssec(respctx_t *rctx) {
case dns_rdatatype_nsec3: case dns_rdatatype_nsec3:
if (rctx->negative) { if (rctx->negative) {
name->attributes.ncache = true; name->attributes.ncache = true;
rdataset->attributes |= rdataset->attributes.ncache = true;
DNS_RDATASETATTR_NCACHE;
} else if (type == dns_rdatatype_nsec) { } else if (type == dns_rdatatype_nsec) {
name->attributes.cache = true; name->attributes.cache = true;
rdataset->attributes |= rdataset->attributes.cache = true;
DNS_RDATASETATTR_CACHE;
} }
if (rctx->aa) { if (rctx->aa) {
@ -9100,7 +9095,7 @@ rctx_authority_dnssec(respctx_t *rctx) {
} }
name->attributes.cache = true; name->attributes.cache = true;
rdataset->attributes |= DNS_RDATASETATTR_CACHE; rdataset->attributes.cache = true;
if ((fctx->options & DNS_FETCHOPT_NONTA) != 0) { if ((fctx->options & DNS_FETCHOPT_NONTA) != 0) {
checknta = false; checknta = false;
@ -9286,7 +9281,7 @@ again:
name->attributes.chase = false; name->attributes.chase = false;
ISC_LIST_FOREACH (name->list, rdataset, link) { ISC_LIST_FOREACH (name->list, rdataset, link) {
if (CHASE(rdataset)) { if (CHASE(rdataset)) {
rdataset->attributes &= ~DNS_RDATASETATTR_CHASE; rdataset->attributes.chase = false;
(void)dns_rdataset_additionaldata( (void)dns_rdataset_additionaldata(
rdataset, name, check_related, rctx, rdataset, name, check_related, rctx,
DNS_RDATASET_MAXADDITIONAL); DNS_RDATASET_MAXADDITIONAL);

4
lib/dns/validator.c
View File

@ -115,8 +115,8 @@ enum valattr {
#define OFFLOADED(v) (((v)->attributes & VALATTR_OFFLOADED) != 0) #define OFFLOADED(v) (((v)->attributes & VALATTR_OFFLOADED) != 0)
#define COMPLETE(v) (((v)->attributes & VALATTR_COMPLETE) != 0) #define COMPLETE(v) (((v)->attributes & VALATTR_COMPLETE) != 0)
#define NEGATIVE(r) (((r)->attributes & DNS_RDATASETATTR_NEGATIVE) != 0) #define NEGATIVE(r) (((r)->attributes.negative))
#define NXDOMAIN(r) (((r)->attributes & DNS_RDATASETATTR_NXDOMAIN) != 0) #define NXDOMAIN(r) (((r)->attributes.nxdomain))
#define MAXVALIDATIONS(r) (((r)->attributes & VALATTR_MAXVALIDATIONS) != 0) #define MAXVALIDATIONS(r) (((r)->attributes & VALATTR_MAXVALIDATIONS) != 0)
#define MAXVALIDATIONFAILS(r) \ #define MAXVALIDATIONFAILS(r) \

2
lib/dns/view.c
View File

@ -1110,7 +1110,7 @@ db_find:
* addresses we use the configured server addresses. * addresses we use the configured server addresses.
*/ */
if (dns_zone_gettype(zone) == dns_zone_staticstub) { if (dns_zone_gettype(zone) == dns_zone_staticstub) {
rdataset->attributes |= DNS_RDATASETATTR_STATICSTUB; rdataset->attributes.staticstub = true;
} }
if (use_cache && view->cachedb != NULL && db != view->hints) { if (use_cache && view->cachedb != NULL && db != view->hints) {

66
lib/ns/query.c
View File

@ -148,13 +148,13 @@
#define QUERY_STALETIMEOUT(q) (((q)->dboptions & DNS_DBFIND_STALETIMEOUT) != 0) #define QUERY_STALETIMEOUT(q) (((q)->dboptions & DNS_DBFIND_STALETIMEOUT) != 0)
/*% Does the rdataset 'r' have an attached 'No QNAME Proof'? */ /*% Does the rdataset 'r' have an attached 'No QNAME Proof'? */
#define NOQNAME(r) (((r)->attributes & DNS_RDATASETATTR_NOQNAME) != 0) #define NOQNAME(r) (((r)->attributes.noqname))
/*% Does the rdataset 'r' contain a stale answer? */ /*% Does the rdataset 'r' contain a stale answer? */
#define STALE(r) (((r)->attributes & DNS_RDATASETATTR_STALE) != 0) #define STALE(r) (((r)->attributes.stale))
/*% Does the rdataset 'r' is stale and within stale-refresh-time? */ /*% Does the rdataset 'r' is stale and within stale-refresh-time? */
#define STALE_WINDOW(r) (((r)->attributes & DNS_RDATASETATTR_STALE_WINDOW) != 0) #define STALE_WINDOW(r) (((r)->attributes.stale_window))
#ifdef WANT_QUERYTRACE #ifdef WANT_QUERYTRACE
static void static void
@ -511,9 +511,6 @@ query_addwildcardproof(query_ctx_t *qctx, bool ispositive, bool nodata);
static void static void
query_addauth(query_ctx_t *qctx); query_addauth(query_ctx_t *qctx);
static void
query_clear_stale(ns_client_t *client);
/* /*
* Increment query statistics counters. * Increment query statistics counters.
*/ */
@ -2179,7 +2176,7 @@ query_setorder(query_ctx_t *qctx, dns_name_t *name, dns_rdataset_t *rdataset) {
UNUSED(client); UNUSED(client);
if (order != NULL) { if (order != NULL) {
rdataset->attributes |= dns_order_find( rdataset->attributes.order = dns_order_find(
order, name, rdataset->type, rdataset->rdclass); order, name, rdataset->type, rdataset->rdclass);
} }
} }
@ -2269,12 +2266,11 @@ query_addrrset(query_ctx_t *qctx, dns_name_t **namep,
if (dbuf != NULL) { if (dbuf != NULL) {
ns_client_releasename(client, namep); ns_client_releasename(client, namep);
} }
if ((rdataset->attributes & DNS_RDATASETATTR_REQUIRED) != 0) { if (rdataset->attributes.required) {
mrdataset->attributes |= DNS_RDATASETATTR_REQUIRED; mrdataset->attributes.required = true;
} }
if ((rdataset->attributes & DNS_RDATASETATTR_STALE_ADDED) != 0) if (rdataset->attributes.stale_added) {
{ mrdataset->attributes.stale_added = true;
mrdataset->attributes |= DNS_RDATASETATTR_STALE_ADDED;
} }
return; return;
} else if (result == DNS_R_NXDOMAIN) { } else if (result == DNS_R_NXDOMAIN) {
@ -2826,7 +2822,7 @@ query_prefetch(ns_client_t *client, dns_name_t *qname,
if (FETCH_RECTYPE_PREFETCH(client) != NULL || if (FETCH_RECTYPE_PREFETCH(client) != NULL ||
client->inner.view->prefetch_trigger == 0U || client->inner.view->prefetch_trigger == 0U ||
rdataset->ttl > client->inner.view->prefetch_trigger || rdataset->ttl > client->inner.view->prefetch_trigger ||
(rdataset->attributes & DNS_RDATASETATTR_PREFETCH) == 0) !rdataset->attributes.prefetch)
{ {
return; return;
} }
@ -4364,7 +4360,7 @@ rpz_ck_dnssec(ns_client_t *client, isc_result_t qresult,
/* /*
* Look for a signature in a negative cache rdataset. * Look for a signature in a negative cache rdataset.
*/ */
if ((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) == 0) { if (!rdataset->attributes.negative) {
return true; return true;
} }
found = dns_fixedname_initname(&fixed); found = dns_fixedname_initname(&fixed);
@ -4715,7 +4711,7 @@ redirect(ns_client_t *client, dns_name_t *name, dns_rdataset_t *rdataset,
{ {
return ISC_R_NOTFOUND; return ISC_R_NOTFOUND;
} }
if ((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0) { if (rdataset->attributes.negative) {
DNS_RDATASET_FOREACH (rdataset) { DNS_RDATASET_FOREACH (rdataset) {
dns_ncache_current(rdataset, found, &trdataset); dns_ncache_current(rdataset, found, &trdataset);
type = trdataset.type; type = trdataset.type;
@ -4849,7 +4845,7 @@ redirect2(ns_client_t *client, dns_name_t *name, dns_rdataset_t *rdataset,
{ {
return ISC_R_NOTFOUND; return ISC_R_NOTFOUND;
} }
if ((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0) { if (rdataset->attributes.negative) {
DNS_RDATASET_FOREACH (rdataset) { DNS_RDATASET_FOREACH (rdataset) {
dns_ncache_current(rdataset, found, &trdataset); dns_ncache_current(rdataset, found, &trdataset);
type = trdataset.type; type = trdataset.type;
@ -5987,7 +5983,7 @@ query_lookup(query_ctx_t *qctx) {
* clean it up if needed when we resume from recursion. * clean it up if needed when we resume from recursion.
*/ */
qctx->client->query.attributes |= NS_QUERYATTR_STALEOK; qctx->client->query.attributes |= NS_QUERYATTR_STALEOK;
qctx->rdataset->attributes |= DNS_RDATASETATTR_STALE_ADDED; qctx->rdataset->attributes.stale_added = true;
} }
result = query_gotanswer(qctx, result); result = query_gotanswer(qctx, result);
@ -5997,11 +5993,11 @@ cleanup:
} }
/* /*
* Clear all rdatasets from the message that are in the given section and * Clear all rdatasets from the message, or only those with stale_added
* that have the 'attr' attribute set. * attribute set.
*/ */
static void static void
message_clearrdataset(dns_message_t *msg, unsigned int attr) { message_clearrdataset(dns_message_t *msg, bool stale_only) {
unsigned int i; unsigned int i;
/* /*
@ -6010,7 +6006,8 @@ message_clearrdataset(dns_message_t *msg, unsigned int attr) {
for (i = DNS_SECTION_ANSWER; i < DNS_SECTION_MAX; i++) { for (i = DNS_SECTION_ANSWER; i < DNS_SECTION_MAX; i++) {
ISC_LIST_FOREACH (msg->sections[i], name, link) { ISC_LIST_FOREACH (msg->sections[i], name, link) {
ISC_LIST_FOREACH (name->list, rds, link) { ISC_LIST_FOREACH (name->list, rds, link) {
if ((rds->attributes & attr) != attr) { if (stale_only && !rds->attributes.stale_added)
{
continue; continue;
} }
ISC_LIST_UNLINK(name->list, rds, link); ISC_LIST_UNLINK(name->list, rds, link);
@ -6030,15 +6027,6 @@ message_clearrdataset(dns_message_t *msg, unsigned int attr) {
} }
} }
/*
* Clear any rdatasets from the client's message that were added on a lookup
* due to a client timeout.
*/
static void
query_clear_stale(ns_client_t *client) {
message_clearrdataset(client->message, DNS_RDATASETATTR_STALE_ADDED);
}
/* /*
* Event handler to resume processing a query after recursion, or when a * Event handler to resume processing a query after recursion, or when a
* client timeout is triggered. If the query has timed out or been cancelled * client timeout is triggered. If the query has timed out or been cancelled
@ -6900,8 +6888,7 @@ query_checkrrl(query_ctx_t *qctx, isc_result_t result) {
} else if (result == DNS_R_NCACHENXDOMAIN && } else if (result == DNS_R_NCACHENXDOMAIN &&
qctx->rdataset != NULL && qctx->rdataset != NULL &&
dns_rdataset_isassociated(qctx->rdataset) && dns_rdataset_isassociated(qctx->rdataset) &&
(qctx->rdataset->attributes & qctx->rdataset->attributes.negative)
DNS_RDATASETATTR_NEGATIVE) != 0)
{ {
/* /*
* Try to use owner name in the negative cache SOA. * Try to use owner name in the negative cache SOA.
@ -7590,7 +7577,7 @@ query_addnoqnameproof(query_ctx_t *qctx) {
query_addrrset(qctx, &fname, &neg, &negsig, dbuf, query_addrrset(qctx, &fname, &neg, &negsig, dbuf,
DNS_SECTION_AUTHORITY); DNS_SECTION_AUTHORITY);
if ((qctx->noqname->attributes & DNS_RDATASETATTR_CLOSEST) == 0) { if (!qctx->noqname->attributes.closest) {
goto cleanup; goto cleanup;
} }
@ -7967,7 +7954,11 @@ query_addanswer(query_ctx_t *qctx) {
!QUERY_STALETIMEOUT(&qctx->client->query) && !qctx->refresh_rrset) !QUERY_STALETIMEOUT(&qctx->client->query) && !qctx->refresh_rrset)
{ {
CCTRACE(ISC_LOG_DEBUG(3), "query_clear_stale"); CCTRACE(ISC_LOG_DEBUG(3), "query_clear_stale");
query_clear_stale(qctx->client); /*
* Clear any rdatasets from the client's message that were added
* on a lookup due to a client timeout.
*/
message_clearrdataset(qctx->client->message, true);
/* /*
* We can clear the attribute to prevent redundant clearing * We can clear the attribute to prevent redundant clearing
* in subsequent lookups. * in subsequent lookups.
@ -10544,7 +10535,7 @@ query_addsoa(query_ctx_t *qctx, unsigned int override_ttl,
} }
if (section == DNS_SECTION_ADDITIONAL) { if (section == DNS_SECTION_ADDITIONAL) {
rdataset->attributes |= DNS_RDATASETATTR_REQUIRED; rdataset->attributes.required = true;
} }
query_addrrset(qctx, &name, &rdataset, sigrdatasetp, NULL, query_addrrset(qctx, &name, &rdataset, sigrdatasetp, NULL,
section); section);
@ -11240,8 +11231,7 @@ query_glueanswer(query_ctx_t *qctx) {
link); link);
ISC_LIST_PREPEND(name->list, rdataset, ISC_LIST_PREPEND(name->list, rdataset,
link); link);
rdataset->attributes |= rdataset->attributes.required = true;
DNS_RDATASETATTR_REQUIRED;
break; break;
} }
} }
@ -11402,7 +11392,7 @@ ns_query_done(query_ctx_t *qctx) {
* RRsets, clear the RRsets from the message before doing the * RRsets, clear the RRsets from the message before doing the
* refresh. * refresh.
*/ */
message_clearrdataset(qctx->client->message, 0); message_clearrdataset(qctx->client->message, false);
query_stale_refresh(qctx->client); query_stale_refresh(qctx->client);
} }

9
tests/dns/db_test.c
View File

@ -179,9 +179,7 @@ ISC_LOOP_TEST_IMPL(dns_dbfind_staleok) {
do { do {
count++; count++;
assert_in_range(count, 1, 21); /* loop sanity */ assert_in_range(count, 1, 21); /* loop sanity */
assert_int_equal(rdataset.attributes & assert_int_equal(rdataset.attributes.stale, false);
DNS_RDATASETATTR_STALE,
0);
assert_true(rdataset.ttl > 0); assert_true(rdataset.ttl > 0);
dns_db_detachnode(db, &node); dns_db_detachnode(db, &node);
dns_rdataset_disassociate(&rdataset); dns_rdataset_disassociate(&rdataset);
@ -215,9 +213,8 @@ ISC_LOOP_TEST_IMPL(dns_dbfind_staleok) {
count++; count++;
assert_in_range(count, 0, 49); /* loop sanity */ assert_in_range(count, 0, 49); /* loop sanity */
assert_int_equal(result, ISC_R_SUCCESS); assert_int_equal(result, ISC_R_SUCCESS);
assert_int_equal(rdataset.attributes & assert_int_equal(rdataset.attributes.stale,
DNS_RDATASETATTR_STALE, true);
DNS_RDATASETATTR_STALE);
dns_db_detachnode(db, &node); dns_db_detachnode(db, &node);
dns_rdataset_disassociate(&rdataset); dns_rdataset_disassociate(&rdataset);