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

chg: dev: Migrate rdataset attributes to struct of bools and enum

Browse Source 
Merge branch 'pspacek/rdataset-attrs-enum' into 'main'

See merge request isc-projects/bind9!10721
This commit is contained in:
Petr Špaček 2025-07-10 09:18:07 +00:00
commit 08814b10a1
23 changed files with 218 additions and 276 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);
/*%< /*%<

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

@ -55,18 +55,7 @@
#include <dns/types.h> #include <dns/types.h>
#define DNS_RDATASET_MAXADDITIONAL 13 #define DNS_RDATASET_MAXADDITIONAL 13
#define DNS_RDATASET_LENGTH 2;
/* Fixed RRSet helper macros */
#define DNS_RDATASET_LENGTH 2;
#if DNS_RDATASET_FIXED
#define DNS_RDATASET_ORDER 2
#define DNS_RDATASET_COUNT (count * 4)
#else /* !DNS_RDATASET_FIXED */
#define DNS_RDATASET_ORDER 0
#define DNS_RDATASET_COUNT 0
#endif /* DNS_RDATASET_FIXED */
typedef enum { typedef enum {
dns_rdatasetadditional_fromauth, dns_rdatasetadditional_fromauth,
@ -128,10 +117,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 */
unsigned int attributes; 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.
*/
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 +162,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 +256,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 +543,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 +552,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 +572,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 +581,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) {

32
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;
@ -1133,10 +1133,10 @@ setnsec3parameters(dns_db_t *db, qpz_version_t *version) {
*/ */
raw = dns_slabheader_raw(header); raw = dns_slabheader_raw(header);
count = raw[0] * 256 + raw[1]; /* count */ count = raw[0] * 256 + raw[1]; /* count */
raw += DNS_RDATASET_COUNT + DNS_RDATASET_LENGTH; raw += DNS_RDATASET_LENGTH;
while (count-- > 0U) { while (count-- > 0U) {
length = raw[0] * 256 + raw[1]; length = raw[0] * 256 + raw[1];
raw += DNS_RDATASET_ORDER + DNS_RDATASET_LENGTH; raw += DNS_RDATASET_LENGTH;
region.base = raw; region.base = raw;
region.length = length; region.length = length;
raw += length; raw += length;
@ -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) >>
@ -2635,11 +2635,11 @@ matchparams(dns_slabheader_t *header, qpz_search_t *search) {
raw = (unsigned char *)header + sizeof(*header); raw = (unsigned char *)header + sizeof(*header);
count = raw[0] * 256 + raw[1]; /* count */ count = raw[0] * 256 + raw[1]; /* count */
raw += DNS_RDATASET_COUNT + DNS_RDATASET_LENGTH; raw += DNS_RDATASET_LENGTH;
while (count-- > 0) { while (count-- > 0) {
rdlen = raw[0] * 256 + raw[1]; rdlen = raw[0] * 256 + raw[1];
raw += DNS_RDATASET_ORDER + DNS_RDATASET_LENGTH; raw += DNS_RDATASET_LENGTH;
region.base = raw; region.base = raw;
region.length = rdlen; region.length = rdlen;
dns_rdata_fromregion(&rdata, search->qpdb->common.rdclass, dns_rdata_fromregion(&rdata, search->qpdb->common.rdclass,
@ -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);