parse type in host byte order.

git-svn-id: file:///svn/unbound/trunk@256 be551aaa-1e26-0410-a405-d3ace91eadb9

diff --git a/doc/Changelog b/doc/Changelog
index 0768764d84afce53b1b9351c490f8e520d1407cb..c945cca402509e07f2eee570d12b85f57aa90637 100644 (file)
--- a/doc/Changelog
+++ b/doc/Changelog
@@ -1,3 +1,6 @@
+25 April 2007: Wouter
+       - prettier code; parse_rrset->type kept in host byte order.
+
 24 April 2007: Wouter
        - ttl per RR, for RRSIG rrsets and others.
        - dname_print debug function.

diff --git a/testcode/unitmain.c b/testcode/unitmain.c
index 26ef8da5e247b3eef4f5864c783eaf0d9e9194f0..68c3af23f1f42c963510262540571548741b3688 100644 (file)
--- a/testcode/unitmain.c
+++ b/testcode/unitmain.c
@@ -218,6 +218,6 @@ main(int argc, char* argv[])
        slabhash_test();
        msgparse_test();
        checklock_stop();
-       printf("%d tests succeeded\n", testcount);
+       printf("%d checks ok.\n", testcount);
        return 0;
 }

diff --git a/util/data/msgparse.c b/util/data/msgparse.c
index d4fccfffa75bbd7229cceb02486fd92da3d52e38..0b6a674c5893615593f35d64dddd121dfa2bc98a 100644 (file)
--- a/util/data/msgparse.c
+++ b/util/data/msgparse.c
@@ -149,7 +149,7 @@ pkt_rrset_flags(struct msg_parse* msg, ldns_buffer* pkt, uint16_t type)
        if(msg->flags & BIT_CD)
                f = PACKED_RRSET_CD;
        else    f = 0;
-       if(type == htons(LDNS_RR_TYPE_NSEC) && nsec_at_apex(pkt)) {
+       if(type == LDNS_RR_TYPE_NSEC && nsec_at_apex(pkt)) {
                f |= PACKED_RRSET_NSEC_AT_APEX;
        }
        return f;
@@ -224,7 +224,7 @@ static int
 pkt_rrsig_covered_equals(ldns_buffer* pkt, uint8_t* here, uint16_t type)
 {
        uint16_t t;
-       if(pkt_rrsig_covered(pkt, here, &t) && t == ntohs(type))
+       if(pkt_rrsig_covered(pkt, here, &t) && t == type)
                return 1;
        return 0;
 }
@@ -295,7 +295,7 @@ rrset_has_sigover(ldns_buffer* pkt, struct rrset_parse* rrset, uint16_t type,
 {
        int res = 0;
        struct rr_parse* rr = rrset->rr_first;
-       log_assert( htons(rrset->type) == LDNS_RR_TYPE_RRSIG );
+       log_assert( rrset->type == LDNS_RR_TYPE_RRSIG );
        while(rr) {
                if(pkt_rrsig_covered_equals(pkt, rr->ttl_data, type))
                        res = 1;
@@ -356,8 +356,8 @@ change_rrsig_rrset(struct rrset_parse* sigset, struct msg_parse* msg,
        struct rrset_parse* dataset = sigset;
        hashvalue_t hash = pkt_hash_rrset(pkt, sigset->dname, sigset->type, 
                sigset->rrset_class, rrset_flags);
-       log_assert( ntohs(sigset->type) == LDNS_RR_TYPE_RRSIG );
-       log_assert( ntohs(datatype) != LDNS_RR_TYPE_RRSIG );
+       log_assert( sigset->type == LDNS_RR_TYPE_RRSIG );
+       log_assert( datatype != LDNS_RR_TYPE_RRSIG );
        if(hasother) {
                /* need to make new rrset to hold data type */
                dataset = new_rrset(msg, sigset->dname, sigset->dname_len, 
@@ -372,8 +372,8 @@ change_rrsig_rrset(struct rrset_parse* sigset, struct msg_parse* msg,
                        default: log_assert(0);
                }
                if(!moveover_rrsigs(pkt, region, sigset, dataset, 
-                       ntohs(msg->qtype) == LDNS_RR_TYPE_RRSIG ||
-                       ntohs(msg->qtype) == LDNS_RR_TYPE_ANY ))
+                       msg->qtype == LDNS_RR_TYPE_RRSIG ||
+                       msg->qtype == LDNS_RR_TYPE_ANY ))
                        return NULL;
                return dataset;
        }
@@ -437,8 +437,7 @@ find_rrset(struct msg_parse* msg, ldns_buffer* pkt, uint8_t* dname,
                        return 1;
                }
                /* check if rrsig over previous item */
-               if(ntohs(type) == LDNS_RR_TYPE_RRSIG && 
-                       dclass == *prev_dclass &&
+               if(type == LDNS_RR_TYPE_RRSIG && dclass == *prev_dclass &&
                        pkt_rrsig_covered_equals(pkt, ldns_buffer_current(pkt),
                                *prev_type) &&
                        smart_compare(pkt, dname, *prev_dname_first,
@@ -452,14 +451,13 @@ find_rrset(struct msg_parse* msg, ldns_buffer* pkt, uint8_t* dname,
        *rrset_flags = pkt_rrset_flags(msg, pkt, type);
        
        /* if rrsig - try to lookup matching data set first */
-       if(ntohs(type) == LDNS_RR_TYPE_RRSIG && pkt_rrsig_covered(pkt, 
+       if(type == LDNS_RR_TYPE_RRSIG && pkt_rrsig_covered(pkt, 
                ldns_buffer_current(pkt), &covtype)) {
-               covtype = htons(covtype);
                *hash = pkt_hash_rrset(pkt, dname, covtype, dclass, 
                        *rrset_flags);
                *rrset_prev = hashtable_lookup(msg, pkt, *hash, *rrset_flags, 
                        dname, dnamelen, covtype, dclass);
-               if(!*rrset_prev && ntohs(covtype) == LDNS_RR_TYPE_NSEC) {
+               if(!*rrset_prev && covtype == LDNS_RR_TYPE_NSEC) {
                        /* if NSEC try with NSEC apex bit twiddled */
                        *rrset_flags ^= PACKED_RRSET_NSEC_AT_APEX;
                        *hash = pkt_hash_rrset(pkt, dname, covtype, dclass, 
@@ -476,13 +474,13 @@ find_rrset(struct msg_parse* msg, ldns_buffer* pkt, uint8_t* dname,
                        return 1;
                }
        }
-       if(ntohs(type) != LDNS_RR_TYPE_RRSIG) {
+       if(type != LDNS_RR_TYPE_RRSIG) {
                int hasother = 0;
                /* find matching rrsig */
-               *hash = pkt_hash_rrset(pkt, dname, htons(LDNS_RR_TYPE_RRSIG), 
+               *hash = pkt_hash_rrset(pkt, dname, LDNS_RR_TYPE_RRSIG, 
                        dclass, *rrset_flags);
                *rrset_prev = hashtable_lookup(msg, pkt, *hash, *rrset_flags, 
-                       dname, dnamelen, htons(LDNS_RR_TYPE_RRSIG), dclass);
+                       dname, dnamelen, LDNS_RR_TYPE_RRSIG, dclass);
                if(*rrset_prev && rrset_has_sigover(pkt, *rrset_prev, type,
                        &hasother)) {
                        /* yes! */
@@ -694,8 +692,8 @@ add_rr_to_rrset(struct rrset_parse* rrset, ldns_buffer* pkt,
 {
        struct rr_parse* rr;
        /* check section of rrset. */
-       if(rrset->section != section && ntohs(type) != LDNS_RR_TYPE_RRSIG &&
-               ntohs(rrset->type) != LDNS_RR_TYPE_RRSIG) {
+       if(rrset->section != section && type != LDNS_RR_TYPE_RRSIG &&
+               rrset->type != LDNS_RR_TYPE_RRSIG) {
                /* silently drop it - it is a security problem, since
                 * trust in rr data depends on the section it is in. 
                 * the less trustworthy part is discarded. */
@@ -707,8 +705,8 @@ add_rr_to_rrset(struct rrset_parse* rrset, ldns_buffer* pkt,
                return 0;
        } 
 
-       if( (ntohs(msg->qtype) == LDNS_RR_TYPE_RRSIG ||
-            ntohs(msg->qtype) == LDNS_RR_TYPE_ANY) 
+       if( (msg->qtype == LDNS_RR_TYPE_RRSIG ||
+            msg->qtype == LDNS_RR_TYPE_ANY) 
            && sig_is_double(pkt, rrset, ldns_buffer_current(pkt))) {
                if(!skip_ttl_rdata(pkt))
                        return LDNS_RCODE_FORMERR;
@@ -720,7 +718,7 @@ add_rr_to_rrset(struct rrset_parse* rrset, ldns_buffer* pkt,
                return LDNS_RCODE_SERVFAIL;
        rr->ttl_data = ldns_buffer_current(pkt);
        rr->next = 0;
-       if(ntohs(type) == LDNS_RR_TYPE_RRSIG) {
+       if(type == LDNS_RR_TYPE_RRSIG) {
                if(rrset->rrsig_last) 
                        rrset->rrsig_last->next = rr;
                else    rrset->rrsig_first = rr;
@@ -735,7 +733,7 @@ add_rr_to_rrset(struct rrset_parse* rrset, ldns_buffer* pkt,
        }
 
        /* calc decompressed size */
-       if(!calc_size(pkt, ntohs(type), rr))
+       if(!calc_size(pkt, type, rr))
                return LDNS_RCODE_FORMERR;
        rrset->size += rr->size;
 
@@ -778,14 +776,14 @@ parse_section(ldns_buffer* pkt, struct msg_parse* msg, region_type* region,
                        return LDNS_RCODE_FORMERR;
                if(ldns_buffer_remaining(pkt) < 10) /* type, class, ttl, len */
                        return LDNS_RCODE_FORMERR;
-               ldns_buffer_read(pkt, &type, sizeof(type));
+               type = ldns_buffer_read_u16(pkt);
                ldns_buffer_read(pkt, &dclass, sizeof(dclass));
 
                if(0) { /* debug show what is being parsed. */
                        printf("parse of %s(%d)",
-                               ldns_rr_descript(ntohs(type))?
-                               ldns_rr_descript(ntohs(type))->_name: "??",
-                               (int)ntohs(type));
+                               ldns_rr_descript(type)?
+                               ldns_rr_descript(type)->_name: "??",
+                               (int)type);
                        printf(" %s(%d) ",
                                ldns_lookup_by_id(ldns_rr_classes, 
                                (int)ntohs(dclass))?ldns_lookup_by_id(
@@ -860,7 +858,7 @@ parse_extract_edns(struct msg_parse* msg, struct edns_data* edns)
        /* since the class encodes the UDP size, we cannot use hash table to
         * find the EDNS OPT record. Scan the packet. */
        while(rrset) {
-               if(ntohs(rrset->type) == LDNS_RR_TYPE_OPT) {
+               if(rrset->type == LDNS_RR_TYPE_OPT) {
                        /* only one OPT RR allowed. */
                        if(found) return LDNS_RCODE_FORMERR;
                        /* found it! */

diff --git a/util/data/msgparse.h b/util/data/msgparse.h
index 1dab1ff4f26ead4b4c34454ad43cfcf8511a3c43..fac9ab32963b2c08431399b0fb9931e96bf81db5 100644 (file)
--- a/util/data/msgparse.h
+++ b/util/data/msgparse.h
@@ -102,9 +102,9 @@ struct msg_parse {
        uint8_t* qname;
        /** length of query dname in octets, 0 if none */
        size_t qname_len;
-       /** query type, network order. 0 if qdcount=0 */
+       /** query type, host order. 0 if qdcount=0 */
        uint16_t qtype;
-       /** query class, network order. 0 if qdcount=0 */
+       /** query class, host order. 0 if qdcount=0 */
        uint16_t qclass;
 
        /**
@@ -137,7 +137,7 @@ struct rrset_parse {
        uint8_t* dname;
        /** length of the dname uncompressed wireformat */
        size_t dname_len;
-       /** type, network order. */
+       /** type, host order. */
        uint16_t type;
        /** class, network order. var name so that it is not a c++ keyword. */
        uint16_t rrset_class;

diff --git a/util/data/msgreply.c b/util/data/msgreply.c
index 3267bc5dc6f0f88fd6902a7defd9a873040ae720..ece8093a36697d38c2efb6e952073eb6287115da 100644 (file)
--- a/util/data/msgreply.c
+++ b/util/data/msgreply.c
@@ -210,7 +210,7 @@ parse_rr_copy(ldns_buffer* pkt, struct rrset_parse* pset,
                data->rr_data[i] = nextrdata;
                nextrdata += rr->size;
                if(!rdata_copy(pkt, data, data->rr_data[i], rr, 
-                       &data->rr_ttl[i], ntohs(pset->type)))
+                       &data->rr_ttl[i], pset->type))
                        return 0;
                rr = rr->next;
        }
@@ -259,6 +259,7 @@ parse_copy_decompress(ldns_buffer* pkt, struct msg_parse* msg,
 {
        int ret;
        size_t i;
+       uint16_t t;
        struct rrset_parse *pset = msg->rrset_first;
        struct packed_rrset_data* data;
        log_assert(rep);
@@ -273,8 +274,9 @@ parse_copy_decompress(ldns_buffer* pkt, struct msg_parse* msg,
                /** copy & decompress dname */
                dname_pkt_copy(pkt, rep->rrsets[i]->rk.dname, pset->dname);
                /** copy over type and class */
+               t = htons(pset->type);
                memmove(&rep->rrsets[i]->rk.dname[pset->dname_len], 
-                       &pset->type, sizeof(uint16_t));
+                       &t, sizeof(uint16_t));
                memmove(&rep->rrsets[i]->rk.dname[pset->dname_len+2], 
                        &pset->rrset_class, sizeof(uint16_t));
                /** read data part. */

diff --git a/util/data/msgreply.h b/util/data/msgreply.h
index 565765d1d30302f34d9a6b4649f6ea6995bfd5a4..b7fc771fdf41c2c57cbe9675726f7071981b91b5 100644 (file)
--- a/util/data/msgreply.h
+++ b/util/data/msgreply.h
@@ -61,9 +61,9 @@ struct query_info {
        uint8_t* qname;
        /** length of qname (including last 0 octet) */
        size_t qnamesize;
-       /** qtype */
+       /** qtype, host byte order */
        uint16_t qtype;
-       /** qclass */
+       /** qclass, host byte order */
        uint16_t qclass;
        /** does query have CD bit set */
        int has_cd;