Added some const correctness.

diff --git a/host2wire.c b/host2wire.c
index 0341a2e62838497bb912a55d4c616a10217c42e2..560d415e9298ac9cea735c26cd3b20fbcc4c6812 100644 (file)
--- a/host2wire.c
+++ b/host2wire.c
@@ -37,7 +37,7 @@ ldns_dname2buffer_wire(ldns_buffer *buffer, ldns_rdf *name)
 }
 
 ldns_status
-ldns_rdf2buffer_wire(ldns_buffer *buffer, ldns_rdf *rdf)
+ldns_rdf2buffer_wire(ldns_buffer *buffer, const ldns_rdf *rdf)
 {
        if (ldns_buffer_reserve(buffer, ldns_rdf_size(rdf))) {
                ldns_buffer_write(buffer,
@@ -48,7 +48,7 @@ ldns_rdf2buffer_wire(ldns_buffer *buffer, ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rr2buffer_wire(ldns_buffer *buffer, ldns_rr *rr, int section)
+ldns_rr2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr, int section)
 {
        uint16_t i;
        uint16_t rdl_pos = 0;
@@ -139,8 +139,8 @@ ldns_rrsig2buffer_wire(ldns_buffer *buffer, ldns_rr *rr)
 /**
  * Copy the packet header data to the buffer in wire format
  */
-ldns_status
-ldns_hdr2buffer_wire(ldns_buffer *buffer, ldns_pkt *packet)
+static ldns_status
+ldns_hdr2buffer_wire(ldns_buffer *buffer, const ldns_pkt *packet)
 {
        uint8_t flags;
 
@@ -172,7 +172,7 @@ ldns_hdr2buffer_wire(ldns_buffer *buffer, ldns_pkt *packet)
  * Copy the packet data to the buffer in wire format
  */
 ldns_status
-ldns_pkt2buffer_wire(ldns_buffer *buffer, ldns_pkt *packet)
+ldns_pkt2buffer_wire(ldns_buffer *buffer, const ldns_pkt *packet)
 {
        ldns_rr_list *rr_list;
        uint16_t i;
@@ -222,7 +222,7 @@ ldns_pkt2buffer_wire(ldns_buffer *buffer, ldns_pkt *packet)
  * the function also returns NULL)
  */
 uint8_t *
-ldns_rdf2wire(ldns_rdf *rdf, size_t *result_size)
+ldns_rdf2wire(const ldns_rdf *rdf, size_t *result_size)
 {
        ldns_buffer *buffer = ldns_buffer_new(MAX_PACKETLEN);
        uint8_t *result = NULL;
@@ -247,7 +247,7 @@ ldns_rdf2wire(ldns_rdf *rdf, size_t *result_size)
  * are not put into the result
  */
 uint8_t *
-ldns_rr2wire(ldns_rr *rr, int section, size_t *result_size)
+ldns_rr2wire(const ldns_rr *rr, int section, size_t *result_size)
 {
        ldns_buffer *buffer = ldns_buffer_new(MAX_PACKETLEN);
        uint8_t *result = NULL;
@@ -269,7 +269,7 @@ ldns_rr2wire(ldns_rr *rr, int section, size_t *result_size)
  * the function also returns NULL)
  */
 uint8_t *
-ldns_pkt2wire(ldns_pkt *packet, size_t *result_size)
+ldns_pkt2wire(const ldns_pkt *packet, size_t *result_size)
 {
        ldns_buffer *buffer = ldns_buffer_new(MAX_PACKETLEN);
        uint8_t *result2 = NULL;

diff --git a/ldns/host2wire.h b/ldns/host2wire.h
index d17a882ca547d9d4283de424f4cb793937cd998c..cffa0a42ad07c62ee58f4c359a602937a5334de6 100644 (file)
--- a/ldns/host2wire.h
+++ b/ldns/host2wire.h
@@ -12,12 +12,13 @@
 
 #include "util.h"
 
-ldns_status ldns_rdf2buffer_wire(ldns_buffer *buffer, ldns_rdf *rdf);
-ldns_status ldns_rr2buffer_wire(ldns_buffer *buffer, ldns_rr *rr, int section);
-ldns_status ldns_pkt2buffer_wire(ldns_buffer *buffer, ldns_pkt *pkt);
+ldns_status ldns_rdf2buffer_wire(ldns_buffer *buffer, const ldns_rdf *rdf);
+ldns_status ldns_rr2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr,
+                               int section);
+ldns_status ldns_pkt2buffer_wire(ldns_buffer *buffer, const ldns_pkt *pkt);
 
-uint8_t *ldns_rdf2wire(ldns_rdf *rdf, size_t *result_size);
-uint8_t *ldns_rr2wire(ldns_rr *rr, int section, size_t *result_size);
-uint8_t *ldns_pkt2wire(ldns_pkt *pkt, size_t *result_size);
+uint8_t *ldns_rdf2wire(const ldns_rdf *rdf, size_t *result_size);
+uint8_t *ldns_rr2wire(const ldns_rr *rr, int section, size_t *result_size);
+uint8_t *ldns_pkt2wire(const ldns_pkt *pkt, size_t *result_size);
 
 #endif

diff --git a/ldns/packet.h b/ldns/packet.h
index 02d73e9538a85591dc60b2137ca3f9bf57d005a9..0835bb72eec37512f7b52bdd70506ab2bdbfe3eb 100644 (file)
--- a/ldns/packet.h
+++ b/ldns/packet.h
@@ -111,30 +111,30 @@ enum ldns_enum_pkt_type {
 typedef enum ldns_enum_pkt_type ldns_pkt_type;
 
 /* prototypes */
-uint16_t ldns_pkt_id(ldns_pkt *);
-bool ldns_pkt_qr(ldns_pkt *);
-bool ldns_pkt_aa(ldns_pkt *);
-bool ldns_pkt_tc(ldns_pkt *);
-bool ldns_pkt_rd(ldns_pkt *);
-bool ldns_pkt_cd(ldns_pkt *);
-bool ldns_pkt_ra(ldns_pkt *);
-bool ldns_pkt_ad(ldns_pkt *);
+uint16_t ldns_pkt_id(const ldns_pkt *);
+bool ldns_pkt_qr(const ldns_pkt *);
+bool ldns_pkt_aa(const ldns_pkt *);
+bool ldns_pkt_tc(const ldns_pkt *);
+bool ldns_pkt_rd(const ldns_pkt *);
+bool ldns_pkt_cd(const ldns_pkt *);
+bool ldns_pkt_ra(const ldns_pkt *);
+bool ldns_pkt_ad(const ldns_pkt *);
 bool ldns_pkt_set_flags(ldns_pkt *, uint16_t);
-uint8_t ldns_pkt_opcode(ldns_pkt *);
-uint8_t ldns_pkt_rcode(ldns_pkt *);
-uint16_t ldns_pkt_qdcount(ldns_pkt *);
-uint16_t ldns_pkt_ancount(ldns_pkt *);
-uint16_t ldns_pkt_nscount(ldns_pkt *);
-uint16_t ldns_pkt_arcount(ldns_pkt *);
-ldns_rdf *ldns_pkt_answerfrom(ldns_pkt *packet);
-char *ldns_pkt_when(ldns_pkt *packet);
-uint32_t ldns_pkt_querytime(ldns_pkt *);
-size_t ldns_pkt_size(ldns_pkt *);
+uint8_t ldns_pkt_opcode(const ldns_pkt *);
+uint8_t ldns_pkt_rcode(const ldns_pkt *);
+uint16_t ldns_pkt_qdcount(const ldns_pkt *);
+uint16_t ldns_pkt_ancount(const ldns_pkt *);
+uint16_t ldns_pkt_nscount(const ldns_pkt *);
+uint16_t ldns_pkt_arcount(const ldns_pkt *);
+ldns_rdf *ldns_pkt_answerfrom(const ldns_pkt *packet);
+char *ldns_pkt_when(const ldns_pkt *packet);
+uint32_t ldns_pkt_querytime(const ldns_pkt *);
+size_t ldns_pkt_size(const ldns_pkt *);
 
-ldns_rr_list *ldns_pkt_question(ldns_pkt *packet);
-ldns_rr_list *ldns_pkt_answer(ldns_pkt *packet);
-ldns_rr_list *ldns_pkt_authority(ldns_pkt *packet);
-ldns_rr_list *ldns_pkt_additional(ldns_pkt *packet);
+ldns_rr_list *ldns_pkt_question(const ldns_pkt *packet);
+ldns_rr_list *ldns_pkt_answer(const ldns_pkt *packet);
+ldns_rr_list *ldns_pkt_authority(const ldns_pkt *packet);
+ldns_rr_list *ldns_pkt_additional(const ldns_pkt *packet);
 
 void ldns_pkt_set_id(ldns_pkt *, uint16_t);
 void ldns_pkt_set_qr(ldns_pkt *, bool);

diff --git a/ldns/rdata.h b/ldns/rdata.h
index 477319b5761623c59da54bc029c61b8163d0deaa..2094624a844d72fe2ee8eca0f7766e69c9eb9ba0 100644 (file)
--- a/ldns/rdata.h
+++ b/ldns/rdata.h
@@ -94,19 +94,19 @@ struct ldns_struct_rdf
 typedef struct ldns_struct_rdf ldns_rdf;
 
 /* prototypes */
-uint16_t        ldns_rdf_size(ldns_rdf *);
+uint16_t        ldns_rdf_size(const ldns_rdf *);
 void            ldns_rdf_set_size(ldns_rdf *, uint16_t);
 void            ldns_rdf_set_type(ldns_rdf *, ldns_rdf_type);
 void            ldns_rdf_set_data(ldns_rdf *, void *);
-ldns_rdf_type   ldns_rdf_get_type(ldns_rdf *);
+ldns_rdf_type   ldns_rdf_get_type(const ldns_rdf *);
 ldns_rdf       *ldns_rdf_new(uint16_t, ldns_rdf_type, void *);
 ldns_rdf       *ldns_rdf_new_frm_data(uint16_t, ldns_rdf_type, void *);
 ldns_status     ldns_octet(char *word, size_t *length);
-uint8_t         *ldns_rdf_data(ldns_rdf *);
+uint8_t         *ldns_rdf_data(const ldns_rdf *);
 void            ldns_rdf_free(ldns_rdf *);
 void            ldns_rdf_free_data(ldns_rdf *);
 ldns_rdf       *ldns_rdf_new_frm_str(const char *, ldns_rdf_type);
 struct sockaddr_storage * ldns_rdf2native_sockaddr_storage(ldns_rdf *);
-ldns_rdf       *ldns_rdf_clone(ldns_rdf *);
+ldns_rdf       *ldns_rdf_clone(const ldns_rdf *);
 
 #endif /* !_LDNS_RDATA_H */

diff --git a/ldns/rr.h b/ldns/rr.h
index b762a9db4d0c9d81f19c9753b07030fa39bed990..d4df551d827a9c4ec62f600d852fde7b0f58397f 100644 (file)
--- a/ldns/rr.h
+++ b/ldns/rr.h
@@ -244,12 +244,12 @@ 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 *, uint16_t);
-ldns_rdf *ldns_rr_owner(ldns_rr *);
-uint32_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 *);
+ldns_rdf *ldns_rr_rdf(const ldns_rr *, uint16_t);
+ldns_rdf *ldns_rr_owner(const ldns_rr *);
+uint32_t ldns_rr_ttl(const ldns_rr *);
+uint16_t ldns_rr_rd_count(const ldns_rr *);
+ldns_rr_type ldns_rr_get_type(const ldns_rr *);
+ldns_rr_class ldns_rr_get_class(const ldns_rr *);
 void ldns_rr_free(ldns_rr *);
 
 uint16_t ldns_rr_list_rr_count(ldns_rr_list *);
@@ -263,9 +263,9 @@ const ldns_rr_descriptor *ldns_rr_descript(uint16_t);
 size_t ldns_rr_descriptor_minimum(const ldns_rr_descriptor *);
 size_t ldns_rr_descriptor_maximum(const ldns_rr_descriptor *);
 ldns_rdf_type ldns_rr_descriptor_field_type(const ldns_rr_descriptor *, size_t);
-ldns_rr_type ldns_rr_get_type_by_name(char *);
-ldns_rr_class ldns_get_class_by_name(char *);
-size_t ldns_rr_uncompressed_size(ldns_rr *);
+ldns_rr_type ldns_rr_get_type_by_name(const char *);
+ldns_rr_class ldns_get_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);
 void ldns_rr_list_sort(ldns_rr_list *);
 

diff --git a/packet.c b/packet.c
index fa50724d1ea73f78f26b7cd6c780c337b559998b..f5e1a504fca1d1b8c954f0d4f02a8d476a6dbb8c 100644 (file)
--- a/packet.c
+++ b/packet.c
@@ -25,174 +25,176 @@
 
 /* read */
 uint16_t
-ldns_pkt_id(ldns_pkt *packet)
+ldns_pkt_id(const ldns_pkt *packet)
 {
        return packet->_header->_id;
 }
 
 bool
-ldns_pkt_qr(ldns_pkt *packet)
+ldns_pkt_qr(const ldns_pkt *packet)
 {
        return packet->_header->_qr;
 }
 
 bool
-ldns_pkt_aa(ldns_pkt *packet)
+ldns_pkt_aa(const ldns_pkt *packet)
 {
        return packet->_header->_aa;
 }
 
 bool
-ldns_pkt_tc(ldns_pkt *packet)
+ldns_pkt_tc(const ldns_pkt *packet)
 {
        return packet->_header->_tc;
 }
 
 bool
-ldns_pkt_rd(ldns_pkt *packet)
+ldns_pkt_rd(const ldns_pkt *packet)
 {
        return packet->_header->_rd;
 }
 
 bool
-ldns_pkt_cd(ldns_pkt *packet)
+ldns_pkt_cd(const ldns_pkt *packet)
 {
        return packet->_header->_cd;
 }
 
 bool
-ldns_pkt_ra(ldns_pkt *packet)
+ldns_pkt_ra(const ldns_pkt *packet)
 {
        return packet->_header->_ra;
 }
 
 bool
-ldns_pkt_ad(ldns_pkt *packet)
+ldns_pkt_ad(const ldns_pkt *packet)
 {
        return packet->_header->_ad;
 }
 
 uint8_t
-ldns_pkt_opcode(ldns_pkt *packet)
+ldns_pkt_opcode(const ldns_pkt *packet)
 {
        return packet->_header->_opcode;
 }
 
 uint8_t
-ldns_pkt_rcode(ldns_pkt *packet)
+ldns_pkt_rcode(const ldns_pkt *packet)
 {
        return packet->_header->_rcode;
 }
 
 uint16_t
-ldns_pkt_qdcount(ldns_pkt *packet)
+ldns_pkt_qdcount(const ldns_pkt *packet)
 {
        return packet->_header->_qdcount;
 }
 
 uint16_t
-ldns_pkt_ancount(ldns_pkt *packet)
+ldns_pkt_ancount(const ldns_pkt *packet)
 {
        return packet->_header->_ancount;
 }
 
 uint16_t
-ldns_pkt_nscount(ldns_pkt *packet)
+ldns_pkt_nscount(const ldns_pkt *packet)
 {
        return packet->_header->_nscount;
 }
 
 uint16_t
-ldns_pkt_arcount(ldns_pkt *packet)
+ldns_pkt_arcount(const ldns_pkt *packet)
 {
        return packet->_header->_arcount;
 }
 
 ldns_rr_list *
-ldns_pkt_question(ldns_pkt *packet)
+ldns_pkt_question(const ldns_pkt *packet)
 {
        return packet->_question;
 }
 
 ldns_rr_list *
-ldns_pkt_answer(ldns_pkt *packet)
+ldns_pkt_answer(const ldns_pkt *packet)
 {
        return packet->_answer;
 }
 
 ldns_rr_list *
-ldns_pkt_authority(ldns_pkt *packet)
+ldns_pkt_authority(const ldns_pkt *packet)
 {
        return packet->_authority;
 }
 
 ldns_rr_list *
-ldns_pkt_additional(ldns_pkt *packet)
+ldns_pkt_additional(const ldns_pkt *packet)
 {
        return packet->_additional;
 }
 
 size_t
-ldns_pkt_size(ldns_pkt *packet)
+ldns_pkt_size(const ldns_pkt *packet)
 {
        return packet->_size;
 }
 
 uint32_t 
-ldns_pkt_querytime(ldns_pkt *packet)
+ldns_pkt_querytime(const ldns_pkt *packet)
 {
        return packet->_querytime;
 }
 
 ldns_rdf *
-ldns_pkt_answerfrom(ldns_pkt *packet)
+ldns_pkt_answerfrom(const ldns_pkt *packet)
 {
        return packet->_answerfrom;
 }
 
 char *
-ldns_pkt_when(ldns_pkt *packet)
+ldns_pkt_when(const ldns_pkt *packet)
 {
        return packet->_when;
 }
 
 uint16_t
-ldns_pkt_xxcount(ldns_pkt *packet, ldns_pkt_section s)
+ldns_pkt_xxcount(const ldns_pkt *packet, ldns_pkt_section s)
 {
        switch(s) {
-               case LDNS_SECTION_QUESTION:
-                       return ldns_pkt_qdcount(packet);
-               case LDNS_SECTION_ANSWER:
-                       return ldns_pkt_ancount(packet);
-               case LDNS_SECTION_AUTHORITY:
-                       return ldns_pkt_nscount(packet);
-               case LDNS_SECTION_ADDITIONAL:
-                       return ldns_pkt_arcount(packet);
-               case LDNS_SECTION_ANY:
-                       return ldns_pkt_qdcount(packet) +
-                               ldns_pkt_ancount(packet) +
-                               ldns_pkt_nscount(packet) +
-                               ldns_pkt_arcount(packet);
+       case LDNS_SECTION_QUESTION:
+               return ldns_pkt_qdcount(packet);
+       case LDNS_SECTION_ANSWER:
+               return ldns_pkt_ancount(packet);
+       case LDNS_SECTION_AUTHORITY:
+               return ldns_pkt_nscount(packet);
+       case LDNS_SECTION_ADDITIONAL:
+               return ldns_pkt_arcount(packet);
+       case LDNS_SECTION_ANY:
+               return ldns_pkt_qdcount(packet) +
+                       ldns_pkt_ancount(packet) +
+                       ldns_pkt_nscount(packet) +
+                       ldns_pkt_arcount(packet);
+       default:
+               abort();
        }
-       return 0;
 }
 
 ldns_rr_list *
 ldns_pkt_xxsection(ldns_pkt *packet, ldns_pkt_section s)
 {
        switch(s) {
-               case LDNS_SECTION_QUESTION:
-                       return ldns_pkt_question(packet);
-               case LDNS_SECTION_ANSWER:
-                       return ldns_pkt_answer(packet);
-               case LDNS_SECTION_AUTHORITY:
-                       return ldns_pkt_authority(packet);
-               case LDNS_SECTION_ADDITIONAL:
-                       return ldns_pkt_additional(packet);
-               case LDNS_SECTION_ANY:
-                       return 0;
+       case LDNS_SECTION_QUESTION:
+               return ldns_pkt_question(packet);
+       case LDNS_SECTION_ANSWER:
+               return ldns_pkt_answer(packet);
+       case LDNS_SECTION_AUTHORITY:
+               return ldns_pkt_authority(packet);
+       case LDNS_SECTION_ADDITIONAL:
+               return ldns_pkt_additional(packet);
+       case LDNS_SECTION_ANY:
+               return NULL;
+       default:
+               abort();
        }
-       return NULL;
 }
 
 /* write */

diff --git a/rdata.c b/rdata.c
index d5956b1942c048ae7207c5a3a2a2dc6c9455ab47..3d94fb649e08843770f7f67087a5317e75af33a0 100644 (file)
--- a/rdata.c
+++ b/rdata.c
@@ -31,19 +31,19 @@
 
 /* read */
 uint16_t
-ldns_rdf_size(ldns_rdf *rd)
+ldns_rdf_size(const ldns_rdf *rd)
 {
        return rd->_size;
 }
 
 ldns_rdf_type
-ldns_rdf_get_type(ldns_rdf *rd)
+ldns_rdf_get_type(const ldns_rdf *rd)
 {
        return rd->_type;
 }
 
 uint8_t *
-ldns_rdf_data(ldns_rdf *rd)
+ldns_rdf_data(const ldns_rdf *rd)
 {
        return rd->_data;
 }
@@ -220,7 +220,7 @@ ldns_rdf_new_frm_data(uint16_t s, ldns_rdf_type t, void *buf)
  * \return a new rdf structure
  */
 ldns_rdf *
-ldns_rdf_clone(ldns_rdf *r)
+ldns_rdf_clone(const ldns_rdf *r)
 {
        return (ldns_rdf_new_frm_data(
                                ldns_rdf_size(r), 

diff --git a/rr.c b/rr.c
index df5496d78ef345055dcdddb9a07cd986abf1df97..3ec8b013ac1e7efc0f26500eddeca3dbfb1ccaa2 100644 (file)
--- a/rr.c
+++ b/rr.c
@@ -155,7 +155,7 @@ ldns_rr_push_rdf(ldns_rr *rr, ldns_rdf *f)
  * \return ldns_rdf *
  */
 ldns_rdf *
-ldns_rr_rdf(ldns_rr *rr, uint16_t nr)
+ldns_rr_rdf(const ldns_rr *rr, uint16_t nr)
 {
        if (nr < ldns_rr_rd_count(rr)) {
                return rr->_rdata_fields[nr];
@@ -170,7 +170,7 @@ ldns_rr_rdf(ldns_rr *rr, uint16_t nr)
  * \return ldns_rdf * 
  */
 ldns_rdf *
-ldns_rr_owner(ldns_rr *rr)
+ldns_rr_owner(const ldns_rr *rr)
 {
        return rr->_owner;
 }
@@ -179,7 +179,7 @@ ldns_rr_owner(ldns_rr *rr)
  * return the owner name of an rr structure
  */
 uint32_t
-ldns_rr_ttl(ldns_rr *rr)
+ldns_rr_ttl(const ldns_rr *rr)
 {
        return rr->_ttl;
 }
@@ -188,7 +188,7 @@ ldns_rr_ttl(ldns_rr *rr)
  * return the rd_count of an rr structure
  */
 uint16_t
-ldns_rr_rd_count(ldns_rr *rr)
+ldns_rr_rd_count(const ldns_rr *rr)
 {
        return rr->_rd_count;
 }
@@ -197,7 +197,7 @@ ldns_rr_rd_count(ldns_rr *rr)
  * Returns the type of the rr
  */
 ldns_rr_type
-ldns_rr_get_type(ldns_rr *rr)
+ldns_rr_get_type(const ldns_rr *rr)
 {
         return rr->_rr_type;
 }
@@ -206,7 +206,7 @@ ldns_rr_get_type(ldns_rr *rr)
  * Returns the class of the rr
  */
 ldns_rr_class
-ldns_rr_get_class(ldns_rr *rr)
+ldns_rr_get_class(const ldns_rr *rr)
 {
         return rr->_rr_class;
 }
@@ -555,7 +555,7 @@ ldns_rr_descriptor_field_type(const ldns_rr_descriptor *descriptor,
 }
 
 ldns_rr_type
-ldns_rr_get_type_by_name(char *name)
+ldns_rr_get_type_by_name(const char *name)
 {
        unsigned int i;
        const char *desc_name;
@@ -596,7 +596,7 @@ ldns_rr_get_type_by_name(char *name)
 }
 
 ldns_rr_class
-ldns_get_class_by_name(char *name)
+ldns_get_class_by_name(const char *name)
 {
        ldns_lookup_table *lt;
        
@@ -694,7 +694,7 @@ ldns_rr_compare(const ldns_rr *rr1, const ldns_rr *rr2)
  * \return size of the rr
  */
 size_t
-ldns_rr_uncompressed_size(ldns_rr *r)
+ldns_rr_uncompressed_size(const ldns_rr *r)
 {
        size_t rrsize;
        uint16_t i;