mirror of
https://github.com/isc-projects/bind9.git
synced 2026-06-11 07:00:00 -04:00
Unify the dns_typepair_t variable naming and usage
The dns_typepair_t and dns_rdatatype_t variables were both named 'type' in multiple places. Rename all dns_typepair_t variables to include word 'pair' in the variable name to make sure that the distinction between the two types is more clear.
This commit is contained in:
Ondřej Surý
parent
5682469a5a
commit
101b1e5a57
4 changed files with 152 additions and 145 deletions
|
|
@ -76,7 +76,7 @@ struct dns_slabheader {
|
|||
isc_stdtime_t expire;
|
||||
dns_ttl_t ttl;
|
||||
};
|
||||
dns_typepair_t type;
|
||||
dns_typepair_t typepair;
|
||||
|
||||
_Atomic(uint16_t) count;
|
||||
/*%<
|
||||
|
|
|
|||
|
|
@ -826,13 +826,13 @@ unref:
|
|||
}
|
||||
|
||||
static void
|
||||
update_rrsetstats(dns_stats_t *stats, const dns_typepair_t htype,
|
||||
update_rrsetstats(dns_stats_t *stats, const dns_typepair_t typepair,
|
||||
const uint_least16_t hattributes, const bool increment) {
|
||||
dns_rdatastatstype_t statattributes = 0;
|
||||
dns_rdatastatstype_t base = 0;
|
||||
dns_rdatastatstype_t type;
|
||||
dns_slabheader_t *header = &(dns_slabheader_t){
|
||||
.type = htype,
|
||||
.typepair = typepair,
|
||||
.attributes = hattributes,
|
||||
};
|
||||
|
||||
|
|
@ -845,10 +845,10 @@ update_rrsetstats(dns_stats_t *stats, const dns_typepair_t htype,
|
|||
statattributes = DNS_RDATASTATSTYPE_ATTR_NXDOMAIN;
|
||||
} else {
|
||||
statattributes = DNS_RDATASTATSTYPE_ATTR_NXRRSET;
|
||||
base = DNS_TYPEPAIR_COVERS(header->type);
|
||||
base = DNS_TYPEPAIR_COVERS(header->typepair);
|
||||
}
|
||||
} else {
|
||||
base = DNS_TYPEPAIR_TYPE(header->type);
|
||||
base = DNS_TYPEPAIR_TYPE(header->typepair);
|
||||
}
|
||||
|
||||
if (STALE(header)) {
|
||||
|
|
@ -890,8 +890,8 @@ mark(dns_slabheader_t *header, uint_least16_t flag) {
|
|||
*/
|
||||
stats = dns_db_getrrsetstats(&qpdb->common);
|
||||
if (stats != NULL) {
|
||||
update_rrsetstats(stats, header->type, attributes, false);
|
||||
update_rrsetstats(stats, header->type, newattributes, true);
|
||||
update_rrsetstats(stats, header->typepair, attributes, false);
|
||||
update_rrsetstats(stats, header->typepair, newattributes, true);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1038,8 +1038,8 @@ bindrdataset(qpcache_t *qpdb, qpcnode_t *node, dns_slabheader_t *header,
|
|||
|
||||
rdataset->methods = &dns_rdataslab_rdatasetmethods;
|
||||
rdataset->rdclass = qpdb->common.rdclass;
|
||||
rdataset->type = DNS_TYPEPAIR_TYPE(header->type);
|
||||
rdataset->covers = DNS_TYPEPAIR_COVERS(header->type);
|
||||
rdataset->type = DNS_TYPEPAIR_TYPE(header->typepair);
|
||||
rdataset->covers = DNS_TYPEPAIR_COVERS(header->typepair);
|
||||
rdataset->ttl = !ZEROTTL(header) ? header->expire - now : 0;
|
||||
rdataset->trust = header->trust;
|
||||
rdataset->resign = 0;
|
||||
|
|
@ -1115,7 +1115,7 @@ static isc_result_t
|
|||
setup_delegation(qpc_search_t *search, dns_dbnode_t **nodep,
|
||||
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
|
||||
isc_rwlocktype_t tlocktype DNS__DB_FLARG) {
|
||||
dns_typepair_t type;
|
||||
dns_typepair_t typepair;
|
||||
qpcnode_t *node = NULL;
|
||||
|
||||
REQUIRE(search != NULL);
|
||||
|
|
@ -1127,7 +1127,7 @@ setup_delegation(qpc_search_t *search, dns_dbnode_t **nodep,
|
|||
*/
|
||||
|
||||
node = search->zonecut;
|
||||
type = search->zonecut_header->type;
|
||||
typepair = search->zonecut_header->typepair;
|
||||
|
||||
if (nodep != NULL) {
|
||||
/*
|
||||
|
|
@ -1150,7 +1150,7 @@ setup_delegation(qpc_search_t *search, dns_dbnode_t **nodep,
|
|||
NODE_UNLOCK(nlock, &nlocktype);
|
||||
}
|
||||
|
||||
if (type == dns_rdatatype_dname) {
|
||||
if (typepair == dns_rdatatype_dname) {
|
||||
return DNS_R_DNAME;
|
||||
}
|
||||
return DNS_R_DELEGATION;
|
||||
|
|
@ -1221,28 +1221,28 @@ check_stale_header(dns_slabheader_t *header, qpc_search_t *search,
|
|||
* negative header covering either 'negtype' or ANY.
|
||||
*/
|
||||
static bool
|
||||
related_headers(dns_slabheader_t *header, dns_typepair_t type,
|
||||
dns_typepair_t sigtype, dns_typepair_t negtype,
|
||||
related_headers(dns_slabheader_t *header, dns_typepair_t typepair,
|
||||
dns_typepair_t sigpair, dns_typepair_t negpair,
|
||||
dns_slabheader_t **foundp, dns_slabheader_t **foundsigp,
|
||||
bool *matchp) {
|
||||
if (!EXISTS(header) || ANCIENT(header)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (header->type == type) {
|
||||
if (header->typepair == typepair) {
|
||||
*foundp = header;
|
||||
SET_IF_NOT_NULL(matchp, true);
|
||||
if (*foundsigp != NULL) {
|
||||
return true;
|
||||
}
|
||||
} else if (header->type == sigtype) {
|
||||
} else if (header->typepair == sigpair) {
|
||||
*foundsigp = header;
|
||||
SET_IF_NOT_NULL(matchp, true);
|
||||
if (*foundp != NULL) {
|
||||
return true;
|
||||
}
|
||||
} else if (negtype != 0 && (header->type == RDATATYPE_NCACHEANY ||
|
||||
header->type == negtype))
|
||||
} else if (negpair != 0 && (header->typepair == RDATATYPE_NCACHEANY ||
|
||||
header->typepair == negpair))
|
||||
{
|
||||
*foundp = header;
|
||||
*foundsigp = NULL;
|
||||
|
|
@ -1259,11 +1259,11 @@ related_headers(dns_slabheader_t *header, dns_typepair_t type,
|
|||
static bool
|
||||
both_headers(dns_slabheader_t *header, dns_rdatatype_t type,
|
||||
dns_slabheader_t **foundp, dns_slabheader_t **foundsigp) {
|
||||
dns_typepair_t matchtype = DNS_TYPEPAIR_VALUE(type, 0);
|
||||
dns_typepair_t sigmatchtype = DNS_SIGTYPE(type);
|
||||
dns_typepair_t typepair = DNS_TYPEPAIR_VALUE(type, 0);
|
||||
dns_typepair_t sigpair = DNS_SIGTYPE(type);
|
||||
|
||||
return related_headers(header, matchtype, sigmatchtype, 0, foundp,
|
||||
foundsigp, NULL);
|
||||
return related_headers(header, typepair, sigpair, 0, foundp, foundsigp,
|
||||
NULL);
|
||||
}
|
||||
|
||||
static isc_result_t
|
||||
|
|
@ -1463,7 +1463,7 @@ find_coveringnsec(qpc_search_t *search, const dns_name_t *name,
|
|||
continue;
|
||||
}
|
||||
|
||||
if (DNS_TYPEPAIR_TYPE(header->type) == 0) {
|
||||
if (DNS_TYPEPAIR_TYPE(header->typepair) == 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
|
@ -1543,7 +1543,7 @@ qpcache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
|
|||
dns_slabheader_t *found = NULL, *nsheader = NULL;
|
||||
dns_slabheader_t *foundsig = NULL, *nssig = NULL, *cnamesig = NULL;
|
||||
dns_slabheader_t *nsecheader = NULL, *nsecsig = NULL;
|
||||
dns_typepair_t sigtype, negtype;
|
||||
dns_typepair_t typepair, sigpair, negpair;
|
||||
|
||||
qpc_search_t search;
|
||||
qpc_search_init(&search, (qpcache_t *)db, options, __now);
|
||||
|
|
@ -1601,7 +1601,7 @@ qpcache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
|
|||
*/
|
||||
if ((search.options & DNS_DBFIND_COVERINGNSEC) != 0 &&
|
||||
(search.zonecut_header == NULL ||
|
||||
search.zonecut_header->type != dns_rdatatype_dname))
|
||||
search.zonecut_header->typepair != dns_rdatatype_dname))
|
||||
{
|
||||
result = find_coveringnsec(
|
||||
&search, name, nodep, foundname, rdataset,
|
||||
|
|
@ -1650,8 +1650,9 @@ qpcache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
|
|||
*/
|
||||
found = NULL;
|
||||
foundsig = NULL;
|
||||
sigtype = DNS_SIGTYPE(type);
|
||||
negtype = DNS_TYPEPAIR_VALUE(0, type);
|
||||
typepair = DNS_TYPEPAIR_VALUE(type, 0);
|
||||
sigpair = DNS_SIGTYPE(type);
|
||||
negpair = DNS_TYPEPAIR_VALUE(0, type);
|
||||
nsheader = NULL;
|
||||
nsecheader = NULL;
|
||||
nssig = NULL;
|
||||
|
|
@ -1686,7 +1687,7 @@ qpcache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
|
|||
}
|
||||
|
||||
bool match = false;
|
||||
if (related_headers(header, type, sigtype, negtype, &found,
|
||||
if (related_headers(header, typepair, sigpair, negpair, &found,
|
||||
&foundsig, &match) &&
|
||||
!MISSING_ANSWER(found, options))
|
||||
{
|
||||
|
|
@ -1705,7 +1706,7 @@ qpcache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
|
|||
continue;
|
||||
}
|
||||
|
||||
switch (header->type) {
|
||||
switch (header->typepair) {
|
||||
case dns_rdatatype_cname:
|
||||
if (!cname_ok) {
|
||||
break;
|
||||
|
|
@ -1717,7 +1718,7 @@ qpcache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
|
|||
foundsig = cnamesig;
|
||||
} else {
|
||||
/* Look for CNAME signature instead */
|
||||
sigtype = DNS_SIGTYPE(dns_rdatatype_cname);
|
||||
sigpair = DNS_SIGTYPE(dns_rdatatype_cname);
|
||||
foundsig = NULL;
|
||||
}
|
||||
break;
|
||||
|
|
@ -1745,8 +1746,8 @@ qpcache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
|
|||
break;
|
||||
|
||||
default:
|
||||
if (type == dns_rdatatype_any &&
|
||||
DNS_TYPEPAIR_TYPE(header->type) != 0)
|
||||
if (typepair == dns_rdatatype_any &&
|
||||
DNS_TYPEPAIR_TYPE(header->typepair) != 0)
|
||||
{
|
||||
/* QTYPE==ANY, so any anwers will do */
|
||||
found = header;
|
||||
|
|
@ -1854,8 +1855,9 @@ qpcache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
|
|||
} else {
|
||||
result = DNS_R_NCACHENXRRSET;
|
||||
}
|
||||
} else if (type != found->type && type != dns_rdatatype_any &&
|
||||
found->type == dns_rdatatype_cname)
|
||||
} else if (typepair != found->typepair &&
|
||||
typepair != dns_rdatatype_any &&
|
||||
found->typepair == dns_rdatatype_cname)
|
||||
{
|
||||
/*
|
||||
* We weren't doing an ANY query and we found a CNAME instead
|
||||
|
|
@ -1870,7 +1872,7 @@ qpcache_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
|
|||
result = ISC_R_SUCCESS;
|
||||
}
|
||||
|
||||
if (type != dns_rdatatype_any || result == DNS_R_NCACHENXDOMAIN ||
|
||||
if (typepair != dns_rdatatype_any || result == DNS_R_NCACHENXDOMAIN ||
|
||||
result == DNS_R_NCACHENXRRSET)
|
||||
{
|
||||
bindrdatasets(search.qpdb, node, found, foundsig, search.now,
|
||||
|
|
@ -1919,8 +1921,8 @@ seek_ns_headers(qpc_search_t *search, qpcnode_t *node, dns_dbnode_t **nodep,
|
|||
|
||||
for (header = node->data; header != NULL; header = header_next) {
|
||||
header_next = header->next;
|
||||
bool ns = (header->type == dns_rdatatype_ns ||
|
||||
header->type == DNS_SIGTYPE(dns_rdatatype_ns));
|
||||
bool ns = (header->typepair == dns_rdatatype_ns ||
|
||||
header->typepair == DNS_SIGTYPE(dns_rdatatype_ns));
|
||||
if (check_stale_header(header, search, &header_prev)) {
|
||||
if (ns) {
|
||||
/*
|
||||
|
|
@ -2063,7 +2065,7 @@ qpcache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
|
|||
dns_slabheader_t *header = NULL;
|
||||
dns_slabheader_t *header_prev = NULL, *header_next = NULL;
|
||||
dns_slabheader_t *found = NULL, *foundsig = NULL;
|
||||
dns_typepair_t matchtype, sigmatchtype, negtype;
|
||||
dns_typepair_t typepair, sigpair, negpair;
|
||||
isc_result_t result;
|
||||
isc_rwlock_t *nlock = NULL;
|
||||
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
|
||||
|
|
@ -2081,9 +2083,9 @@ qpcache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
|
|||
nlock = &qpdb->buckets[qpnode->locknum].lock;
|
||||
NODE_RDLOCK(nlock, &nlocktype);
|
||||
|
||||
matchtype = DNS_TYPEPAIR_VALUE(type, covers);
|
||||
negtype = DNS_TYPEPAIR_VALUE(0, type);
|
||||
sigmatchtype = (covers == 0) ? DNS_SIGTYPE(type) : 0;
|
||||
typepair = DNS_TYPEPAIR_VALUE(type, covers);
|
||||
negpair = DNS_TYPEPAIR_VALUE(0, type);
|
||||
sigpair = (covers == 0) ? DNS_SIGTYPE(type) : 0;
|
||||
|
||||
for (header = qpnode->data; header != NULL; header = header_next) {
|
||||
header_next = header->next;
|
||||
|
|
@ -2092,8 +2094,8 @@ qpcache_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
|
|||
continue;
|
||||
}
|
||||
|
||||
if (related_headers(header, matchtype, sigmatchtype, negtype,
|
||||
&found, &foundsig, NULL))
|
||||
if (related_headers(header, typepair, sigpair, negpair, &found,
|
||||
&foundsig, NULL))
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
|
@ -2482,11 +2484,13 @@ overmaxtype(qpcache_t *qpdb, uint32_t ntypes) {
|
|||
|
||||
static bool
|
||||
prio_header(dns_slabheader_t *header) {
|
||||
if (NEGATIVE(header) && prio_type(DNS_TYPEPAIR_COVERS(header->type))) {
|
||||
if (NEGATIVE(header) &&
|
||||
prio_type(DNS_TYPEPAIR_COVERS(header->typepair)))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
return prio_type(header->type);
|
||||
return prio_type(header->typepair);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -2543,7 +2547,7 @@ add(qpcache_t *qpdb, qpcnode_t *qpnode,
|
|||
dns_slabheader_t *topheader = NULL, *topheader_prev = NULL;
|
||||
dns_slabheader_t *header = NULL, *sigheader = NULL;
|
||||
dns_slabheader_t *prioheader = NULL, *expireheader = NULL;
|
||||
dns_typepair_t negtype = 0;
|
||||
dns_typepair_t negpair = 0;
|
||||
dns_trust_t trust;
|
||||
uint32_t ntypes = 0;
|
||||
|
||||
|
|
@ -2554,9 +2558,10 @@ add(qpcache_t *qpdb, qpcnode_t *qpnode,
|
|||
}
|
||||
|
||||
if (EXISTS(newheader)) {
|
||||
dns_rdatatype_t rdtype = DNS_TYPEPAIR_TYPE(newheader->type);
|
||||
dns_rdatatype_t covers = DNS_TYPEPAIR_COVERS(newheader->type);
|
||||
dns_typepair_t sigtype = DNS_SIGTYPE(covers);
|
||||
dns_rdatatype_t rdtype = DNS_TYPEPAIR_TYPE(newheader->typepair);
|
||||
dns_rdatatype_t covers =
|
||||
DNS_TYPEPAIR_COVERS(newheader->typepair);
|
||||
dns_typepair_t sigpair = DNS_SIGTYPE(covers);
|
||||
if (NEGATIVE(newheader)) {
|
||||
/*
|
||||
* We're adding a negative cache entry.
|
||||
|
|
@ -2586,12 +2591,12 @@ add(qpcache_t *qpdb, qpcnode_t *qpnode,
|
|||
for (topheader = qpnode->data; topheader != NULL;
|
||||
topheader = topheader->next)
|
||||
{
|
||||
if (topheader->type == sigtype) {
|
||||
if (topheader->typepair == sigpair) {
|
||||
sigheader = topheader;
|
||||
break;
|
||||
}
|
||||
}
|
||||
negtype = DNS_TYPEPAIR_VALUE(covers, 0);
|
||||
negpair = DNS_TYPEPAIR_VALUE(covers, 0);
|
||||
} else {
|
||||
/*
|
||||
* We're adding something that isn't a
|
||||
|
|
@ -2604,9 +2609,10 @@ add(qpcache_t *qpdb, qpcnode_t *qpnode,
|
|||
for (topheader = qpnode->data; topheader != NULL;
|
||||
topheader = topheader->next)
|
||||
{
|
||||
if ((topheader->type == RDATATYPE_NCACHEANY) ||
|
||||
(newheader->type == sigtype &&
|
||||
topheader->type ==
|
||||
if ((topheader->typepair ==
|
||||
RDATATYPE_NCACHEANY) ||
|
||||
(newheader->typepair == sigpair &&
|
||||
topheader->typepair ==
|
||||
DNS_TYPEPAIR_VALUE(0, covers)))
|
||||
{
|
||||
break;
|
||||
|
|
@ -2642,7 +2648,7 @@ add(qpcache_t *qpdb, qpcnode_t *qpnode,
|
|||
topheader = NULL;
|
||||
goto find_header;
|
||||
}
|
||||
negtype = DNS_TYPEPAIR_VALUE(0, rdtype);
|
||||
negpair = DNS_TYPEPAIR_VALUE(0, rdtype);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -2657,8 +2663,8 @@ add(qpcache_t *qpdb, qpcnode_t *qpnode,
|
|||
prioheader = topheader;
|
||||
}
|
||||
|
||||
if (topheader->type == newheader->type ||
|
||||
topheader->type == negtype)
|
||||
if (topheader->typepair == newheader->typepair ||
|
||||
topheader->typepair == negpair)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
|
@ -2706,12 +2712,12 @@ find_header:
|
|||
* special to be done w.r.t stale data; it gets replaced
|
||||
* normally further down.
|
||||
*/
|
||||
if (ACTIVE(header, now) && header->type == dns_rdatatype_ns &&
|
||||
EXISTS(header) && EXISTS(newheader) &&
|
||||
header->trust >= newheader->trust &&
|
||||
if (ACTIVE(header, now) &&
|
||||
header->typepair == dns_rdatatype_ns && EXISTS(header) &&
|
||||
EXISTS(newheader) && header->trust >= newheader->trust &&
|
||||
dns_rdataslab_equalx(header, newheader,
|
||||
qpdb->common.rdclass,
|
||||
(dns_rdatatype_t)header->type))
|
||||
DNS_TYPEPAIR_TYPE(header->typepair)))
|
||||
{
|
||||
/*
|
||||
* Honour the new ttl if it is less than the
|
||||
|
|
@ -2749,9 +2755,9 @@ find_header:
|
|||
* to be no more than the current NS RRset's TTL. This
|
||||
* ensures the delegations that are withdrawn are honoured.
|
||||
*/
|
||||
if (ACTIVE(header, now) && header->type == dns_rdatatype_ns &&
|
||||
EXISTS(header) && EXISTS(newheader) &&
|
||||
header->trust <= newheader->trust)
|
||||
if (ACTIVE(header, now) &&
|
||||
header->typepair == dns_rdatatype_ns && EXISTS(header) &&
|
||||
EXISTS(newheader) && header->trust <= newheader->trust)
|
||||
{
|
||||
if (newheader->expire > header->expire) {
|
||||
newheader->expire = header->expire;
|
||||
|
|
@ -2759,10 +2765,10 @@ find_header:
|
|||
}
|
||||
if (ACTIVE(header, now) &&
|
||||
(options & DNS_DBADD_PREFETCH) == 0 &&
|
||||
(header->type == dns_rdatatype_a ||
|
||||
header->type == dns_rdatatype_aaaa ||
|
||||
header->type == dns_rdatatype_ds ||
|
||||
header->type == DNS_SIGTYPE(dns_rdatatype_ds)) &&
|
||||
(header->typepair == dns_rdatatype_a ||
|
||||
header->typepair == dns_rdatatype_aaaa ||
|
||||
header->typepair == dns_rdatatype_ds ||
|
||||
header->typepair == DNS_SIGTYPE(dns_rdatatype_ds)) &&
|
||||
EXISTS(header) && EXISTS(newheader) &&
|
||||
header->trust >= newheader->trust &&
|
||||
dns_rdataslab_equal(header, newheader))
|
||||
|
|
@ -3068,7 +3074,7 @@ qpcache_addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
|
|||
|
||||
if (qpdb->rrsetstats != NULL) {
|
||||
DNS_SLABHEADER_SETATTR(newheader, DNS_SLABHEADERATTR_STATCOUNT);
|
||||
update_rrsetstats(qpdb->rrsetstats, newheader->type,
|
||||
update_rrsetstats(qpdb->rrsetstats, newheader->typepair,
|
||||
atomic_load_acquire(&newheader->attributes),
|
||||
true);
|
||||
}
|
||||
|
|
@ -3132,7 +3138,7 @@ qpcache_deleterdataset(dns_db_t *db, dns_dbnode_t *node,
|
|||
}
|
||||
|
||||
newheader = dns_slabheader_new(db, node);
|
||||
newheader->type = DNS_TYPEPAIR_VALUE(type, covers);
|
||||
newheader->typepair = DNS_TYPEPAIR_VALUE(type, covers);
|
||||
setttl(newheader, 0);
|
||||
atomic_init(&newheader->attributes, DNS_SLABHEADERATTR_NONEXISTENT);
|
||||
|
||||
|
|
@ -3742,7 +3748,7 @@ qpcnode_deletedata(dns_dbnode_t *node ISC_ATTR_UNUSED, void *data) {
|
|||
isc_heap_delete(header->heap, header->heap_index);
|
||||
}
|
||||
|
||||
update_rrsetstats(qpdb->rrsetstats, header->type,
|
||||
update_rrsetstats(qpdb->rrsetstats, header->typepair,
|
||||
atomic_load_acquire(&header->attributes), false);
|
||||
|
||||
if (ISC_LINK_LINKED(header, link)) {
|
||||
|
|
|
|||
129
lib/dns/qpzone.c
129
lib/dns/qpzone.c
|
|
@ -445,7 +445,7 @@ resign_sooner(void *v1, void *v2) {
|
|||
return h1->resign < h2->resign ||
|
||||
(h1->resign == h2->resign && h1->resign_lsb < h2->resign_lsb) ||
|
||||
(h1->resign == h2->resign && h1->resign_lsb == h2->resign_lsb &&
|
||||
h2->type == DNS_SIGTYPE(dns_rdatatype_soa));
|
||||
h2->typepair == DNS_SIGTYPE(dns_rdatatype_soa));
|
||||
}
|
||||
|
||||
/*%
|
||||
|
|
@ -1059,8 +1059,8 @@ bindrdataset(qpzonedb_t *qpdb, qpznode_t *node, dns_slabheader_t *header,
|
|||
|
||||
rdataset->methods = &dns_rdataslab_rdatasetmethods;
|
||||
rdataset->rdclass = qpdb->common.rdclass;
|
||||
rdataset->type = DNS_TYPEPAIR_TYPE(header->type);
|
||||
rdataset->covers = DNS_TYPEPAIR_COVERS(header->type);
|
||||
rdataset->type = DNS_TYPEPAIR_TYPE(header->typepair);
|
||||
rdataset->covers = DNS_TYPEPAIR_COVERS(header->typepair);
|
||||
rdataset->ttl = header->ttl;
|
||||
rdataset->trust = header->trust;
|
||||
|
||||
|
|
@ -1133,7 +1133,7 @@ setnsec3parameters(dns_db_t *db, qpz_version_t *version) {
|
|||
} while (header != NULL);
|
||||
|
||||
if (header != NULL &&
|
||||
(header->type == dns_rdatatype_nsec3param))
|
||||
(header->typepair == dns_rdatatype_nsec3param))
|
||||
{
|
||||
/*
|
||||
* Find an NSEC3PARAM with a supported algorithm.
|
||||
|
|
@ -1623,7 +1623,7 @@ qpzone_findrdataset(dns_db_t *db, dns_dbnode_t *dbnode,
|
|||
uint32_t serial;
|
||||
qpz_version_t *version = (qpz_version_t *)dbversion;
|
||||
bool close_version = false;
|
||||
dns_typepair_t matchtype, sigmatchtype;
|
||||
dns_typepair_t typepair, sigpair;
|
||||
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
|
||||
isc_rwlock_t *nlock = NULL;
|
||||
|
||||
|
|
@ -1640,11 +1640,11 @@ qpzone_findrdataset(dns_db_t *db, dns_dbnode_t *dbnode,
|
|||
nlock = qpzone_get_lock(node);
|
||||
NODE_RDLOCK(nlock, &nlocktype);
|
||||
|
||||
matchtype = DNS_TYPEPAIR_VALUE(type, covers);
|
||||
typepair = DNS_TYPEPAIR_VALUE(type, covers);
|
||||
if (covers == 0) {
|
||||
sigmatchtype = DNS_SIGTYPE(type);
|
||||
sigpair = DNS_SIGTYPE(type);
|
||||
} else {
|
||||
sigmatchtype = 0;
|
||||
sigpair = 0;
|
||||
}
|
||||
|
||||
for (header = node->data; header != NULL; header = header_next) {
|
||||
|
|
@ -1664,12 +1664,12 @@ qpzone_findrdataset(dns_db_t *db, dns_dbnode_t *dbnode,
|
|||
* We have an active, extant rdataset. If it's a
|
||||
* type we're looking for, remember it.
|
||||
*/
|
||||
if (header->type == matchtype) {
|
||||
if (header->typepair == typepair) {
|
||||
found = header;
|
||||
if (foundsig != NULL) {
|
||||
break;
|
||||
}
|
||||
} else if (header->type == sigmatchtype) {
|
||||
} else if (header->typepair == sigpair) {
|
||||
foundsig = header;
|
||||
if (found != NULL) {
|
||||
break;
|
||||
|
|
@ -1700,9 +1700,9 @@ qpzone_findrdataset(dns_db_t *db, dns_dbnode_t *dbnode,
|
|||
}
|
||||
|
||||
static bool
|
||||
delegating_type(qpzonedb_t *qpdb, qpznode_t *node, dns_typepair_t type) {
|
||||
return type == dns_rdatatype_dname ||
|
||||
(type == dns_rdatatype_ns &&
|
||||
delegating_type(qpzonedb_t *qpdb, qpznode_t *node, dns_typepair_t typepair) {
|
||||
return typepair == dns_rdatatype_dname ||
|
||||
(typepair == dns_rdatatype_ns &&
|
||||
(node != qpdb->origin || IS_STUB(qpdb)));
|
||||
}
|
||||
|
||||
|
|
@ -1778,7 +1778,7 @@ cname_and_other(qpznode_t *node, uint32_t serial) {
|
|||
for (header = node->data; header != NULL; header = header_next) {
|
||||
header_next = header->next;
|
||||
|
||||
rdtype = DNS_TYPEPAIR_TYPE(header->type);
|
||||
rdtype = DNS_TYPEPAIR_TYPE(header->typepair);
|
||||
if (rdtype == dns_rdatatype_cname) {
|
||||
do {
|
||||
if (header->serial <= serial && !IGNORE(header))
|
||||
|
|
@ -1809,7 +1809,7 @@ cname_and_other(qpznode_t *node, uint32_t serial) {
|
|||
header = header->down;
|
||||
} while (header != NULL);
|
||||
if (header != NULL) {
|
||||
if (!prio_type(header->type)) {
|
||||
if (!prio_type(header->typepair)) {
|
||||
/*
|
||||
* CNAME is in the priority list, so if
|
||||
* we are done with priority types, we
|
||||
|
|
@ -1906,10 +1906,10 @@ add(qpzonedb_t *qpdb, qpznode_t *node, const dns_name_t *nodename,
|
|||
topheader = topheader->next)
|
||||
{
|
||||
++ntypes;
|
||||
if (prio_type(topheader->type)) {
|
||||
if (prio_type(topheader->typepair)) {
|
||||
prioheader = topheader;
|
||||
}
|
||||
if (topheader->type == newheader->type) {
|
||||
if (topheader->typepair == newheader->typepair) {
|
||||
break;
|
||||
}
|
||||
topheader_prev = topheader;
|
||||
|
|
@ -1950,8 +1950,8 @@ add(qpzonedb_t *qpdb, qpznode_t *node, const dns_name_t *nodename,
|
|||
result = dns_rdataslab_merge(
|
||||
header, newheader, qpdb->common.mctx,
|
||||
qpdb->common.rdclass,
|
||||
(dns_rdatatype_t)header->type, flags,
|
||||
qpdb->maxrrperset, &merged);
|
||||
DNS_TYPEPAIR_TYPE(header->typepair),
|
||||
flags, qpdb->maxrrperset, &merged);
|
||||
}
|
||||
if (result == ISC_R_SUCCESS) {
|
||||
/*
|
||||
|
|
@ -1979,7 +1979,8 @@ add(qpzonedb_t *qpdb, qpznode_t *node, const dns_name_t *nodename,
|
|||
if (result == DNS_R_TOOMANYRECORDS) {
|
||||
dns__db_logtoomanyrecords(
|
||||
(dns_db_t *)qpdb, nodename,
|
||||
(dns_rdatatype_t)header->type,
|
||||
DNS_TYPEPAIR_TYPE(
|
||||
header->typepair),
|
||||
"updating", qpdb->maxrrperset);
|
||||
}
|
||||
dns_slabheader_destroy(&newheader);
|
||||
|
|
@ -2085,7 +2086,7 @@ add(qpzonedb_t *qpdb, qpznode_t *node, const dns_name_t *nodename,
|
|||
|
||||
INSIST(newheader->down == NULL);
|
||||
|
||||
if (prio_type(newheader->type)) {
|
||||
if (prio_type(newheader->typepair)) {
|
||||
/* This is a priority type, prepend it */
|
||||
newheader->next = node->data;
|
||||
node->data = newheader;
|
||||
|
|
@ -2522,7 +2523,7 @@ again:
|
|||
? (header->resign << 1) | header->resign_lsb
|
||||
: 0;
|
||||
dns_name_copy(&HEADERNODE(header)->name, foundname);
|
||||
*typepair = header->type;
|
||||
*typepair = header->typepair;
|
||||
result = ISC_R_SUCCESS;
|
||||
}
|
||||
UNLOCK(&qpdb->heap->lock);
|
||||
|
|
@ -2627,7 +2628,7 @@ matchparams(dns_slabheader_t *header, qpz_search_t *search) {
|
|||
isc_region_t region;
|
||||
isc_result_t result;
|
||||
|
||||
REQUIRE(header->type == dns_rdatatype_nsec3);
|
||||
REQUIRE(header->typepair == dns_rdatatype_nsec3);
|
||||
|
||||
raw = (unsigned char *)header + sizeof(*header);
|
||||
count = raw[0] * 256 + raw[1]; /* count */
|
||||
|
|
@ -2661,7 +2662,7 @@ qpzone_setup_delegation(qpz_search_t *search, dns_dbnode_t **nodep,
|
|||
dns_name_t *foundname, dns_rdataset_t *rdataset,
|
||||
dns_rdataset_t *sigrdataset DNS__DB_FLARG) {
|
||||
dns_name_t *zcname = NULL;
|
||||
dns_typepair_t type;
|
||||
dns_typepair_t typepair;
|
||||
qpznode_t *node = NULL;
|
||||
|
||||
REQUIRE(search != NULL);
|
||||
|
|
@ -2673,7 +2674,7 @@ qpzone_setup_delegation(qpz_search_t *search, dns_dbnode_t **nodep,
|
|||
*/
|
||||
|
||||
node = search->zonecut;
|
||||
type = search->zonecut_header->type;
|
||||
typepair = search->zonecut_header->typepair;
|
||||
|
||||
/*
|
||||
* If we have to set foundname, we do it before anything else.
|
||||
|
|
@ -2709,7 +2710,7 @@ qpzone_setup_delegation(qpz_search_t *search, dns_dbnode_t **nodep,
|
|||
NODE_UNLOCK(nlock, &nlocktype);
|
||||
}
|
||||
|
||||
if (type == dns_rdatatype_dname) {
|
||||
if (typepair == dns_rdatatype_dname) {
|
||||
return DNS_R_DNAME;
|
||||
}
|
||||
return DNS_R_DELEGATION;
|
||||
|
|
@ -3103,18 +3104,14 @@ find_closest_nsec(qpz_search_t *search, dns_dbnode_t **nodep,
|
|||
isc_result_t result;
|
||||
dns_fixedname_t fname;
|
||||
dns_name_t *name = dns_fixedname_initname(&fname);
|
||||
dns_rdatatype_t type = dns_rdatatype_nsec;
|
||||
dns_typepair_t sigtype = DNS_SIGTYPE(dns_rdatatype_nsec);
|
||||
bool wraps = false;
|
||||
dns_rdatatype_t matchtype = nsec3 ? dns_rdatatype_nsec3
|
||||
: dns_rdatatype_nsec;
|
||||
dns_typepair_t typepair = DNS_TYPEPAIR_VALUE(matchtype, 0);
|
||||
dns_typepair_t sigpair = DNS_SIGTYPE(matchtype);
|
||||
bool wraps = nsec3;
|
||||
bool first = true;
|
||||
bool need_sig = secure;
|
||||
|
||||
if (nsec3) {
|
||||
type = dns_rdatatype_nsec3;
|
||||
sigtype = DNS_SIGTYPE(dns_rdatatype_nsec3);
|
||||
wraps = true;
|
||||
}
|
||||
|
||||
/*
|
||||
* Use the auxiliary tree only starting with the second node in the
|
||||
* hope that the original node will be right much of the time.
|
||||
|
|
@ -3154,12 +3151,12 @@ again:
|
|||
* active rdataset at this node.
|
||||
*/
|
||||
empty_node = false;
|
||||
if (header->type == type) {
|
||||
if (header->typepair == typepair) {
|
||||
found = header;
|
||||
if (foundsig != NULL) {
|
||||
break;
|
||||
}
|
||||
} else if (header->type == sigtype) {
|
||||
} else if (header->typepair == sigpair) {
|
||||
foundsig = header;
|
||||
if (found != NULL) {
|
||||
break;
|
||||
|
|
@ -3169,13 +3166,13 @@ again:
|
|||
}
|
||||
if (!empty_node) {
|
||||
if (found != NULL && search->version->havensec3 &&
|
||||
found->type == dns_rdatatype_nsec3 &&
|
||||
found->typepair == dns_rdatatype_nsec3 &&
|
||||
!matchparams(found, search))
|
||||
{
|
||||
empty_node = true;
|
||||
found = NULL;
|
||||
foundsig = NULL;
|
||||
result = previous_closest_nsec(type, search,
|
||||
result = previous_closest_nsec(typepair, search,
|
||||
name, &prevnode,
|
||||
NULL, NULL);
|
||||
} else if (found != NULL &&
|
||||
|
|
@ -3214,7 +3211,7 @@ again:
|
|||
*/
|
||||
empty_node = true;
|
||||
result = previous_closest_nsec(
|
||||
type, search, name, &prevnode,
|
||||
typepair, search, name, &prevnode,
|
||||
&nseciter, &first);
|
||||
} else {
|
||||
/*
|
||||
|
|
@ -3229,7 +3226,7 @@ again:
|
|||
* This node isn't active. We've got to keep
|
||||
* looking.
|
||||
*/
|
||||
result = previous_closest_nsec(type, search, name,
|
||||
result = previous_closest_nsec(typepair, search, name,
|
||||
&prevnode, &nseciter,
|
||||
&first);
|
||||
}
|
||||
|
|
@ -3277,9 +3274,9 @@ qpzone_check_zonecut(qpznode_t *node, void *arg DNS__DB_FLARG) {
|
|||
*/
|
||||
for (header = node->data; header != NULL; header = header_next) {
|
||||
header_next = header->next;
|
||||
if (header->type == dns_rdatatype_ns ||
|
||||
header->type == dns_rdatatype_dname ||
|
||||
header->type == DNS_SIGTYPE(dns_rdatatype_dname))
|
||||
if (header->typepair == dns_rdatatype_ns ||
|
||||
header->typepair == dns_rdatatype_dname ||
|
||||
header->typepair == DNS_SIGTYPE(dns_rdatatype_dname))
|
||||
{
|
||||
do {
|
||||
if (header->serial <= search->serial &&
|
||||
|
|
@ -3294,9 +3291,9 @@ qpzone_check_zonecut(qpznode_t *node, void *arg DNS__DB_FLARG) {
|
|||
}
|
||||
} while (header != NULL);
|
||||
if (header != NULL) {
|
||||
if (header->type == dns_rdatatype_dname) {
|
||||
if (header->typepair == dns_rdatatype_dname) {
|
||||
dname_header = header;
|
||||
} else if (header->type ==
|
||||
} else if (header->typepair ==
|
||||
DNS_SIGTYPE(dns_rdatatype_dname))
|
||||
{
|
||||
sigdname_header = header;
|
||||
|
|
@ -3429,7 +3426,7 @@ qpzone_find(dns_db_t *db, const dns_name_t *name, dns_dbversion_t *version,
|
|||
dns_slabheader_t *header = NULL, *header_next = NULL;
|
||||
dns_slabheader_t *found = NULL, *nsecheader = NULL;
|
||||
dns_slabheader_t *foundsig = NULL, *cnamesig = NULL, *nsecsig = NULL;
|
||||
dns_typepair_t sigtype;
|
||||
dns_typepair_t sigpair;
|
||||
bool active;
|
||||
isc_rwlock_t *nlock = NULL;
|
||||
isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
|
||||
|
|
@ -3602,7 +3599,7 @@ found:
|
|||
* We now go looking for rdata...
|
||||
*/
|
||||
|
||||
sigtype = DNS_SIGTYPE(type);
|
||||
sigpair = DNS_SIGTYPE(type);
|
||||
empty_node = true;
|
||||
for (header = node->data; header != NULL; header = header_next) {
|
||||
header_next = header->next;
|
||||
|
|
@ -3630,7 +3627,9 @@ found:
|
|||
/*
|
||||
* Do special zone cut handling, if requested.
|
||||
*/
|
||||
if (maybe_zonecut && header->type == dns_rdatatype_ns) {
|
||||
if (maybe_zonecut &&
|
||||
header->typepair == dns_rdatatype_ns)
|
||||
{
|
||||
/*
|
||||
* We increment the reference count on node to
|
||||
* ensure that search->zonecut_header will
|
||||
|
|
@ -3671,7 +3670,7 @@ found:
|
|||
* If the NSEC3 record doesn't match the chain
|
||||
* we are using behave as if it isn't here.
|
||||
*/
|
||||
if (header->type == dns_rdatatype_nsec3 &&
|
||||
if (header->typepair == dns_rdatatype_nsec3 &&
|
||||
!matchparams(header, &search))
|
||||
{
|
||||
NODE_UNLOCK(nlock, &nlocktype);
|
||||
|
|
@ -3681,14 +3680,16 @@ found:
|
|||
* If we found a type we were looking for,
|
||||
* remember it.
|
||||
*/
|
||||
if (header->type == type || type == dns_rdatatype_any ||
|
||||
(header->type == dns_rdatatype_cname && cname_ok))
|
||||
if (header->typepair == type ||
|
||||
type == dns_rdatatype_any ||
|
||||
(header->typepair == dns_rdatatype_cname &&
|
||||
cname_ok))
|
||||
{
|
||||
/*
|
||||
* We've found the answer!
|
||||
*/
|
||||
found = header;
|
||||
if (header->type == dns_rdatatype_cname &&
|
||||
if (header->typepair == dns_rdatatype_cname &&
|
||||
cname_ok)
|
||||
{
|
||||
/*
|
||||
|
|
@ -3702,7 +3703,7 @@ found:
|
|||
if (cnamesig != NULL) {
|
||||
foundsig = cnamesig;
|
||||
} else {
|
||||
sigtype = DNS_SIGTYPE(
|
||||
sigpair = DNS_SIGTYPE(
|
||||
dns_rdatatype_cname);
|
||||
}
|
||||
}
|
||||
|
|
@ -3712,7 +3713,7 @@ found:
|
|||
if (!maybe_zonecut && foundsig != NULL) {
|
||||
break;
|
||||
}
|
||||
} else if (header->type == sigtype) {
|
||||
} else if (header->typepair == sigpair) {
|
||||
/*
|
||||
* We've found the RRSIG rdataset for our
|
||||
* target type. Remember it.
|
||||
|
|
@ -3724,7 +3725,7 @@ found:
|
|||
if (!maybe_zonecut && found != NULL) {
|
||||
break;
|
||||
}
|
||||
} else if (header->type == dns_rdatatype_nsec &&
|
||||
} else if (header->typepair == dns_rdatatype_nsec &&
|
||||
!search.version->havensec3)
|
||||
{
|
||||
/*
|
||||
|
|
@ -3733,7 +3734,7 @@ found:
|
|||
* we might need it later.
|
||||
*/
|
||||
nsecheader = header;
|
||||
} else if (header->type ==
|
||||
} else if (header->typepair ==
|
||||
DNS_SIGTYPE(dns_rdatatype_nsec) &&
|
||||
!search.version->havensec3)
|
||||
{
|
||||
|
|
@ -3743,7 +3744,7 @@ found:
|
|||
*/
|
||||
nsecsig = header;
|
||||
} else if (cname_ok &&
|
||||
header->type ==
|
||||
header->typepair ==
|
||||
DNS_SIGTYPE(dns_rdatatype_cname))
|
||||
{
|
||||
/*
|
||||
|
|
@ -3840,8 +3841,8 @@ found:
|
|||
/*
|
||||
* We found what we were looking for, or we found a CNAME.
|
||||
*/
|
||||
if (type != found->type && type != dns_rdatatype_any &&
|
||||
found->type == dns_rdatatype_cname)
|
||||
if (type != found->typepair && type != dns_rdatatype_any &&
|
||||
found->typepair == dns_rdatatype_cname)
|
||||
{
|
||||
/*
|
||||
* We weren't doing an ANY query and we found a CNAME instead
|
||||
|
|
@ -4975,7 +4976,7 @@ qpzone_subtractrdataset(dns_db_t *db, dns_dbnode_t *dbnode,
|
|||
for (topheader = node->data; topheader != NULL;
|
||||
topheader = topheader->next)
|
||||
{
|
||||
if (topheader->type == newheader->type) {
|
||||
if (topheader->typepair == newheader->typepair) {
|
||||
break;
|
||||
}
|
||||
topheader_prev = topheader;
|
||||
|
|
@ -5003,7 +5004,7 @@ qpzone_subtractrdataset(dns_db_t *db, dns_dbnode_t *dbnode,
|
|||
result = dns_rdataslab_subtract(
|
||||
header, newheader, qpdb->common.mctx,
|
||||
qpdb->common.rdclass,
|
||||
(dns_rdatatype_t)header->type, flags,
|
||||
DNS_TYPEPAIR_TYPE(header->typepair), flags,
|
||||
&subresult);
|
||||
}
|
||||
if (result == ISC_R_SUCCESS) {
|
||||
|
|
@ -5040,7 +5041,7 @@ qpzone_subtractrdataset(dns_db_t *db, dns_dbnode_t *dbnode,
|
|||
newheader = dns_slabheader_new((dns_db_t *)qpdb,
|
||||
(dns_dbnode_t *)node);
|
||||
newheader->ttl = 0;
|
||||
newheader->type = topheader->type;
|
||||
newheader->typepair = topheader->typepair;
|
||||
atomic_init(&newheader->attributes,
|
||||
DNS_SLABHEADERATTR_NONEXISTENT);
|
||||
newheader->serial = version->serial;
|
||||
|
|
@ -5122,7 +5123,7 @@ qpzone_deleterdataset(dns_db_t *db, dns_dbnode_t *dbnode,
|
|||
}
|
||||
|
||||
newheader = dns_slabheader_new(db, (dns_dbnode_t *)node);
|
||||
newheader->type = DNS_TYPEPAIR_VALUE(type, covers);
|
||||
newheader->typepair = DNS_TYPEPAIR_VALUE(type, covers);
|
||||
newheader->ttl = 0;
|
||||
atomic_init(&newheader->attributes, DNS_SLABHEADERATTR_NONEXISTENT);
|
||||
newheader->serial = version->serial;
|
||||
|
|
|
|||
|
|
@ -346,8 +346,8 @@ dns_rdataslab_fromrdataset(dns_rdataset_t *rdataset, isc_mem_t *mctx,
|
|||
dns_slabheader_t *new = (dns_slabheader_t *)region->base;
|
||||
|
||||
*new = (dns_slabheader_t){
|
||||
.type = DNS_TYPEPAIR_VALUE(rdataset->type,
|
||||
rdataset->covers),
|
||||
.typepair = DNS_TYPEPAIR_VALUE(rdataset->type,
|
||||
rdataset->covers),
|
||||
.trust = rdataset->trust,
|
||||
.ttl = rdataset->ttl,
|
||||
.link = ISC_LINK_INITIALIZER,
|
||||
|
|
@ -934,24 +934,24 @@ dns_slabheader_freeproof(isc_mem_t *mctx, dns_slabheader_proof_t **proofp) {
|
|||
|
||||
dns_slabheader_t *
|
||||
dns_slabheader_top(dns_slabheader_t *header) {
|
||||
dns_typepair_t type, negtype;
|
||||
dns_typepair_t typepair, negpair;
|
||||
dns_rdatatype_t rdtype, covers;
|
||||
|
||||
type = header->type;
|
||||
rdtype = DNS_TYPEPAIR_TYPE(header->type);
|
||||
typepair = header->typepair;
|
||||
rdtype = DNS_TYPEPAIR_TYPE(header->typepair);
|
||||
if (NEGATIVE(header)) {
|
||||
covers = DNS_TYPEPAIR_COVERS(header->type);
|
||||
negtype = DNS_TYPEPAIR_VALUE(covers, 0);
|
||||
covers = DNS_TYPEPAIR_COVERS(header->typepair);
|
||||
negpair = DNS_TYPEPAIR_VALUE(covers, 0);
|
||||
} else {
|
||||
negtype = DNS_TYPEPAIR_VALUE(0, rdtype);
|
||||
negpair = DNS_TYPEPAIR_VALUE(0, rdtype);
|
||||
}
|
||||
|
||||
/*
|
||||
* Find the start of the header chain for the next type
|
||||
* by walking back up the list.
|
||||
*/
|
||||
while (header->up != NULL &&
|
||||
(header->up->type == type || header->up->type == negtype))
|
||||
while (header->up != NULL && (header->up->typepair == typepair ||
|
||||
header->up->typepair == negpair))
|
||||
{
|
||||
header = header->up;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue