if-i-don't-commit-now-conflicts-will-set-us-up-the-bomb commit

added access functions for rr and rrset and packet
more host2str functionality
more wire2host functionality

diff --git a/host2str.c b/host2str.c
index ec5b9edd58b23889b6dec78c8761dcab93561070..198d2b055be1dd6fae130abbf24c1283e53a27e8 100644 (file)
--- a/host2str.c
+++ b/host2str.c
@@ -255,9 +255,12 @@ ldns_pktheader2buffer(ldns_buffer *output, ldns_pkt *pkt)
        return LDNS_STATUS_OK;
 }
 
+/* TODO check status returns */
+
 ldns_status
 ldns_pkt2buffer(ldns_buffer *output, ldns_pkt *pkt)
 {
+       uint16_t i;
        ldns_status status = LDNS_STATUS_OK;
        
        status = ldns_pktheader2buffer(output, pkt);
@@ -266,6 +269,34 @@ ldns_pkt2buffer(ldns_buffer *output, ldns_pkt *pkt)
                printf("error in pkt2buf %d\n", status);
        }
        
+       ldns_buffer_printf(output, ";; QUESTION SECTION:\n;; ");
+       for (i = 0; i < ldns_pkt_qdcount(pkt); i++) {
+               status = ldns_rr2buffer(output, 
+                              ldns_rrset_rr(ldns_pkt_question(pkt), i));
+               ldns_buffer_printf(output, "\n");
+       }
+       
+       ldns_buffer_printf(output, ";; ANSWER SECTION:\n");
+       for (i = 0; i < ldns_pkt_ancount(pkt); i++) {
+               status = ldns_rr2buffer(output, 
+                              ldns_rrset_rr(ldns_pkt_answer(pkt), i));
+               ldns_buffer_printf(output, "\n");
+       }
+       
+       ldns_buffer_printf(output, ";; AUTHORITY SECTION:\n");
+       for (i = 0; i < ldns_pkt_nscount(pkt); i++) {
+               status = ldns_rr2buffer(output, 
+                              ldns_rrset_rr(ldns_pkt_authority(pkt), i));
+               ldns_buffer_printf(output, "\n");
+       }
+       
+       ldns_buffer_printf(output, ";; ADDITIONAL SECTION:\n");
+       for (i = 0; i < ldns_pkt_arcount(pkt); i++) {
+               status = ldns_rr2buffer(output, 
+                              ldns_rrset_rr(ldns_pkt_additional(pkt), i));
+               ldns_buffer_printf(output, "\n");
+       }
+       
        return status;
 }
 

diff --git a/ldns/packet.h b/ldns/packet.h
index 1ef39500ade14535244c0355b857987d01f573d9..8f7d3615335198afdceb3d4d8d1c5a03c6887e1a 100644 (file)
--- a/ldns/packet.h
+++ b/ldns/packet.h
@@ -102,6 +102,11 @@ uint16_t ldns_pkt_ancount(ldns_pkt *);
 uint16_t ldns_pkt_nscount(ldns_pkt *);
 uint16_t ldns_pkt_arcount(ldns_pkt *);
 
+ldns_rrset *ldns_pkt_question(ldns_pkt *packet);
+ldns_rrset *ldns_pkt_answer(ldns_pkt *packet);
+ldns_rrset *ldns_pkt_authority(ldns_pkt *packet);
+ldns_rrset *ldns_pkt_additional(ldns_pkt *packet);
+
 void ldns_pkt_set_id(ldns_pkt *, uint16_t);
 void ldns_pkt_set_qr(ldns_pkt *, bool);
 void ldns_pkt_set_aa(ldns_pkt *, bool);

diff --git a/ldns/rdata.h b/ldns/rdata.h
index dfd81fca7af9aea6cc44fdcff64a02292f565e94..33b5e2eb86cb92b3f44bc31ce57c9909f6ec7890 100644 (file)
--- a/ldns/rdata.h
+++ b/ldns/rdata.h
@@ -109,6 +109,6 @@ void            ldns_rdf_set_data(ldns_rdf *, uint8_t *);
 ldns_rdf_type   ldns_rdf_get_type(ldns_rdf *);
 ldns_rdf       *ldns_rdf_new(uint16_t, ldns_rdf_type, uint8_t *);
 uint8_t         *ldns_rdf_data(ldns_rdf *);
-void            ldns_rdf_destroy(ldns_rdf *);
+void            ldns_rdf_free(ldns_rdf *);
 
 #endif /* !_LDNS_RDATA_H */

diff --git a/ldns/rr.h b/ldns/rr.h
index a3fc16e1d1785a139e9695a39c683fcd2e8b9d5e..0a3641119b81876339b0c992b5b00787967ff44f 100644 (file)
--- a/ldns/rr.h
+++ b/ldns/rr.h
@@ -177,8 +177,8 @@ typedef struct ldns_struct_rr ldns_rr;
  */
 struct ldns_struct_rrset
 {
-       ldns_rr *rrs;
-
+       uint16_t _rr_count;
+       ldns_rr **_rrs;
 };
 typedef struct ldns_struct_rrset ldns_rrset;
 
@@ -208,12 +208,19 @@ void ldns_rr_set_rd_count(ldns_rr *, uint16_t);
 void ldns_rr_set_type(ldns_rr *, ldns_rr_type);
 void ldns_rr_set_class(ldns_rr *, ldns_rr_class);
 bool ldns_rr_push_rdf(ldns_rr *, ldns_rdf *);
+ldns_rdf *ldns_rr_rdf(ldns_rr *rr, uint16_t nr);
 ldns_rdf *ldns_rr_owner(ldns_rr *);
 uint8_t ldns_rr_ttl(ldns_rr *);
 uint16_t ldns_rr_rd_count(ldns_rr *);
 ldns_rr_type ldns_rr_get_type(ldns_rr *);
 ldns_rr_class ldns_rr_get_class(ldns_rr *);
 
+uint16_t ldns_rrset_rr_count(ldns_rrset *rrset);
+void ldns_rrset_set_rr_count(ldns_rrset *rrset, uint16_t count);
+ldns_rr *ldns_rrset_rr(ldns_rrset *rrset, uint16_t nr);
+ldns_rrset *ldns_rrset_new();
+void ldns_rrset_free(ldns_rrset *rrset);
+bool ldns_rrset_push_rr(ldns_rrset *rrset, ldns_rr *rr);
 
 const ldns_rr_descriptor *ldns_rr_descript(uint16_t type);
 size_t ldns_rr_descriptor_minimum(const ldns_rr_descriptor *descriptor);

diff --git a/packet.c b/packet.c
index ef9889cd50600791ab2423e482ecfe9299f3fba4..5528e54f793d25430805f91247f998c9eed0b56c 100644 (file)
--- a/packet.c
+++ b/packet.c
@@ -105,6 +105,30 @@ ldns_pkt_arcount(ldns_pkt *packet)
        return packet->_header->_arcount;
 }
 
+ldns_rrset *
+ldns_pkt_question(ldns_pkt *packet)
+{
+       return packet->_question;
+}
+
+ldns_rrset *
+ldns_pkt_answer(ldns_pkt *packet)
+{
+       return packet->_answer;
+}
+
+ldns_rrset *
+ldns_pkt_authority(ldns_pkt *packet)
+{
+       return packet->_authority;
+}
+
+ldns_rrset *
+ldns_pkt_additional(ldns_pkt *packet)
+{
+       return packet->_additional;
+}
+
 
 /* write */
 void
@@ -210,10 +234,10 @@ ldns_pkt_new()
                return NULL;
        }
 
-       packet->_question = NULL;
-       packet->_answer = NULL;
-       packet->_authority = NULL;
-       packet->_additional = NULL;
+       packet->_question = ldns_rrset_new();
+       packet->_answer = ldns_rrset_new();
+       packet->_authority = ldns_rrset_new();
+       packet->_additional = ldns_rrset_new();
        return packet;
 }
 

diff --git a/rdata.c b/rdata.c
index 6ec3bf88649436e7bde1f24d2dc2e3f20f62e7dc..788e31c7aa815615f9a364a3faeb598df1c7d4e4 100644 (file)
--- a/rdata.c
+++ b/rdata.c
@@ -80,10 +80,9 @@ ldns_rdf_new(uint16_t s, ldns_rdf_type t, uint8_t *d)
 }
 
 void 
-ldns_rdf_destroy(ldns_rdf *rd)
+ldns_rdf_free(ldns_rdf *rd)
 {
-       rd = NULL; /* kuch */
-       /* empty */
+       FREE(rd);
 }
 
 /**

diff --git a/rr.c b/rr.c
index 9b7feaa4df3450e566cd75dd5f07a0e35f465644..cc3d51f2e6dc3ccbc14ba1a0bfdd330b1693fdc5 100644 (file)
--- a/rr.c
+++ b/rr.c
@@ -35,6 +35,22 @@ ldns_rr_new(void)
         return rr;
 }
 
+/**
+ * Frees the rr structure TODO
+ */
+void
+ldns_rr_free(ldns_rr *rr)
+{
+       uint16_t i;
+       for (i = 0; i < ldns_rr_rd_count(rr); i++) {
+               ldns_rdf_free(ldns_rr_rdf(rr, i));
+       }
+       /*
+       FREE(ldns_rr_owner(rr));
+       */
+       FREE(rr);
+}
+
 /**
  * set the owner in the rr structure
  */
@@ -107,6 +123,19 @@ ldns_rr_push_rdf(ldns_rr *rr, ldns_rdf *f)
        return true;
 }
 
+/**
+ *
+ */
+ldns_rdf *
+ldns_rr_rdf(ldns_rr *rr, uint16_t nr)
+{
+       if (nr < ldns_rr_rd_count(rr)) {
+               return rr->_rdata_fields[nr];
+       } else {
+               return NULL;
+       }
+}
+
 /**
  * return the owner name of an rr structure
  */
@@ -152,6 +181,75 @@ ldns_rr_get_class(ldns_rr *rr)
         return rr->_rr_class;
 }
 
+/* rrsets */
+
+uint16_t
+ldns_rrset_rr_count(ldns_rrset *rrset)
+{
+       return rrset->_rr_count;
+}
+
+void
+ldns_rrset_set_rr_count(ldns_rrset *rrset, uint16_t count)
+{
+       rrset->_rr_count = count;
+}
+
+ldns_rr *
+ldns_rrset_rr(ldns_rrset *rrset, uint16_t nr)
+{
+       if (nr < ldns_rrset_rr_count(rrset)) {
+               return rrset->_rrs[nr];
+       } else {
+               return NULL;
+       }
+}
+
+ldns_rrset *
+ldns_rrset_new()
+{
+       ldns_rrset *rrset = MALLOC(ldns_rrset);
+       rrset->_rr_count = 0;
+       rrset->_rrs = NULL;
+       
+       return rrset;
+}
+
+void
+ldns_rrset_free(ldns_rrset *rrset)
+{
+       uint16_t i;
+       
+       for (i=0; i < ldns_rrset_rr_count(rrset); i++) {
+               ldns_rr_free(ldns_rrset_rr(rrset, i));
+       }
+       
+       FREE(rrset);
+}
+
+bool
+ldns_rrset_push_rr(ldns_rrset *rrset, ldns_rr *rr)
+{
+       uint16_t rr_count;
+       ldns_rr **rrs;
+       
+       rr_count = ldns_rrset_rr_count(rrset);
+       
+       /* grow the array */
+       rrs = XREALLOC(
+               rrset->_rrs, ldns_rr *, rr_count + 1);
+       if (!rrs) {
+               return false;
+       }
+       
+       /* add the new member */
+       rrset->_rrs = rrs;
+       rrset->_rrs[rr_count] = rr;
+
+       ldns_rrset_set_rr_count(rrset, rr_count + 1);
+       return true;
+
+}
 
 static const ldns_rdf_type type_0_wireformat[] = { LDNS_RDF_TYPE_UNKNOWN };
 static const ldns_rdf_type type_a_wireformat[] = { LDNS_RDF_TYPE_A };

diff --git a/wire2host.c b/wire2host.c
index 61e523d80e57663913fa19c1444b846ec16a47bc..5e88becf1536f5856f1abb3fc57b412fcbc575d6 100644 (file)
--- a/wire2host.c
+++ b/wire2host.c
@@ -425,21 +425,33 @@ ldns_wire2pkt(ldns_pkt **packet_p, const uint8_t *wire, size_t max)
        for (i = 0; i < ldns_pkt_qdcount(packet); i++) {
                status = ldns_wire2rr(&rr, wire, max, &pos,
                                      LDNS_SECTION_QUESTION);
+               if (!ldns_rrset_push_rr(ldns_pkt_question(packet), rr)) {
+                       return LDNS_STATUS_INTERNAL_ERR;
+               }
                STATUS_CHECK_GOTO(status, status_error);
        }
        for (i = 0; i < ldns_pkt_ancount(packet); i++) {
                status = ldns_wire2rr(&rr, wire, max, &pos,
                                      LDNS_SECTION_ANSWER);
+               if (!ldns_rrset_push_rr(ldns_pkt_answer(packet), rr)) {
+                       return LDNS_STATUS_INTERNAL_ERR;
+               }
                STATUS_CHECK_GOTO(status, status_error);
        }
        for (i = 0; i < ldns_pkt_nscount(packet); i++) {
                status = ldns_wire2rr(&rr, wire, max, &pos,
                                      LDNS_SECTION_AUTHORITY);
+               if (!ldns_rrset_push_rr(ldns_pkt_authority(packet), rr)) {
+                       return LDNS_STATUS_INTERNAL_ERR;
+               }
                STATUS_CHECK_GOTO(status, status_error);
        }
        for (i = 0; i < ldns_pkt_arcount(packet); i++) {
                status = ldns_wire2rr(&rr, wire, max, &pos,
                                      LDNS_SECTION_ADDITIONAL);
+               if (!ldns_rrset_push_rr(ldns_pkt_additional(packet), rr)) {
+                       return LDNS_STATUS_INTERNAL_ERR;
+               }
                STATUS_CHECK_GOTO(status, status_error);
        }