replaced the pkt_get_sigs with the more generale get_rr_list_by_name_and_type

added an rr_compare_ds that 'sees' no difference between a dnskey and its ds representation
more functions for chasing

diff --git a/dnssec.c b/dnssec.c
index 380ec17efffa1086d50fbe754702d4a24adc249d..3fbd6fd53c0faec398119b681970a04363f74ea5 100644 (file)
--- a/dnssec.c
+++ b/dnssec.c
@@ -70,75 +70,9 @@ ldns_keytag(ldns_rr *key)
        }
 }
 
-/**
- * Returns an rr_list that contains the possible rrsigs for the given 
- * rr in the given packet
- * Allocates and copies, so don't forget to free!
- * TODO: helper for rr copying?
- * ldns_rr_deep_clone????
- */
-ldns_rr_list *
-ldns_pkt_get_sigs(ldns_pkt *pkt, ldns_rr *rr)
-{
-       ldns_rr_list *sigs = ldns_rr_list_new();
-       ldns_rr_list *pkt_rrs;
-       ldns_rr *cur_rr;
-       uint16_t i;
-       
-       pkt_rrs = ldns_pkt_answer(pkt);
-       if (pkt_rrs) {
-               for (i = 0; i < ldns_rr_list_rr_count(pkt_rrs); i++) {
-                       cur_rr = ldns_rr_list_rr(pkt_rrs, i);
-                       if (ldns_rdf_compare(ldns_rr_owner(rr),
-                                        ldns_rr_owner(cur_rr)
-                                       )
-                          &&
-                               ldns_rr_get_type(cur_rr) == LDNS_RR_TYPE_RRSIG
-                          ) {
-                               ldns_rr_list_push_rr(sigs,
-                                                    ldns_rr_deep_clone(cur_rr));
-                       }
-               }
-       }
-       pkt_rrs = ldns_pkt_authority(pkt);
-       if (pkt_rrs) {
-               for (i = 0; i < ldns_rr_list_rr_count(pkt_rrs); i++) {
-                       cur_rr = ldns_rr_list_rr(pkt_rrs, i);
-                       if (ldns_rdf_compare(ldns_rr_owner(rr),
-                                        ldns_rr_owner(cur_rr)
-                                       )
-                          &&
-                               ldns_rr_get_type(cur_rr) == LDNS_RR_TYPE_RRSIG
-                          ) {
-                               ldns_rr_list_push_rr(sigs,
-                                                    ldns_rr_deep_clone(cur_rr));
-                       }
-               }
-       }
-       pkt_rrs = ldns_pkt_additional(pkt);
-       if (pkt_rrs) {
-               for (i = 0; i < ldns_rr_list_rr_count(pkt_rrs); i++) {
-                       cur_rr = ldns_rr_list_rr(pkt_rrs, i);
-                       if (ldns_rdf_compare(ldns_rr_owner(rr),
-                                        ldns_rr_owner(cur_rr)
-                                       )
-                          &&
-                               ldns_rr_get_type(cur_rr) == LDNS_RR_TYPE_RRSIG
-                          ) {
-                               ldns_rr_list_push_rr(sigs,
-                                                    ldns_rr_deep_clone(cur_rr));
-                       }
-               }
-       }
-               
-       return sigs;
-}
-
-
 /**
  * verify an rrsig rrset
  */
-
 bool
 ldns_verify(ldns_rr_list *rrset, ldns_rr_list *rrsig, ldns_rr_list *keys)
 {
@@ -732,7 +666,9 @@ ldns_pkt_tsig_sign(ldns_pkt *pkt, const char *key_name, const char *key_data, ui
        return LDNS_STATUS_OK;
 }
 
-
+/** 
+ * Returns a new DS rr that represents the given key rr
+ */
 ldns_rr *
 ldns_key_rr2ds(ldns_rr *key)
 {

diff --git a/ldns/dnssec.h b/ldns/dnssec.h
index 4369e6a5cd76a1bc87a6b72bcb77542b3e311156..869873e3a979d7ba6695b29d56f00421a5c80d84 100644 (file)
--- a/ldns/dnssec.h
+++ b/ldns/dnssec.h
@@ -46,6 +46,4 @@ ldns_status ldns_pkt_tsig_sign(ldns_pkt *pkt, const char *key_name, const char *
 
 ldns_rr *ldns_key_rr2ds(ldns_rr *key);
 
-ldns_rr_list *ldns_pkt_get_sigs(ldns_pkt *pkt, ldns_rr *rr);
-
 #endif /* _DNSSEC_H_ */

diff --git a/ldns/packet.h b/ldns/packet.h
index ea2f2f3d79285a0b5e06d74b4a9201a0b57a4073..59db6eff1fb83b709617991140c7154fd5e2ae3b 100644 (file)
--- a/ldns/packet.h
+++ b/ldns/packet.h
@@ -101,7 +101,8 @@ enum ldns_enum_pkt_section {
        LDNS_SECTION_ANSWER = 1,
        LDNS_SECTION_AUTHORITY = 2,
        LDNS_SECTION_ADDITIONAL = 3,
-       LDNS_SECTION_ANY = 4  /* bogus section, if not interested */
+       LDNS_SECTION_ANY = 4,  /* bogus section, if not interested */
+       LDNS_SECTION_ANY_NOQUESTION = 5 /* used to get all non-question rrs from a packet */
 };
 typedef enum ldns_enum_pkt_section ldns_pkt_section;   
 
@@ -147,6 +148,7 @@ ldns_rr_list *ldns_pkt_additional(const ldns_pkt *);
 ldns_rr_list *ldns_pkt_xxsection(ldns_pkt *, ldns_pkt_section);
 ldns_rr_list *ldns_pkt_rr_list_by_name(ldns_pkt *, ldns_rdf *, ldns_pkt_section);
 ldns_rr_list *ldns_pkt_rr_list_by_type(ldns_pkt *, ldns_rr_type, ldns_pkt_section);
+ldns_rr_list *ldns_pkt_rr_list_by_name_and_type(ldns_pkt *packet, ldns_rdf *ownername, ldns_rr_type type, ldns_pkt_section sec);
 
 void ldns_pkt_set_id(ldns_pkt *, uint16_t);
 void ldns_pkt_set_qr(ldns_pkt *, bool);

diff --git a/ldns/rr.h b/ldns/rr.h
index 8801494f15d3e3045d52dfc4dabe0b72b26d9c2f..d8b338a2b2364cbb8091508ce8d93f62ff5c8721 100644 (file)
--- a/ldns/rr.h
+++ b/ldns/rr.h
@@ -271,6 +271,7 @@ ldns_rr_type ldns_get_rr_type_by_name(const char *);
 ldns_rr_class ldns_get_rr_class_by_name(const char *);
 size_t ldns_rr_uncompressed_size(const ldns_rr *);
 int ldns_rr_compare(const ldns_rr *rr1, const ldns_rr *rr2);
+bool ldns_rr_compare_ds(const ldns_rr *rr1, const ldns_rr *rr2);
 void ldns_rr_list_sort(ldns_rr_list *);
 
 ldns_rr *ldns_rr_deep_clone(ldns_rr *rr);

diff --git a/packet.c b/packet.c
index ce951dcd776576033c92a9c97835cbdeced0abfd..375c15e1bb75432f9c1febaea8915a1a2fd1b06b 100644 (file)
--- a/packet.c
+++ b/packet.c
@@ -149,6 +149,20 @@ ldns_pkt_all(ldns_pkt *packet)
        return all;
 }
 
+ldns_rr_list *
+ldns_pkt_all_noquestion(ldns_pkt *packet)
+{
+       /* mem leaks?? :( */
+       ldns_rr_list *all;
+
+       all = ldns_rr_list_cat(
+                       ldns_pkt_xxsection(packet, LDNS_SECTION_ANSWER),
+                       ldns_pkt_xxsection(packet, LDNS_SECTION_AUTHORITY));
+       all = ldns_rr_list_cat(all,
+                       ldns_pkt_xxsection(packet, LDNS_SECTION_ADDITIONAL));
+       return all;
+}
+
 size_t
 ldns_pkt_size(const ldns_pkt *packet)
 {
@@ -259,6 +273,37 @@ ldns_pkt_rr_list_by_type(ldns_pkt *packet, ldns_rr_type type, ldns_pkt_section s
        return ret;
 }
 
+/* return only those rrs that share name and type */
+ldns_rr_list *
+ldns_pkt_rr_list_by_name_and_type(ldns_pkt *packet, ldns_rdf *ownername, ldns_rr_type type, ldns_pkt_section sec)
+{
+       ldns_rr_list *rrs;
+       ldns_rr_list *new;
+       ldns_rr_list *ret;
+       uint16_t i;
+
+       if(!packet) {
+               return NULL;
+       }
+       
+       rrs = ldns_pkt_xxsection(packet, sec);
+       new = ldns_rr_list_new();
+       ret = NULL;
+
+       for(i = 0; i < ldns_rr_list_rr_count(rrs); i++) {
+               if (type == ldns_rr_get_type(ldns_rr_list_rr(rrs, i)) &&
+                   ldns_rdf_compare(ldns_rr_owner(ldns_rr_list_rr(rrs, i)),
+                                    ownername
+                                   ) == 0
+                  ) {
+                       /* types match */
+                       ldns_rr_list_push_rr(new, ldns_rr_list_rr(rrs, i));
+                       ret = new;
+               }
+       }
+       return ret;
+}
+
 /** 
  * check to see if an rr exist in the packet
  * \param[in] pkt the packet to examine
@@ -305,6 +350,10 @@ ldns_pkt_xxcount(const ldns_pkt *packet, ldns_pkt_section s)
                        ldns_pkt_ancount(packet) +
                        ldns_pkt_nscount(packet) +
                        ldns_pkt_arcount(packet);
+       case LDNS_SECTION_ANY_NOQUESTION:
+               return ldns_pkt_ancount(packet) +
+                       ldns_pkt_nscount(packet) +
+                       ldns_pkt_arcount(packet);
        default:
                abort();
        }
@@ -324,6 +373,8 @@ ldns_pkt_xxsection(ldns_pkt *packet, ldns_pkt_section s)
                return ldns_pkt_additional(packet);
        case LDNS_SECTION_ANY:
                return ldns_pkt_all(packet);
+       case LDNS_SECTION_ANY_NOQUESTION:
+               return ldns_pkt_all_noquestion(packet);
        default:
                abort();
        }
@@ -492,6 +543,7 @@ ldns_pkt_set_xxcount(ldns_pkt *packet, ldns_pkt_section s, uint16_t count)
                        ldns_pkt_set_arcount(packet, count);
                        break;
                case LDNS_SECTION_ANY:
+               case LDNS_SECTION_ANY_NOQUESTION:
                        break;
        }
 }
@@ -536,6 +588,7 @@ ldns_pkt_push_rr(ldns_pkt *packet, ldns_pkt_section section, ldns_rr *rr)
                        ldns_pkt_set_arcount(packet, ldns_pkt_arcount(packet) + 1);
                        break;
                case LDNS_SECTION_ANY:
+               case LDNS_SECTION_ANY_NOQUESTION:
                        break;
        }
        return true;

diff --git a/rr.c b/rr.c
index 4e4e008eb1ec5dbe618cacc8d812899c9b4997f0..a610ab9e5681e8897abc6f79d67abac4e82c8159 100644 (file)
--- a/rr.c
+++ b/rr.c
@@ -1325,18 +1325,42 @@ ldns_rr_compare(const ldns_rr *rr1, const ldns_rr *rr2)
                }
                /* now compare the buffer's byte for byte */
                for(i = 0; i < rr1_len; i++) {
-                       if (ldns_buffer_at(rr1_buf, i) < 
-                               ldns_buffer_at(rr2_buf, i)) {
+                       if (rr1_buf->_data[i] < rr2_buf->_data[i]) {
                                return -1;
-                       } else if (ldns_buffer_at(rr1_buf, i) >
-                                       ldns_buffer_at(rr2_buf, i)) {
+                       } else if (rr1_buf->_data[i] > rr2_buf->_data[i]) {
                                return +1;
                        }
                }
-       return 0;
+               return 0;
        }
 }
 
+/**
+ * Returns true of the given rr's are equal, where
+ * Also returns true if one records is a DS that represents the
+ * other DNSKEY record
+ */
+bool
+ldns_rr_compare_ds(const ldns_rr *rr1, const ldns_rr *rr2)
+{
+       bool result;
+       ldns_rr *ds_repr;
+
+       if (ldns_rr_get_type(rr1) == LDNS_RR_TYPE_DS &&
+           ldns_rr_get_type(rr2) == LDNS_RR_TYPE_DNSKEY) {
+               ds_repr = ldns_key_rr2ds(rr2);
+               result = (ldns_rr_compare(rr1, ds_repr) == 0);
+               ldns_rr_free(ds_repr);
+       } else if (ldns_rr_get_type(rr1) == LDNS_RR_TYPE_DNSKEY &&
+           ldns_rr_get_type(rr2) == LDNS_RR_TYPE_DS) {
+               ds_repr = ldns_key_rr2ds(rr1);
+               result = (ldns_rr_compare(rr2, ds_repr) == 0);
+               ldns_rr_free(ds_repr);
+       } else {
+               result = (ldns_rr_compare(rr1, rr2) == 0);
+       }       
+       return result;
+}
 
 /** 
  * calculate the uncompressed size of an RR