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.

diff --git a/lib/dns/include/dns/rdataslab.h b/lib/dns/include/dns/rdataslab.h
index 921c32da1f5cf93af842b402bfcc24f451b47049..c5e61c3b925d329bafa2ba4462fc5c67104423ac 100644 (file)
--- a/lib/dns/include/dns/rdataslab.h
+++ b/lib/dns/include/dns/rdataslab.h
@@ -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;
        /*%<

diff --git a/lib/dns/qpcache.c b/lib/dns/qpcache.c
index 29f933554657aa48e1a14f6c6b3fa3d96ddb0deb..0f10245aa4c9b9dc7d749334eb9fe67a7112bf62 100644 (file)
--- a/lib/dns/qpcache.c
+++ b/lib/dns/qpcache.c
@@ -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)) {

diff --git a/lib/dns/qpzone.c b/lib/dns/qpzone.c
index 2140a96421581466490c3e333640174f55a41037..8253d21dde5d6b3a6181526255451212700031ca 100644 (file)
--- a/lib/dns/qpzone.c
+++ b/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;

diff --git a/lib/dns/rdataslab.c b/lib/dns/rdataslab.c
index 68f5ea669622e4c191f9593f4bff3f6741389926..9f862422b937f66843ded3c5f027125dbedec2ba 100644 (file)
--- a/lib/dns/rdataslab.c
+++ b/lib/dns/rdataslab.c
@@ -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;
        }