use new dns_rdatatype classification functions

modify code to use dns_rdatatype_ismulti(), dns_rdatatype_issig(),
dns_rdatatype_isaddr(), and dns_rdatatype_isalias() where applicable.

diff --git a/bin/dig/host.c b/bin/dig/host.c
index b56c0743affda0f2c00b296a96b9e38a9e9eea8b..4e6dc8d9cdea1b7d4ad5b6bc980bc720d1a2ec29 100644 (file)
--- a/bin/dig/host.c
+++ b/bin/dig/host.c
@@ -246,8 +246,7 @@ printsection(dns_message_t *msg, dns_section_t sectionid,
                               (list_type == dns_rdatatype_any ||
                                rdataset->type == list_type)) ||
                              (list_addresses &&
-                              (rdataset->type == dns_rdatatype_a ||
-                               rdataset->type == dns_rdatatype_aaaa ||
+                              (dns_rdatatype_isaddr(rdataset->type) ||
                                rdataset->type == dns_rdatatype_ns ||
                                rdataset->type == dns_rdatatype_ptr))))
                        {

diff --git a/bin/tests/system/dyndb/driver/db.c b/bin/tests/system/dyndb/driver/db.c
index 761fdae03be716da990ea9700f9d3153563515a0..f5a3bdd219cfc646e9bca63b55172a0db7fd3dd0 100644 (file)
--- a/bin/tests/system/dyndb/driver/db.c
+++ b/bin/tests/system/dyndb/driver/db.c
@@ -232,9 +232,7 @@ addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
        dns_fixedname_init(&name);
        CHECK(dns__db_addrdataset(sampledb->db, node, version, now, rdataset,
                                  options, addedrdataset DNS__DB_FLARG_PASS));
-       if (rdataset->type == dns_rdatatype_a ||
-           rdataset->type == dns_rdatatype_aaaa)
-       {
+       if (dns_rdatatype_isaddr(rdataset->type)) {
                CHECK(dns_db_nodefullname(sampledb->db, node,
                                          dns_fixedname_name(&name)));
                CHECK(syncptrs(sampledb->inst, dns_fixedname_name(&name),
@@ -263,9 +261,7 @@ subtractrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
                goto cleanup;
        }
 
-       if (rdataset->type == dns_rdatatype_a ||
-           rdataset->type == dns_rdatatype_aaaa)
-       {
+       if (dns_rdatatype_isaddr(rdataset->type)) {
                CHECK(dns_db_nodefullname(sampledb->db, node,
                                          dns_fixedname_name(&name)));
                CHECK(syncptrs(sampledb->inst, dns_fixedname_name(&name),

diff --git a/lib/dns/adb.c b/lib/dns/adb.c
index 69766541e18c89117304b66f64f038e50adcb62c..0b47145c3dfe03b7258641df5c5833876f198434 100644 (file)
--- a/lib/dns/adb.c
+++ b/lib/dns/adb.c
@@ -567,7 +567,7 @@ import_rdataset(dns_adbname_t *adbname, dns_rdataset_t *rdataset,
                rdataset->ttl = ttlclamp(rdataset->ttl);
        }
 
-       REQUIRE(rdtype == dns_rdatatype_a || rdtype == dns_rdatatype_aaaa);
+       REQUIRE(dns_rdatatype_isaddr(rdtype));
 
        for (result = dns_rdataset_first(rdataset); result == ISC_R_SUCCESS;
             result = dns_rdataset_next(rdataset))
@@ -2557,7 +2557,7 @@ dbfind_name(dns_adbname_t *adbname, isc_stdtime_t now, dns_rdatatype_t rdtype) {
        adb = adbname->adb;
 
        REQUIRE(DNS_ADB_VALID(adb));
-       REQUIRE(rdtype == dns_rdatatype_a || rdtype == dns_rdatatype_aaaa);
+       REQUIRE(dns_rdatatype_isaddr(rdtype));
 
        fname = dns_fixedname_initname(&foundname);
        dns_rdataset_init(&rdataset);

diff --git a/lib/dns/catz.c b/lib/dns/catz.c
index 09d5afc047f864b6f2fabb94f53ac71e00bf90cc..2a6fd1af4efd920b361d4e372ae538bc9a466037 100644 (file)
--- a/lib/dns/catz.c
+++ b/lib/dns/catz.c
@@ -1516,8 +1516,7 @@ catz_process_primaries(dns_catz_zone_t *catz, dns_ipkeylist_t *ipkl,
        }
        /* else - 'simple' case - without labels */
 
-       if (value->type != dns_rdatatype_a && value->type != dns_rdatatype_aaaa)
-       {
+       if (!dns_rdatatype_isaddr(value->type)) {
                return ISC_R_FAILURE;
        }
 

diff --git a/lib/dns/master.c b/lib/dns/master.c
index 071c1c3475f62f3f162de824079d130d31313abf..6f6b086c51c1235bf776e673a397e23e9b0ff7bc 100644 (file)
--- a/lib/dns/master.c
+++ b/lib/dns/master.c
@@ -1914,7 +1914,7 @@ load_text(dns_loadctx_t *lctx) {
                        }
                }
 
-               if (type == dns_rdatatype_rrsig || type == dns_rdatatype_sig) {
+               if (dns_rdatatype_issig(type)) {
                        covers = dns_rdata_covers(&rdata[rdcount]);
                } else {
                        covers = 0;

diff --git a/lib/dns/qpcache.c b/lib/dns/qpcache.c
index 5f8877867a9cf8a1a3917969a3b193f0889e5c07..03d0abd73bad73af689c01ccff136018f0537b5f 100644 (file)
--- a/lib/dns/qpcache.c
+++ b/lib/dns/qpcache.c
@@ -513,8 +513,7 @@ need_headerupdate(dns_slabheader_t *header, isc_stdtime_t now) {
 #if DNS_QPDB_LIMITLRUUPDATE
        if (header->type == dns_rdatatype_ns ||
            (header->trust == dns_trust_glue &&
-            (header->type == dns_rdatatype_a ||
-             header->type == dns_rdatatype_aaaa)))
+            dns_rdatatype_isaddr(header->type)))
        {
                /*
                 * Glue records are updated if at least DNS_QPDB_LRUUPDATE_GLUE

diff --git a/lib/dns/resolver.c b/lib/dns/resolver.c
index 9a5ba9b872c8613b965649398cef156c4c160248..1f3835983dd3063496395f989c53dbe14e9604f7 100644 (file)
--- a/lib/dns/resolver.c
+++ b/lib/dns/resolver.c
@@ -1569,9 +1569,7 @@ fctx_sendevents(fetchctx_t *fctx, isc_result_t result) {
 
                INSIST(resp->result != ISC_R_SUCCESS ||
                       dns_rdataset_isassociated(resp->rdataset) ||
-                      fctx->type == dns_rdatatype_any ||
-                      fctx->type == dns_rdatatype_rrsig ||
-                      fctx->type == dns_rdatatype_sig);
+                      dns_rdatatype_ismulti(fctx->type));
 
                /*
                 * Negative results must be indicated in resp->result.
@@ -5400,10 +5398,7 @@ validated(void *arg) {
 
        hresp = ISC_LIST_HEAD(fctx->resps);
        if (hresp != NULL) {
-               if (!negative && !chaining &&
-                   (fctx->type == dns_rdatatype_any ||
-                    fctx->type == dns_rdatatype_rrsig ||
-                    fctx->type == dns_rdatatype_sig))
+               if (!negative && !chaining && dns_rdatatype_ismulti(fctx->type))
                {
                        /*
                         * Don't bind rdatasets; the caller
@@ -5625,9 +5620,7 @@ validated(void *arg) {
 
        if (!ISC_LIST_EMPTY(fctx->validators)) {
                INSIST(!negative);
-               INSIST(fctx->type == dns_rdatatype_any ||
-                      fctx->type == dns_rdatatype_rrsig ||
-                      fctx->type == dns_rdatatype_sig);
+               INSIST(dns_rdatatype_ismulti(fctx->type));
                /*
                 * Don't send a response yet - we have
                 * more rdatasets that still need to
@@ -6044,9 +6037,7 @@ cache_name(fetchctx_t *fctx, dns_name_t *name, dns_message_t *message,
                         * DNS_R_CNAME or DNS_R_DNAME and we must set up
                         * the rdatasets.
                         */
-                       if ((fctx->type != dns_rdatatype_any &&
-                            fctx->type != dns_rdatatype_rrsig &&
-                            fctx->type != dns_rdatatype_sig) ||
+                       if (!dns_rdatatype_ismulti(fctx->type) ||
                            name->attributes.chaining)
                        {
                                ardataset = resp->rdataset;
@@ -6295,10 +6286,7 @@ cache_name(fetchctx_t *fctx, dns_name_t *name, dns_message_t *message,
                        }
 
                        if (ANSWER(rdataset) && need_validation) {
-                               if (fctx->type != dns_rdatatype_any &&
-                                   fctx->type != dns_rdatatype_rrsig &&
-                                   fctx->type != dns_rdatatype_sig)
-                               {
+                               if (!dns_rdatatype_ismulti(fctx->type)) {
                                        /*
                                         * This is The Answer.  We will
                                         * validate it, but first we
@@ -6913,14 +6901,12 @@ check_section(void *arg, const dns_name_t *addname, dns_rdatatype_t type,
                             rdataset != NULL;
                             rdataset = ISC_LIST_NEXT(rdataset, link))
                        {
-                               if (rdataset->type == dns_rdatatype_rrsig) {
+                               if (dns_rdatatype_issig(rdataset->type)) {
                                        rtype = rdataset->covers;
                                } else {
                                        rtype = rdataset->type;
                                }
-                               if (rtype == dns_rdatatype_a ||
-                                   rtype == dns_rdatatype_aaaa)
-                               {
+                               if (dns_rdatatype_isaddr(rtype)) {
                                        mark_related(name, rdataset, external,
                                                     gluing);
                                }
@@ -7050,8 +7036,7 @@ is_answertarget_allowed(fetchctx_t *fctx, dns_name_t *qname, dns_name_t *rname,
        int order;
 
        REQUIRE(rdataset != NULL);
-       REQUIRE(rdataset->type == dns_rdatatype_cname ||
-               rdataset->type == dns_rdatatype_dname);
+       REQUIRE(dns_rdatatype_isalias(rdataset->type));
 
        /*
         * By default, we allow any target name.
@@ -7981,9 +7966,7 @@ rctx_answer_init(respctx_t *rctx) {
         * we treat these types as a subset of ANY.
         */
        rctx->type = fctx->type;
-       if (rctx->type == dns_rdatatype_rrsig ||
-           rctx->type == dns_rdatatype_sig)
-       {
+       if (dns_rdatatype_issig(fctx->type)) {
                rctx->type = dns_rdatatype_any;
        }
 
@@ -8676,15 +8659,13 @@ rctx_answer_any(respctx_t *rctx) {
                        return ISC_R_COMPLETE;
                }
 
-               if ((fctx->type == dns_rdatatype_sig ||
-                    fctx->type == dns_rdatatype_rrsig) &&
+               if (dns_rdatatype_issig(fctx->type) &&
                    rdataset->type != fctx->type)
                {
                        continue;
                }
 
-               if ((rdataset->type == dns_rdatatype_a ||
-                    rdataset->type == dns_rdatatype_aaaa) &&
+               if (dns_rdatatype_isaddr(rdataset->type) &&
                    !is_answeraddress_allowed(fctx->res->view, rctx->aname,
                                              rdataset))
                {
@@ -8692,8 +8673,7 @@ rctx_answer_any(respctx_t *rctx) {
                        return ISC_R_COMPLETE;
                }
 
-               if ((rdataset->type == dns_rdatatype_cname ||
-                    rdataset->type == dns_rdatatype_dname) &&
+               if (dns_rdatatype_isalias(rdataset->type) &&
                    !is_answertarget_allowed(fctx, fctx->name, rctx->aname,
                                             rdataset, NULL))
                {
@@ -8728,16 +8708,14 @@ rctx_answer_match(respctx_t *rctx) {
                return ISC_R_COMPLETE;
        }
 
-       if ((rctx->ardataset->type == dns_rdatatype_a ||
-            rctx->ardataset->type == dns_rdatatype_aaaa) &&
+       if (dns_rdatatype_isaddr(rctx->ardataset->type) &&
            !is_answeraddress_allowed(fctx->res->view, rctx->aname,
                                      rctx->ardataset))
        {
                rctx->result = DNS_R_SERVFAIL;
                return ISC_R_COMPLETE;
        }
-       if ((rctx->ardataset->type == dns_rdatatype_cname ||
-            rctx->ardataset->type == dns_rdatatype_dname) &&
+       if (dns_rdatatype_isalias(rctx->ardataset->type) &&
            rctx->type != rctx->ardataset->type &&
            rctx->type != dns_rdatatype_any &&
            !is_answertarget_allowed(fctx, fctx->name, rctx->aname,
@@ -9158,7 +9136,7 @@ rctx_authority_negative(respctx_t *rctx) {
                     rdataset = ISC_LIST_NEXT(rdataset, link))
                {
                        dns_rdatatype_t type = rdataset->type;
-                       if (type == dns_rdatatype_rrsig) {
+                       if (dns_rdatatype_issig(rdataset->type)) {
                                type = rdataset->covers;
                        }
                        if ((type == dns_rdatatype_ns ||
@@ -9329,7 +9307,7 @@ rctx_authority_dnssec(respctx_t *rctx) {
                        bool secure_domain = false;
                        dns_rdatatype_t type = rdataset->type;
 
-                       if (type == dns_rdatatype_rrsig) {
+                       if (dns_rdatatype_issig(type)) {
                                type = rdataset->covers;
                        }
 
@@ -9482,9 +9460,7 @@ rctx_referral(respctx_t *rctx) {
         * additional section that are in the answer section or if
         * the record gets dropped due to message size constraints.
         */
-       if (rctx->glue_in_answer &&
-           (fctx->type == dns_rdatatype_aaaa || fctx->type == dns_rdatatype_a))
-       {
+       if (rctx->glue_in_answer && dns_rdatatype_isaddr(fctx->type)) {
                (void)dns_rdataset_additionaldata(
                        rctx->ns_rdataset, rctx->ns_name, check_answer, fctx);
        }

diff --git a/lib/dns/sdlz.c b/lib/dns/sdlz.c
index e99f34da13d57afed5c9f6d3b9773fe445e2cbf4..ce5f0963ab0ff2b78a75662c5b01c6441a41c963 100644 (file)
--- a/lib/dns/sdlz.c
+++ b/lib/dns/sdlz.c
@@ -752,7 +752,7 @@ findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
        UNUSED(now);
        UNUSED(sigrdataset);
 
-       if (type == dns_rdatatype_sig || type == dns_rdatatype_rrsig) {
+       if (dns_rdatatype_issig(type)) {
                return ISC_R_NOTIMPLEMENTED;
        }
 

diff --git a/lib/ns/query.c b/lib/ns/query.c
index 2ec0e1109b0d64fa8f9a9214c39536b1e317322d..44d13382818c7b80d3210c9e3ebe9d69bae9f105 100644 (file)
--- a/lib/ns/query.c
+++ b/lib/ns/query.c
@@ -3318,9 +3318,7 @@ rpz_find_p(ns_client_t *client, dns_name_t *self_name, dns_rdatatype_t qtype,
                        }
                        dns_db_detachnode(*dbp, nodep);
 
-                       if (qtype == dns_rdatatype_rrsig ||
-                           qtype == dns_rdatatype_sig)
-                       {
+                       if (dns_rdatatype_issig(qtype)) {
                                result = DNS_R_NXRRSET;
                        } else {
                                result = dns_db_findext(*dbp, p_name, *versionp,
@@ -5044,9 +5042,7 @@ qctx_init(ns_client_t *client, dns_fetchresponse_t **frespp,
        /*
         * If it's an RRSIG or SIG query, we'll iterate the node.
         */
-       if (qctx->qtype == dns_rdatatype_rrsig ||
-           qctx->qtype == dns_rdatatype_sig)
-       {
+       if (dns_rdatatype_issig(qctx->qtype)) {
                qctx->type = dns_rdatatype_any;
        }
 
@@ -5439,8 +5435,7 @@ ns__query_start(query_ctx_t *qctx) {
         */
        if (qctx->view->root_key_sentinel &&
            qctx->client->query.restarts == 0 &&
-           (qctx->qtype == dns_rdatatype_a ||
-            qctx->qtype == dns_rdatatype_aaaa) &&
+           (dns_rdatatype_isaddr(qctx->qtype)) &&
            (qctx->client->message->flags & DNS_MESSAGEFLAG_CD) == 0)
        {
                root_key_sentinel_detect(qctx);
@@ -6495,9 +6490,7 @@ query_resume(query_ctx_t *qctx) {
        }
        INSIST(qctx->rdataset != NULL);
 
-       if (qctx->qtype == dns_rdatatype_rrsig ||
-           qctx->qtype == dns_rdatatype_sig)
-       {
+       if (dns_rdatatype_issig(qctx->qtype)) {
                qctx->type = dns_rdatatype_any;
        } else {
                qctx->type = qctx->qtype;
@@ -7735,8 +7728,7 @@ query_respond_any(query_ctx_t *qctx) {
                } else if (qctx->view->minimal_any && !TCP(qctx->client) &&
                           !WANTDNSSEC(qctx->client) &&
                           qctx->qtype == dns_rdatatype_any &&
-                          (qctx->rdataset->type == dns_rdatatype_sig ||
-                           qctx->rdataset->type == dns_rdatatype_rrsig))
+                          (dns_rdatatype_issig(qctx->rdataset->type)))
                {
                        CCTRACE(ISC_LOG_DEBUG(5), "query_respond_any: "
                                                  "minimal-any skip signature");
@@ -7781,9 +7773,7 @@ query_respond_any(query_ctx_t *qctx) {
                         * Remember the first RRtype we find so we
                         * can skip others with minimal-any.
                         */
-                       if (qctx->rdataset->type == dns_rdatatype_sig ||
-                           qctx->rdataset->type == dns_rdatatype_rrsig)
-                       {
+                       if (dns_rdatatype_issig(qctx->rdataset->type)) {
                                onetype = qctx->rdataset->covers;
                        } else {
                                onetype = qctx->rdataset->type;
@@ -7847,9 +7837,7 @@ query_respond_any(query_ctx_t *qctx) {
                 * At least one matching rdataset was found
                 */
                query_addauth(qctx);
-       } else if (qctx->qtype == dns_rdatatype_rrsig ||
-                  qctx->qtype == dns_rdatatype_sig)
-       {
+       } else if (dns_rdatatype_issig(qctx->qtype)) {
                /*
                 * No matching rdatasets were found, but we got
                 * here on a search for RRSIG/SIG, so that's okay.
@@ -9918,8 +9906,7 @@ query_coveringnsec(query_ctx_t *qctx) {
                        goto cleanup;
                }
                if (!ISC_LIST_EMPTY(qctx->view->dns64) &&
-                   (qctx->type == dns_rdatatype_a ||
-                    qctx->type == dns_rdatatype_aaaa)) /* XXX not yet */
+                   dns_rdatatype_isaddr(qctx->type)) /* XXX not yet */
                {
                        goto cleanup;
                }
@@ -9978,8 +9965,7 @@ query_coveringnsec(query_ctx_t *qctx) {
                        goto cleanup;
                }
                if (!ISC_LIST_EMPTY(qctx->view->dns64) &&
-                   (qctx->type == dns_rdatatype_a ||
-                    qctx->type == dns_rdatatype_aaaa)) /* XXX not yet */
+                   dns_rdatatype_isaddr(qctx->type)) /* XXX not yet */
                {
                        goto cleanup;
                }
@@ -11329,8 +11315,7 @@ query_glueanswer(query_ctx_t *qctx) {
 
        if (!ISC_LIST_EMPTY(secs[DNS_SECTION_ANSWER]) ||
            qctx->client->message->rcode != dns_rcode_noerror ||
-           (qctx->qtype != dns_rdatatype_a &&
-            qctx->qtype != dns_rdatatype_aaaa))
+           !dns_rdatatype_isaddr(qctx->qtype))
        {
                return;
        }

diff --git a/lib/ns/update.c b/lib/ns/update.c
index 1b73d5ba7c1b4e084308c7349222f2e573c8130d..573c9f7b3fadf0da3311dc0eb5fdfc7f4120c658 100644 (file)
--- a/lib/ns/update.c
+++ b/lib/ns/update.c
@@ -1165,9 +1165,7 @@ temp_check(isc_mem_t *mctx, dns_diff_t *temp, dns_db_t *db,
                                           *    this name and type */
 
                        *typep = type = t->rdata.type;
-                       if (type == dns_rdatatype_rrsig ||
-                           type == dns_rdatatype_sig)
-                       {
+                       if (dns_rdatatype_issig(type)) {
                                covers = dns_rdata_covers(&t->rdata);
                        } else if (type == dns_rdatatype_any) {
                                dns_db_detachnode(db, &node);

diff --git a/lib/ns/xfrout.c b/lib/ns/xfrout.c
index a47ddadcc0648d4bba229efe45e2027bb4aaf324..96012fdccd463af0ec738c30f642b1d764d44cfa 100644 (file)
--- a/lib/ns/xfrout.c
+++ b/lib/ns/xfrout.c
@@ -135,9 +135,7 @@ log_rr(dns_name_t *name, dns_rdata_t *rdata, uint32_t ttl) {
        rdl.type = rdata->type;
        rdl.rdclass = rdata->rdclass;
        rdl.ttl = ttl;
-       if (rdata->type == dns_rdatatype_sig ||
-           rdata->type == dns_rdatatype_rrsig)
-       {
+       if (dns_rdatatype_issig(rdata->type)) {
                rdl.covers = dns_rdata_covers(rdata);
        } else {
                rdl.covers = dns_rdatatype_none;
@@ -1553,9 +1551,7 @@ sendstream(xfrout_ctx_t *xfr) {
                msgrdl->type = rdata->type;
                msgrdl->rdclass = rdata->rdclass;
                msgrdl->ttl = ttl;
-               if (rdata->type == dns_rdatatype_sig ||
-                   rdata->type == dns_rdatatype_rrsig)
-               {
+               if (dns_rdatatype_issig(rdata->type)) {
                        msgrdl->covers = dns_rdata_covers(rdata);
                } else {
                        msgrdl->covers = dns_rdatatype_none;