From: Miek Gieben <miekg@NLnetLabs.nl>
Date: Wed, 8 Feb 2006 08:28:35 +0000 (+0000)
Subject: const updates (we're almost)
X-Git-Tag: release-1.1.0~363
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=7976a11aeebb95fa7ac4398b3a4cd93aa5ceaaf9;p=thirdparty%2Fldns.git

const updates (we're almost)
updated/added documentation
coding style fixes and deleted #ifdef'd code
---

diff --git a/TODO b/TODO
index ab5c4370..6da0a451 100644
--- a/TODO
+++ b/TODO
@@ -15,10 +15,13 @@ Post 1.0 Stuff:
         o refactor ldns_verify_rrsig_keylist and
           ldns_verify_rrsig (fold in TSIG stuff or leave it out?)
         o Different digest for DS (spec currently specifies SHA-1)
+        o zone.c; make it better/faster??
+        o SHA256 test in configure.ac
 
         Minor:
         ------
         o Check RedHat 9 Compile problem
+        o lua bindings?
 
 
 1.1.0:
@@ -29,8 +32,6 @@ Post 1.0 Stuff:
 	o API cleanup: add missing consts in function arguments
         o vim syntax
         o walker 
-        o zone.c; make it better/faster??
-        o SHA256 test in configure.ac
 
 DONE:
 1.0.1 released 5 January 2006
diff --git a/dnssec.c b/dnssec.c
index 8632790f..a4e4334c 100644
--- a/dnssec.c
+++ b/dnssec.c
@@ -27,7 +27,7 @@
 
 /* used only on the public key RR */
 uint16_t
-ldns_calc_keytag(ldns_rr *key)
+ldns_calc_keytag(const ldns_rr *key)
 {
 	unsigned int i;
 	uint32_t ac32;
diff --git a/host2str.c b/host2str.c
index c15af348..daad7aa2 100644
--- a/host2str.c
+++ b/host2str.c
@@ -83,7 +83,7 @@ ldns_lookup_table ldns_opcodes[] = {
 
 /* do NOT pass compressed data here :p */
 ldns_status
-ldns_rdf2buffer_str_dname(ldns_buffer *output, ldns_rdf *dname)
+ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname)
 {
 	/* can we do with 1 pos var? or without at all? */
 	uint8_t src_pos = 0;
@@ -129,7 +129,7 @@ ldns_rdf2buffer_str_dname(ldns_buffer *output, ldns_rdf *dname)
 }
 
 ldns_status
-ldns_rdf2buffer_str_int8(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_int8(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	uint8_t data = ldns_rdf_data(rdf)[0];
 	ldns_buffer_printf(output, "%lu", (unsigned long) data);
@@ -137,7 +137,7 @@ ldns_rdf2buffer_str_int8(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rdf2buffer_str_int16(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
 	ldns_buffer_printf(output, "%lu", (unsigned long) data);
@@ -145,7 +145,7 @@ ldns_rdf2buffer_str_int16(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rdf2buffer_str_int32(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_int32(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
 	ldns_buffer_printf(output, "%lu", (unsigned long) data);
@@ -153,7 +153,7 @@ ldns_rdf2buffer_str_int32(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rdf2buffer_str_time(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_time(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	/* create a YYYYMMDDHHMMSS string if possible */
 	uint32_t data = ldns_read_uint32(ldns_rdf_data(rdf));
@@ -173,7 +173,7 @@ ldns_rdf2buffer_str_time(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rdf2buffer_str_a(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	char str[INET_ADDRSTRLEN];
 	
@@ -184,7 +184,7 @@ ldns_rdf2buffer_str_a(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rdf2buffer_str_aaaa(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	char str[INET6_ADDRSTRLEN];
 
@@ -196,7 +196,7 @@ ldns_rdf2buffer_str_aaaa(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rdf2buffer_str_str(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	const uint8_t *data = ldns_rdf_data(rdf);
 	uint8_t length = data[0];
@@ -219,7 +219,7 @@ ldns_rdf2buffer_str_str(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rdf2buffer_str_b64(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	size_t size = b64_ntop_calculate_size(ldns_rdf_size(rdf));
 	char *b64 = LDNS_XMALLOC(char, size);
@@ -231,7 +231,7 @@ ldns_rdf2buffer_str_b64(ldns_buffer *output, ldns_rdf *rdf)
 }	
 
 ldns_status
-ldns_rdf2buffer_str_hex(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	size_t i;
 	for (i = 0; i < ldns_rdf_size(rdf); i++) {
@@ -242,7 +242,7 @@ ldns_rdf2buffer_str_hex(ldns_buffer *output, ldns_rdf *rdf)
 }	
 
 ldns_status
-ldns_rdf2buffer_str_type(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf)
 {
         uint16_t data = ldns_read_uint16(ldns_rdf_data(rdf));
 	const ldns_rr_descriptor *descriptor;
@@ -257,7 +257,7 @@ ldns_rdf2buffer_str_type(ldns_buffer *output, ldns_rdf *rdf)
 }	
 
 ldns_status
-ldns_rdf2buffer_str_class(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf)
 {
         uint8_t data = ldns_rdf_data(rdf)[0];
 	ldns_lookup_table *lt;
@@ -272,7 +272,7 @@ ldns_rdf2buffer_str_class(ldns_buffer *output, ldns_rdf *rdf)
 }	
 
 ldns_status
-ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf)
 {
         uint8_t data = ldns_rdf_data(rdf)[0];
 	ldns_lookup_table *lt;
@@ -287,7 +287,7 @@ ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, ldns_rdf *rdf)
 }	
 
 ldns_status
-ldns_rdf2buffer_str_alg(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf)
 {
         uint8_t data = ldns_rdf_data(rdf)[0];
 	ldns_lookup_table *lt;
@@ -302,7 +302,7 @@ ldns_rdf2buffer_str_alg(ldns_buffer *output, ldns_rdf *rdf)
 }	
 
 ldns_status
-ldns_rdf2buffer_str_loc(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	/* we could do checking (ie degrees < 90 etc)? */
 	uint8_t version = ldns_rdf_data(rdf)[0];
@@ -399,21 +399,21 @@ ldns_rdf2buffer_str_loc(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rdf2buffer_str_unknown(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	ldns_buffer_printf(output, "\\# %u ", ldns_rdf_size(rdf));
 	return ldns_rdf2buffer_str_hex(output, rdf);
 }
 
 ldns_status
-ldns_rdf2buffer_str_nsap(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	ldns_buffer_printf(output, "0x");
 	return ldns_rdf2buffer_str_hex(output, rdf);
 }
 
 ldns_status
-ldns_rdf2buffer_str_wks(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	/* protocol, followed by bitmap of services */
 	struct protoent *protocol;
@@ -453,7 +453,7 @@ ldns_rdf2buffer_str_wks(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rdf2buffer_str_nsec(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	/* Note: this code is duplicated in higher.c in 
 	 * ldns_nsec_type_check() function
@@ -491,7 +491,7 @@ ldns_rdf2buffer_str_nsec(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rdf2buffer_str_period(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	/* period is the number of seconds */
 	uint32_t p = ldns_read_uint32(ldns_rdf_data(rdf));
@@ -500,7 +500,7 @@ ldns_rdf2buffer_str_period(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rdf2buffer_str_tsigtime(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_tsigtime(ldns_buffer *output,const  ldns_rdf *rdf)
 {
 	/* tsigtime is 48 bits network order unsigned integer */
 	uint64_t tsigtime = 0;
@@ -521,7 +521,7 @@ ldns_rdf2buffer_str_tsigtime(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rdf2buffer_str_apl(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	uint8_t *data = ldns_rdf_data(rdf);
 	uint16_t address_family = ldns_read_uint16(data);
@@ -588,16 +588,16 @@ ldns_rdf2buffer_str_apl(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rdf2buffer_str_int16_data(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	/* Subtract the size (2) of the number that specifies the length */
 	size_t size = b64_ntop_calculate_size(ldns_rdf_size(rdf) - 2);
 	char *b64 = LDNS_XMALLOC(char, size);
 
-	ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf)-2);
+	ldns_buffer_printf(output, "%u ", ldns_rdf_size(rdf) - 2);
 	
 	if (ldns_rdf_size(rdf) > 2 &&
-	    b64_ntop(ldns_rdf_data(rdf)+2, ldns_rdf_size(rdf)-2, b64, size)) {
+	    b64_ntop(ldns_rdf_data(rdf) + 2, ldns_rdf_size(rdf) - 2, b64, size)) {
 		ldns_buffer_printf(output, "%s", b64);
 	}
 	LDNS_FREE(b64);
@@ -605,7 +605,7 @@ ldns_rdf2buffer_str_int16_data(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	/* wire format from 
 	   http://www.ietf.org/internet-drafts/draft-ietf-ipseckey-rr-12.txt
@@ -673,7 +673,7 @@ ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, ldns_rdf *rdf)
 }
 
 ldns_status 
-ldns_rdf2buffer_str_tsig(ldns_buffer *output, ldns_rdf *rdf)
+ldns_rdf2buffer_str_tsig(ldns_buffer *output, const ldns_rdf *rdf)
 {
 	/* TSIG RRs have no presentation format, make them #size <data> */
 	return ldns_rdf2buffer_str_unknown(output, rdf);
@@ -681,7 +681,7 @@ ldns_rdf2buffer_str_tsig(ldns_buffer *output, ldns_rdf *rdf)
 
 
 ldns_status
-ldns_rdf2buffer_str(ldns_buffer *buffer, ldns_rdf *rdf)
+ldns_rdf2buffer_str(ldns_buffer *buffer, const ldns_rdf *rdf)
 {
 	ldns_status res;
 
@@ -774,7 +774,7 @@ ldns_rdf2buffer_str(ldns_buffer *buffer, ldns_rdf *rdf)
 }
 
 ldns_status
-ldns_rr2buffer_str(ldns_buffer *output, ldns_rr *rr)
+ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr)
 {
 	uint16_t i;
 	ldns_status status = LDNS_STATUS_OK;
@@ -876,7 +876,7 @@ ldns_rr2buffer_str(ldns_buffer *output, ldns_rr *rr)
 }
 
 ldns_status
-ldns_rr_list2buffer_str(ldns_buffer *output, ldns_rr_list *list)
+ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list)
 {
 	uint16_t i;
 
@@ -887,7 +887,7 @@ ldns_rr_list2buffer_str(ldns_buffer *output, ldns_rr_list *list)
 }
 
 ldns_status
-ldns_pktheader2buffer_str(ldns_buffer *output, ldns_pkt *pkt)
+ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
 {
 	ldns_lookup_table *opcode = ldns_lookup_by_id(ldns_opcodes,
 			                    (int) ldns_pkt_get_opcode(pkt));
@@ -938,7 +938,7 @@ ldns_pktheader2buffer_str(ldns_buffer *output, ldns_pkt *pkt)
 }
 
 ldns_status
-ldns_pkt2buffer_str(ldns_buffer *output, ldns_pkt *pkt)
+ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt)
 {
 	uint16_t i;
 	ldns_status status = LDNS_STATUS_OK;
@@ -1042,7 +1042,7 @@ ldns_pkt2buffer_str(ldns_buffer *output, ldns_pkt *pkt)
 }
 
 ldns_status
-ldns_key2buffer_str(ldns_buffer *output, ldns_key *k)
+ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k)
 {
 	ldns_status status = LDNS_STATUS_OK;
 	unsigned char  *bignum;
@@ -1272,7 +1272,7 @@ buffer2str(ldns_buffer *buffer)
 }
 
 char *
-ldns_rdf2str(ldns_rdf *rdf)
+ldns_rdf2str(const ldns_rdf *rdf)
 {
 	char *result = NULL;
 	ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
@@ -1287,7 +1287,7 @@ ldns_rdf2str(ldns_rdf *rdf)
 }
 
 char *
-ldns_rr2str(ldns_rr *rr)
+ldns_rr2str(const ldns_rr *rr)
 {
 	char *result = NULL;
 	ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
@@ -1302,7 +1302,7 @@ ldns_rr2str(ldns_rr *rr)
 }
 
 char *
-ldns_pkt2str(ldns_pkt *pkt)
+ldns_pkt2str(const ldns_pkt *pkt)
 {
 	char *result = NULL;
 	ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
@@ -1317,7 +1317,7 @@ ldns_pkt2str(ldns_pkt *pkt)
 }
 
 char *
-ldns_key2str(ldns_key *k)
+ldns_key2str(const ldns_key *k)
 {
 	char *result = NULL;
 	ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN);
@@ -1330,7 +1330,7 @@ ldns_key2str(ldns_key *k)
 }
 
 char *
-ldns_rr_list2str(ldns_rr_list *list)
+ldns_rr_list2str(const ldns_rr_list *list)
 {
 	char *result = NULL;
 	ldns_buffer *tmp_buffer = ldns_buffer_new(LDNS_MIN_BUFLEN); 
@@ -1349,7 +1349,7 @@ ldns_rr_list2str(ldns_rr_list *list)
 }
 
 void
-ldns_rdf_print(FILE *output, ldns_rdf *rdf)
+ldns_rdf_print(FILE *output, const ldns_rdf *rdf)
 {
 	char *str = ldns_rdf2str(rdf);
 	if (str) {
@@ -1361,7 +1361,7 @@ ldns_rdf_print(FILE *output, ldns_rdf *rdf)
 }
 
 void
-ldns_rr_print(FILE *output, ldns_rr *rr)
+ldns_rr_print(FILE *output, const ldns_rr *rr)
 {
 	char *str = ldns_rr2str(rr);
 	if (str) {
@@ -1373,7 +1373,7 @@ ldns_rr_print(FILE *output, ldns_rr *rr)
 }
 
 void
-ldns_pkt_print(FILE *output, ldns_pkt *pkt)
+ldns_pkt_print(FILE *output, const ldns_pkt *pkt)
 {
 	char *str = ldns_pkt2str(pkt);
 	if (str) {
@@ -1385,7 +1385,7 @@ ldns_pkt_print(FILE *output, ldns_pkt *pkt)
 }
 
 void
-ldns_rr_list_print(FILE *output, ldns_rr_list *lst)
+ldns_rr_list_print(FILE *output, const ldns_rr_list *lst)
 {
 	char *str = ldns_rr_list2str(lst);
 	if (str) {
@@ -1397,7 +1397,7 @@ ldns_rr_list_print(FILE *output, ldns_rr_list *lst)
 }
 
 void
-ldns_resolver_print(FILE *output, ldns_resolver *r)
+ldns_resolver_print(FILE *output, const ldns_resolver *r)
 {
 	uint16_t i;
 	ldns_rdf **n;
@@ -1431,7 +1431,7 @@ ldns_resolver_print(FILE *output, ldns_resolver *r)
 }
 
 void
-ldns_zone_print(FILE *output, ldns_zone *z)
+ldns_zone_print(FILE *output, const ldns_zone *z)
 {
 	ldns_rr_print(output, ldns_zone_soa(z));
 	ldns_rr_list_print(output, ldns_zone_rrs(z));
diff --git a/host2wire.c b/host2wire.c
index a391a9e6..660a876d 100644
--- a/host2wire.c
+++ b/host2wire.c
@@ -24,7 +24,7 @@
 */
 
 ldns_status
-ldns_dname2buffer_wire(ldns_buffer *buffer, ldns_rdf *name)
+ldns_dname2buffer_wire(ldns_buffer *buffer, const ldns_rdf *name)
 {
 	if (ldns_buffer_reserve(buffer, ldns_rdf_size(name))) {
 		ldns_buffer_write(buffer,
@@ -47,7 +47,7 @@ ldns_rdf2buffer_wire(ldns_buffer *buffer, const ldns_rdf *rdf)
 
 /* convert a rr list to wireformat */
 ldns_status
-ldns_rr_list2buffer_wire(ldns_buffer *buffer, ldns_rr_list *rr_list)
+ldns_rr_list2buffer_wire(ldns_buffer *buffer,const ldns_rr_list *rr_list)
 {
 	uint16_t rr_count;
 	uint16_t i;
@@ -99,7 +99,7 @@ ldns_rr2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr, int section)
 }
 
 ldns_status
-ldns_rrsig2buffer_wire(ldns_buffer *buffer, ldns_rr *rr)
+ldns_rrsig2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr)
 {
 	uint16_t i;
 
@@ -120,28 +120,10 @@ ldns_rrsig2buffer_wire(ldns_buffer *buffer, ldns_rr *rr)
 }
 
 ldns_status
-ldns_rr_rdata2buffer_wire(ldns_buffer *buffer, ldns_rr *rr)
+ldns_rr_rdata2buffer_wire(ldns_buffer *buffer, const ldns_rr *rr)
 {
 	uint16_t i;
-#if 0
-	if (ldns_rr_owner(rr)) {
-		(void) ldns_dname2buffer_wire(buffer, ldns_rr_owner(rr));
-	}
-	
-	if (ldns_buffer_reserve(buffer, 4)) {
-		(void) ldns_buffer_write_u16(buffer, ldns_rr_get_type(rr));
-		(void) ldns_buffer_write_u16(buffer, ldns_rr_get_class(rr));
-	}
-
-	if (ldns_buffer_reserve(buffer, 6)) {
-		ldns_buffer_write_u32(buffer, ldns_rr_ttl(rr));
-		/* remember pos for later */
-		rdl_pos = ldns_buffer_position(buffer);
-		ldns_buffer_write_u16(buffer, 0);
-	}	
-#endif
-
-	/* convert all the rdf */
+	/* convert all the rdf's */
 	for (i = 0; i < ldns_rr_rd_count(rr); i++) {
 		(void) ldns_rdf2buffer_wire(buffer, ldns_rr_rdf(rr, i));
 	}
@@ -338,4 +320,3 @@ ldns_pkt2wire(uint8_t **dest, const ldns_pkt *packet, size_t *result_size)
 	ldns_buffer_free(buffer);
 	return status;
 }
-
diff --git a/keys.c b/keys.c
index 985dc38b..d0b9816c 100644
--- a/keys.c
+++ b/keys.c
@@ -415,7 +415,7 @@ ldns_key_new_frm_algorithm(ldns_signing_algorithm alg, uint16_t size)
 }
 
 void
-ldns_key_print(FILE *output, ldns_key *k)
+ldns_key_print(FILE *output, const ldns_key *k)
 {
 	char *str = ldns_key2str(k);
 	if (str) {
@@ -489,13 +489,13 @@ ldns_key_set_keytag(ldns_key *k, uint16_t tag)
 
 /* read */
 size_t
-ldns_key_list_key_count(ldns_key_list *key_list)
+ldns_key_list_key_count(const ldns_key_list *key_list)
 {
 	        return key_list->_key_count;
 }       
 
 ldns_key *
-ldns_key_list_key(ldns_key_list *key, size_t nr)
+ldns_key_list_key(const ldns_key_list *key, size_t nr)
 {       
 	if (nr < ldns_key_list_key_count(key)) {
 		return key->_keys[nr];
@@ -505,61 +505,61 @@ ldns_key_list_key(ldns_key_list *key, size_t nr)
 }
 
 ldns_signing_algorithm
-ldns_key_algorithm(ldns_key *k) 
+ldns_key_algorithm(const ldns_key *k) 
 {
 	return k->_alg;
 }
 
 RSA *
-ldns_key_rsa_key(ldns_key *k)
+ldns_key_rsa_key(const ldns_key *k)
 {
 	return k->_key.rsa;
 }
 
 DSA *
-ldns_key_dsa_key(ldns_key *k)
+ldns_key_dsa_key(const ldns_key *k)
 {
 	return k->_key.dsa;
 }
 
 unsigned char *
-ldns_key_hmac_key(ldns_key *k)
+ldns_key_hmac_key(const ldns_key *k)
 {
 	return k->_key.hmac;
 }
 
 uint32_t
-ldns_key_origttl(ldns_key *k)
+ldns_key_origttl(const ldns_key *k)
 {
 	return k->_extra.dnssec.orig_ttl;
 }
 
 uint16_t
-ldns_key_flags(ldns_key *k)
+ldns_key_flags(const ldns_key *k)
 {
 	return k->_extra.dnssec.flags;
 }
 
 uint32_t
-ldns_key_inception(ldns_key *k)
+ldns_key_inception(const ldns_key *k)
 {
 	return k->_extra.dnssec.inception;
 }
 
 uint32_t
-ldns_key_expiration(ldns_key *k)
+ldns_key_expiration(const ldns_key *k)
 {
 	return k->_extra.dnssec.expiration;
 }
 
 uint16_t
-ldns_key_keytag(ldns_key *k)
+ldns_key_keytag(const ldns_key *k)
 {
 	return k->_extra.dnssec.keytag;
 }
 
 ldns_rdf *
-ldns_key_pubkey_owner(ldns_key *k)
+ldns_key_pubkey_owner(const ldns_key *k)
 {
 	return k->_pubkey_owner;
 }
@@ -684,7 +684,7 @@ ldns_key_dsa2bin(unsigned char *data, DSA *k, uint16_t *size)
 }
 
 ldns_rr *
-ldns_key2rr(ldns_key *k)
+ldns_key2rr(const ldns_key *k)
 {
 	/* this function will convert a the keydata contained in
 	 * rsa/dsa pointers to a DNSKEY rr. It will fill in as
diff --git a/ldns/dnssec.h b/ldns/dnssec.h
index b076a83e..a2d61f5f 100644
--- a/ldns/dnssec.h
+++ b/ldns/dnssec.h
@@ -30,7 +30,7 @@
  * \param[in] key the key as an RR to use for the calc.
  * \return the keytag
  */
-uint16_t ldns_calc_keytag(ldns_rr *key);
+uint16_t ldns_calc_keytag(const ldns_rr *key);
 
 /**
  * verifies an rrsig rrset.
diff --git a/ldns/host2str.h b/ldns/host2str.h
index f4d68b54..58abbdac 100644
--- a/ldns/host2str.h
+++ b/ldns/host2str.h
@@ -34,7 +34,7 @@
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_a(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_a(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_AAAA rdata element to string format and adds it to the output buffer 
@@ -42,7 +42,7 @@ ldns_status ldns_rdf2buffer_str_a(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_aaaa(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_aaaa(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_STR rdata element to string format and adds it to the output buffer 
@@ -50,7 +50,7 @@ ldns_status ldns_rdf2buffer_str_aaaa(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_str(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_B64 rdata element to string format and adds it to the output buffer 
@@ -58,7 +58,7 @@ ldns_status ldns_rdf2buffer_str_str(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_b64(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_HEX rdata element to string format and adds it to the output buffer 
@@ -66,7 +66,7 @@ ldns_status ldns_rdf2buffer_str_b64(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_hex(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_hex(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_TYPE rdata element to string format and adds it to the output buffer 
@@ -74,7 +74,7 @@ ldns_status ldns_rdf2buffer_str_hex(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_type(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_type(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_CLASS rdata element to string format and adds it to the output buffer 
@@ -82,7 +82,7 @@ ldns_status ldns_rdf2buffer_str_type(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_class(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_class(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_ALG rdata element to string format and adds it to the output buffer 
@@ -90,7 +90,7 @@ ldns_status ldns_rdf2buffer_str_class(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_alg(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_alg(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_CERT rdata element to string format and adds it to the output buffer 
@@ -98,7 +98,7 @@ ldns_status ldns_rdf2buffer_str_alg(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_LOC rdata element to string format and adds it to the output buffer 
@@ -106,7 +106,7 @@ ldns_status ldns_rdf2buffer_str_cert_alg(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_loc(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_loc(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_UNKNOWN rdata element to string format and adds it to the output buffer 
@@ -114,7 +114,7 @@ ldns_status ldns_rdf2buffer_str_loc(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_unknown(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_unknown(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_NSAP rdata element to string format and adds it to the output buffer 
@@ -122,7 +122,7 @@ ldns_status ldns_rdf2buffer_str_unknown(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_nsap(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_nsap(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_WKS rdata element to string format and adds it to the output buffer 
@@ -130,7 +130,7 @@ ldns_status ldns_rdf2buffer_str_nsap(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_wks(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_wks(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_NSEC rdata element to string format and adds it to the output buffer 
@@ -138,7 +138,7 @@ ldns_status ldns_rdf2buffer_str_wks(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_nsec(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_nsec(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_PERIOD rdata element to string format and adds it to the output buffer 
@@ -146,7 +146,7 @@ ldns_status ldns_rdf2buffer_str_nsec(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_period(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_period(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_TSIGTIME rdata element to string format and adds it to the output buffer 
@@ -154,7 +154,7 @@ ldns_status ldns_rdf2buffer_str_period(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_tsigtime(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_tsigtime(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_APL rdata element to string format and adds it to the output buffer 
@@ -162,7 +162,7 @@ ldns_status ldns_rdf2buffer_str_tsigtime(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_apl(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_apl(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_INT16_DATA rdata element to string format and adds it to the output buffer 
@@ -170,7 +170,7 @@ ldns_status ldns_rdf2buffer_str_apl(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_int16_data(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_int16_data(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_IPSECKEY rdata element to string format and adds it to the output buffer 
@@ -178,7 +178,7 @@ ldns_status ldns_rdf2buffer_str_int16_data(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, const ldns_rdf *rdf);
 
 /** 
  * Converts an LDNS_RDF_TYPE_TSIG rdata element to string format and adds it to the output buffer 
@@ -186,7 +186,7 @@ ldns_status ldns_rdf2buffer_str_ipseckey(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] *output The buffer to add the data to
  * \return LDNS_STATUS_OK on success, and error status on failure
  */
-ldns_status ldns_rdf2buffer_str_tsig(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_tsig(ldns_buffer *output, const ldns_rdf *rdf);
 
 
 /**
@@ -197,7 +197,7 @@ ldns_status ldns_rdf2buffer_str_tsig(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] rdf the pointer to the rdafa field containing the data
  * \return status
  */
-ldns_status ldns_rdf2buffer_str(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str(ldns_buffer *output, const ldns_rdf *rdf);
 
 /**
  * Converts the data in the resource record to presentation
@@ -207,7 +207,7 @@ ldns_status ldns_rdf2buffer_str(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] rr the pointer to the rr field to convert
  * \return status
  */
-ldns_status ldns_rr2buffer_str(ldns_buffer *output, ldns_rr *rr);
+ldns_status ldns_rr2buffer_str(ldns_buffer *output, const ldns_rr *rr);
 
 /**
  * Converts the data in the DNS packet to presentation
@@ -217,7 +217,7 @@ ldns_status ldns_rr2buffer_str(ldns_buffer *output, ldns_rr *rr);
  * \param[in] pkt the pointer to the packet to convert
  * \return status
  */
-ldns_status ldns_pkt2buffer_str(ldns_buffer *output, ldns_pkt *pkt);
+ldns_status ldns_pkt2buffer_str(ldns_buffer *output, const ldns_pkt *pkt);
 
 /**
  * Converts the data in the DNS packet to presentation
@@ -227,7 +227,7 @@ ldns_status ldns_pkt2buffer_str(ldns_buffer *output, ldns_pkt *pkt);
  * \param[in] k the pointer to the private key to convert
  * \return status
  */
-ldns_status ldns_key2buffer_str(ldns_buffer *output, ldns_key *k);
+ldns_status ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k);
 
 /**
  * Converts the data in the int16 typed rdata field to presentation
@@ -237,7 +237,7 @@ ldns_status ldns_key2buffer_str(ldns_buffer *output, ldns_key *k);
  * \param[in] rdf the pointer to the rdafa field containing the data
  * \return status
  */
-ldns_status ldns_rdf2buffer_str_int16(ldns_buffer *output, ldns_rdf *rdf);
+ldns_status ldns_rdf2buffer_str_int16(ldns_buffer *output, const ldns_rdf *rdf);
 
 /**
  * Converts the data in the rdata field to presentation format and
@@ -247,7 +247,7 @@ ldns_status ldns_rdf2buffer_str_int16(ldns_buffer *output, ldns_rdf *rdf);
  * \param[in] rdf The rdata field to convert
  * \return null terminated char * data, or NULL on error
  */
-char *ldns_rdf2str(ldns_rdf *rdf);
+char *ldns_rdf2str(const ldns_rdf *rdf);
 
 /**
  * Converts the data in the resource record to presentation format and
@@ -257,7 +257,7 @@ char *ldns_rdf2str(ldns_rdf *rdf);
  * \param[in] rr The rdata field to convert
  * \return null terminated char * data, or NULL on error
  */
-char *ldns_rr2str(ldns_rr *rr);
+char *ldns_rr2str(const ldns_rr *rr);
 
 /**
  * Converts the data in the DNS packet to presentation format and
@@ -267,7 +267,7 @@ char *ldns_rr2str(ldns_rr *rr);
  * \param[in] pkt The rdata field to convert
  * \return null terminated char * data, or NULL on error
  */
-char *ldns_pkt2str(ldns_pkt *pkt);
+char *ldns_pkt2str(const ldns_pkt *pkt);
 
 /**
  * Converts a private key to the test presentation fmt and
@@ -277,7 +277,7 @@ char *ldns_pkt2str(ldns_pkt *pkt);
  * \param[in] k the key to convert to text
  * \return null terminated char * data, or NULL on error
  */
-char *ldns_key2str(ldns_key *k);
+char *ldns_key2str(const ldns_key *k);
 
 /**
  * Converts a list of resource records to presentation format
@@ -287,7 +287,7 @@ char *ldns_key2str(ldns_key *k);
  * \param[in] rr_list the rr_list to convert to text
  * \return null terminated char * data, or NULL on error
  */
-char *ldns_rr_list2str(ldns_rr_list *rr_list);
+char *ldns_rr_list2str(const ldns_rr_list *rr_list);
 
 /**
  * Returns the data in the buffer as a null terminated char * string
@@ -306,7 +306,7 @@ char *buffer2str(ldns_buffer *buffer);
  * \param[in] rdf the rdata field to print
  * \return void
  */
-void ldns_rdf_print(FILE *output, ldns_rdf *rdf);
+void ldns_rdf_print(FILE *output, const ldns_rdf *rdf);
 
 /**
  * Prints the data in the resource record to the given file stream
@@ -316,7 +316,7 @@ void ldns_rdf_print(FILE *output, ldns_rdf *rdf);
  * \param[in] rr the resource record to print
  * \return void
  */
-void ldns_rr_print(FILE *output, ldns_rr *rr);
+void ldns_rr_print(FILE *output, const ldns_rr *rr);
 
 /**
  * Prints the data in the DNS packet to the given file stream
@@ -326,7 +326,7 @@ void ldns_rr_print(FILE *output, ldns_rr *rr);
  * \param[in] pkt the packet to print
  * \return void
  */
-void ldns_pkt_print(FILE *output, ldns_pkt *pkt);
+void ldns_pkt_print(FILE *output, const ldns_pkt *pkt);
 
 /**
  * Converts a rr_list to presentation format and appends it to
@@ -335,7 +335,7 @@ void ldns_pkt_print(FILE *output, ldns_pkt *pkt);
  * \param[in] list the ldns_rr_list to print
  * \return ldns_status
  */
-ldns_status ldns_rr_list2buffer_str(ldns_buffer *output, ldns_rr_list *list);
+ldns_status ldns_rr_list2buffer_str(ldns_buffer *output, const ldns_rr_list *list);
 
 /**
  * Converts the header of a packet to presentation format and appends it to
@@ -344,14 +344,14 @@ ldns_status ldns_rr_list2buffer_str(ldns_buffer *output, ldns_rr_list *list);
  * \param[in] pkt the packet to convert the header of
  * \return ldns_status
  */
-ldns_status ldns_pktheader2buffer_str(ldns_buffer *output, ldns_pkt *pkt);
+ldns_status ldns_pktheader2buffer_str(ldns_buffer *output, const ldns_pkt *pkt);
 
 /**
  * print a rr_list to output
  * param[in] output the fd to print to
  * param[in] list the rr_list to print
  */
-void ldns_rr_list_print(FILE *output, ldns_rr_list *list);
+void ldns_rr_list_print(FILE *output, const ldns_rr_list *list);
 
 /**
  * Print a resolver (in sofar that is possible) state
@@ -359,7 +359,7 @@ void ldns_rr_list_print(FILE *output, ldns_rr_list *list);
  * \param[in] output the fd to print to
  * \param[in] r the resolver to print
  */
-void ldns_resolver_print(FILE *output, ldns_resolver *r);
+void ldns_resolver_print(FILE *output, const ldns_resolver *r);
 
 /**
  * Print a zone structure * to output. Note the SOA record
@@ -367,7 +367,7 @@ void ldns_resolver_print(FILE *output, ldns_resolver *r);
  * \param[in] output the fd to print to
  * \param[in] z the zone to print
  */
-void ldns_zone_print(FILE *output, ldns_zone *z);
+void ldns_zone_print(FILE *output, const ldns_zone *z);
 
 /**
  * Print the ldns_rdf containing a dname to the buffer
@@ -375,7 +375,7 @@ void ldns_zone_print(FILE *output, ldns_zone *z);
  * \param[in] dname the dname to print
  * \return ldns_status message if the printing succeeded
  */
-ldns_status ldns_rdf2buffer_str_dname(ldns_buffer *output, ldns_rdf *dname);
+ldns_status ldns_rdf2buffer_str_dname(ldns_buffer *output, const ldns_rdf *dname);
 
 
 #endif /* LDNS_HOST2STR_H */
diff --git a/ldns/host2wire.h b/ldns/host2wire.h
index 5c8401fa..aa74d781 100644
--- a/ldns/host2wire.h
+++ b/ldns/host2wire.h
@@ -21,6 +21,14 @@
 
 #include "ldns/util.h"
 
+/**
+ * Copies the dname data to the buffer in wire format
+ * \param[out] *output buffer to append the result to
+ * \param[in] *name rdata dname to convert
+ * \return ldns_status
+ */
+ldns_status ldns_dname2buffer_wire(ldns_buffer *buffer, const ldns_rdf *name);
+
 /**
  * Copies the rdata data to the buffer in wire format
  * \param[out] *output buffer to append the result to
@@ -46,11 +54,11 @@ ldns_status ldns_rr2buffer_wire(ldns_buffer *output, const ldns_rr *rr, int sect
  * \param[in] sigrr signature rr to operate on
  * \return ldns_status
  */
-ldns_status ldns_rrsig2buffer_wire(ldns_buffer *output, ldns_rr *sigrr);
+ldns_status ldns_rrsig2buffer_wire(ldns_buffer *output, const ldns_rr *sigrr);
 
 /**
  * Converts an rr's rdata to wireformat, while excluding
- * the ownername and all the crap before the rdata.
+ * the ownername and all the stuff before the rdata.
  * This is needed in DNSSEC keytag calculation, the ds
  * calcalution from the key and maybe elsewhere.
  *
@@ -58,7 +66,7 @@ ldns_status ldns_rrsig2buffer_wire(ldns_buffer *output, ldns_rr *sigrr);
  * \param[in] *rr rr to operate on
  * \return ldns_status
  */
-ldns_status ldns_rr_rdata2buffer_wire(ldns_buffer *output, ldns_rr *rr);
+ldns_status ldns_rr_rdata2buffer_wire(ldns_buffer *output, const ldns_rr *rr);
 
 /**
  * Copies the packet data to the buffer in wire format
@@ -74,7 +82,7 @@ ldns_status ldns_pkt2buffer_wire(ldns_buffer *output, const ldns_pkt *pkt);
  * \param[in] *rrlist rr_list to to convert
  * \return ldns_status
  */
-ldns_status ldns_rr_list2buffer_wire(ldns_buffer *output, ldns_rr_list *rrlist);
+ldns_status ldns_rr_list2buffer_wire(ldns_buffer *output, const ldns_rr_list *rrlist);
 
 /**
  * Allocates an array of uint8_t at dest, and puts the wireformat of the
diff --git a/ldns/keys.h b/ldns/keys.h
index d448025b..7941e487 100644
--- a/ldns/keys.h
+++ b/ldns/keys.h
@@ -267,7 +267,7 @@ bool ldns_key_list_push_key(ldns_key_list *key_list, ldns_key *key);
  * \param[in] key_list the key_list
  * \return the numbers of keys in the list
  */
-size_t ldns_key_list_key_count(ldns_key_list *key_list);
+size_t ldns_key_list_key_count(const ldns_key_list *key_list);
 
 /**
  * returns a pointer to the key in the list at the given position
@@ -275,7 +275,7 @@ size_t ldns_key_list_key_count(ldns_key_list *key_list);
  * \param[in] nr the position in the list
  * \return the key
  */
-ldns_key *ldns_key_list_key(ldns_key_list *key, size_t nr);
+ldns_key *ldns_key_list_key(const ldns_key_list *key, size_t nr);
 
 #ifdef HAVE_SSL
 /**
@@ -283,14 +283,14 @@ ldns_key *ldns_key_list_key(ldns_key_list *key, size_t nr);
  * \param[in] k the key to look in
  * \return the RSA * structure in the key
  */
-RSA *ldns_key_rsa_key(ldns_key *k);
+RSA *ldns_key_rsa_key(const ldns_key *k);
 #endif /* HAVE_SSL */
 
 /**
  * returns the (openssl) DSA struct contained in the key
  */
 #ifdef HAVE_SSL
-DSA *ldns_key_dsa_key(ldns_key *k);
+DSA *ldns_key_dsa_key(const ldns_key *k);
 #endif /* HAVE_SSL */
 
 /**
@@ -298,49 +298,49 @@ DSA *ldns_key_dsa_key(ldns_key *k);
  * \param[in] k the key
  * \return the algorithm
  */
-ldns_signing_algorithm ldns_key_algorithm(ldns_key *k);
+ldns_signing_algorithm ldns_key_algorithm(const ldns_key *k);
 /**
  * return the hmac key 
  * \param[in] k the key
  * \return the hmac key
  */
-unsigned char *ldns_key_hmac_key(ldns_key *k);
+unsigned char *ldns_key_hmac_key(const ldns_key *k);
 /**
  * return the original ttl of the key
  * \param[in] k the key
  * \return the original ttl
  */
-uint32_t ldns_key_origttl(ldns_key *k);
+uint32_t ldns_key_origttl(const ldns_key *k);
 /**
  * return the key's inception date
  * \param[in] k the key
  * \return the inception date
  */
-uint32_t ldns_key_inception(ldns_key *k);
+uint32_t ldns_key_inception(const ldns_key *k);
 /**
  * return the key's expiration date
  * \param[in] k the key
  * \return the experiration date
  */
-uint32_t ldns_key_expiration(ldns_key *k);
+uint32_t ldns_key_expiration(const ldns_key *k);
 /**
  * return the keytag
  * \param[in] k the key
  * \return the keytag
  */
-uint16_t ldns_key_keytag(ldns_key *k);
+uint16_t ldns_key_keytag(const ldns_key *k);
 /**
  * return the public key's owner
  * \param[in] k the key
  * \return the owner
  */
-ldns_rdf *ldns_key_pubkey_owner(ldns_key *k);
+ldns_rdf *ldns_key_pubkey_owner(const ldns_key *k);
 /**
  * return the flag of the key
  * \param[in] k the key
  * \return the flag
  */
-uint16_t ldns_key_flags(ldns_key *k);
+uint16_t ldns_key_flags(const ldns_key *k);
 
 /**     
  * pops the last rr from a keylist
@@ -355,7 +355,7 @@ ldns_key *ldns_key_list_pop_key(ldns_key_list *key_list);
  * \param[in] k the ldns_key to convert
  * \return ldns_rr representation of the key
  */
-ldns_rr *ldns_key2rr(ldns_key *k);
+ldns_rr *ldns_key2rr(const ldns_key *k);
 
 /**
  * print a private key to the file ouput
@@ -363,7 +363,7 @@ ldns_rr *ldns_key2rr(ldns_key *k);
  * \param[in] output the FILE descriptor where to print to
  * \param[in] k the ldns_key to print
  */
-void ldns_key_print(FILE *output, ldns_key *k);
+void ldns_key_print(FILE *output, const ldns_key *k);
 
 /**
  * frees a key structure
diff --git a/ldns/rr.h b/ldns/rr.h
index a128864b..4bd7aa6b 100644
--- a/ldns/rr.h
+++ b/ldns/rr.h
@@ -416,7 +416,7 @@ ldns_rr_class ldns_rr_get_class(const ldns_rr *rr);
  * \param[in] rr_list  the rr_list to read from
  * \return the number of rr's
  */
-size_t ldns_rr_list_rr_count(ldns_rr_list *rr_list);
+size_t ldns_rr_list_rr_count(const ldns_rr_list *rr_list);
 
 /**
  * sets the number of rr's in an rr_list.
@@ -442,7 +442,7 @@ ldns_rr * ldns_rr_list_set_rr(ldns_rr_list *rr_list, const ldns_rr *r, size_t co
  * \param[in] nr return this rr
  * \return the rr at position nr
  */
-ldns_rr* ldns_rr_list_rr(ldns_rr_list *rr_list, size_t nr);
+ldns_rr* ldns_rr_list_rr(const ldns_rr_list *rr_list, size_t nr);
 
 /**
  * creates a new rr_list structure.
diff --git a/ldns/rr_functions.h b/ldns/rr_functions.h
index 63d2c5c7..79c1c664 100644
--- a/ldns/rr_functions.h
+++ b/ldns/rr_functions.h
@@ -26,7 +26,7 @@
  * \param[in] r the resource record
  * \return a ldns_rdf* with the address or NULL on failure
  */
-ldns_rdf* ldns_rr_a_address(ldns_rr *r);
+ldns_rdf* ldns_rr_a_address(const ldns_rr *r);
 
 /**
  * sets the address of a LDNS_RR_TYPE_A rr
@@ -42,7 +42,7 @@ bool ldns_rr_a_set_address(ldns_rr *r, ldns_rdf *f);
  * \param[in] r the resource record
  * \return a ldns_rdf* with the name or NULL on failure
  */
-ldns_rdf* ldns_rr_ns_nsdname(ldns_rr *r);
+ldns_rdf* ldns_rr_ns_nsdname(const ldns_rr *r);
 
 /* MX */
 /**
@@ -50,13 +50,13 @@ ldns_rdf* ldns_rr_ns_nsdname(ldns_rr *r);
  * \param[in] r the resource record
  * \return a ldns_rdf* with the preference or NULL on failure
  */
-ldns_rdf* ldns_rr_mx_preference(ldns_rr *r);
+ldns_rdf* ldns_rr_mx_preference(const ldns_rr *r);
 /**
  * returns the mx host of a LDNS_RR_TYPE_MX rr
  * \param[in] r the resource record
  * \return a ldns_rdf* with the name of the MX host or NULL on failure
  */
-ldns_rdf* ldns_rr_mx_exchange(ldns_rr *r);
+ldns_rdf* ldns_rr_mx_exchange(const ldns_rr *r);
 
 /* RRSIG */
 /**
@@ -64,7 +64,7 @@ ldns_rdf* ldns_rr_mx_exchange(ldns_rr *r);
  * \param[in] r the resource record
  * \return a ldns_rdf* with the type covered or NULL on failure
  */
-ldns_rdf* ldns_rr_rrsig_typecovered(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_typecovered(const ldns_rr *r);
 /**
  * sets the typecovered of a LDNS_RR_TYPE_RRSIG rr
  * \param[in] r the rr to use
@@ -77,7 +77,7 @@ bool ldns_rr_rrsig_set_typecovered(ldns_rr *r, ldns_rdf *f);
  * \param[in] r the resource record
  * \return a ldns_rdf* with the algorithm or NULL on failure
  */
-ldns_rdf* ldns_rr_rrsig_algorithm(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_algorithm(const ldns_rr *r);
 /**
  * sets the algorithm of a LDNS_RR_TYPE_RRSIG rr
  * \param[in] r the rr to use
@@ -90,7 +90,7 @@ bool ldns_rr_rrsig_set_algorithm(ldns_rr *r, ldns_rdf *f);
  * \param[in] r the resource record
  * \return a ldns_rdf* with the number of labels or NULL on failure
  */
-ldns_rdf* ldns_rr_rrsig_labels(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_labels(const ldns_rr *r);
 /**
  * sets the number of labels of a LDNS_RR_TYPE_RRSIG rr
  * \param[in] r the rr to use
@@ -103,7 +103,7 @@ bool ldns_rr_rrsig_set_labels(ldns_rr *r, ldns_rdf *f);
  * \param[in] r the resource record
  * \return a ldns_rdf* with the original TTL or NULL on failure
  */
-ldns_rdf* ldns_rr_rrsig_origttl(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_origttl(const ldns_rr *r);
 /**
  * sets the original TTL of a LDNS_RR_TYPE_RRSIG rr
  * \param[in] r the rr to use
@@ -116,7 +116,7 @@ bool ldns_rr_rrsig_set_origttl(ldns_rr *r, ldns_rdf *f);
  * \param[in] r the resource record
  * \return a ldns_rdf* with the expiration time or NULL on failure
  */
-ldns_rdf* ldns_rr_rrsig_expiration(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_expiration(const ldns_rr *r);
 /**
  * sets the expireation date of a LDNS_RR_TYPE_RRSIG rr
  * \param[in] r the rr to use
@@ -129,7 +129,7 @@ bool ldns_rr_rrsig_set_expiration(ldns_rr *r, ldns_rdf *f);
  * \param[in] r the resource record
  * \return a ldns_rdf* with the inception time or NULL on failure
  */
-ldns_rdf* ldns_rr_rrsig_inception(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_inception(const ldns_rr *r);
 /**
  * sets the inception date of a LDNS_RR_TYPE_RRSIG rr
  * \param[in] r the rr to use
@@ -142,7 +142,7 @@ bool ldns_rr_rrsig_set_inception(ldns_rr *r, ldns_rdf *f);
  * \param[in] r the resource record
  * \return a ldns_rdf* with the keytag or NULL on failure
  */
-ldns_rdf* ldns_rr_rrsig_keytag(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_keytag(const ldns_rr *r);
 /**
  * sets the keytag of a LDNS_RR_TYPE_RRSIG rr
  * \param[in] r the rr to use
@@ -155,7 +155,7 @@ bool ldns_rr_rrsig_set_keytag(ldns_rr *r, ldns_rdf *f);
  * \param[in] r the resource record
  * \return a ldns_rdf* with the signers name or NULL on failure
  */
-ldns_rdf* ldns_rr_rrsig_signame(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_signame(const ldns_rr *r);
 /**
  * sets the signers name of a LDNS_RR_TYPE_RRSIG rr
  * \param[in] r the rr to use
@@ -168,7 +168,7 @@ bool ldns_rr_rrsig_set_signame(ldns_rr *r, ldns_rdf *f);
  * \param[in] r the resource record
  * \return a ldns_rdf* with the signature data or NULL on failure
  */
-ldns_rdf* ldns_rr_rrsig_sig(ldns_rr *r);
+ldns_rdf* ldns_rr_rrsig_sig(const ldns_rr *r);
 /**
  * sets the signature data of a LDNS_RR_TYPE_RRSIG rr
  * \param[in] r the rr to use
@@ -183,7 +183,7 @@ bool ldns_rr_rrsig_set_sig(ldns_rr *r, ldns_rdf *f);
  * \param[in] r the resource record
  * \return a ldns_rdf* with the flags or NULL on failure
  */
-ldns_rdf* ldns_rr_dnskey_flags(ldns_rr *r);
+ldns_rdf* ldns_rr_dnskey_flags(const ldns_rr *r);
 /**
  * sets the flags of a LDNS_RR_TYPE_DNSKEY rr
  * \param[in] r the rr to use
@@ -196,7 +196,7 @@ bool ldns_rr_dnskey_set_flags(ldns_rr *r, ldns_rdf *f);
  * \param[in] r the resource record
  * \return a ldns_rdf* with the protocol or NULL on failure
  */
-ldns_rdf* ldns_rr_dnskey_protocol(ldns_rr *r);
+ldns_rdf* ldns_rr_dnskey_protocol(const ldns_rr *r);
 /**
  * sets the protocol of a LDNS_RR_TYPE_DNSKEY rr
  * \param[in] r the rr to use
@@ -209,7 +209,7 @@ bool ldns_rr_dnskey_set_protocol(ldns_rr *r, ldns_rdf *f);
  * \param[in] r the resource record
  * \return a ldns_rdf* with the algorithm or NULL on failure
  */
-ldns_rdf* ldns_rr_dnskey_algorithm(ldns_rr *r);
+ldns_rdf* ldns_rr_dnskey_algorithm(const ldns_rr *r);
 /**
  * sets the algorithm of a LDNS_RR_TYPE_DNSKEY rr
  * \param[in] r the rr to use
@@ -222,7 +222,7 @@ bool ldns_rr_dnskey_set_algorithm(ldns_rr *r, ldns_rdf *f);
  * \param[in] r the resource record
  * \return a ldns_rdf* with the key data or NULL on failure
  */
-ldns_rdf* ldns_rr_dnskey_key(ldns_rr *r);
+ldns_rdf* ldns_rr_dnskey_key(const ldns_rr *r);
 /**
  * sets the key data of a LDNS_RR_TYPE_DNSKEY rr
  * \param[in] r the rr to use
@@ -236,6 +236,6 @@ bool ldns_rr_dnskey_set_key(ldns_rr *r, ldns_rdf *f);
  * \param[in] key the key rr to use
  * \return the keysize in bits
  */
-uint16_t ldns_rr_dnskey_key_size(ldns_rr *key);
+uint16_t ldns_rr_dnskey_key_size(const ldns_rr *key);
 
 #endif /* LDNS_RR_FUNCTIONS_H */
diff --git a/rr.c b/rr.c
index 3ea8b22d..e8272832 100644
--- a/rr.c
+++ b/rr.c
@@ -630,7 +630,7 @@ ldns_rr_get_class(const ldns_rr *rr)
 /* rr_lists */
 
 size_t
-ldns_rr_list_rr_count(ldns_rr_list *rr_list)
+ldns_rr_list_rr_count(const ldns_rr_list *rr_list)
 {
 	if (rr_list) {
 		return rr_list->_rr_count;
@@ -694,7 +694,7 @@ ldns_rr_list_set_rr_count(ldns_rr_list *rr_list, size_t count)
 }
 
 ldns_rr *
-ldns_rr_list_rr(ldns_rr_list *rr_list, size_t nr)
+ldns_rr_list_rr(const ldns_rr_list *rr_list, size_t nr)
 {
 	if (nr < ldns_rr_list_rr_count(rr_list)) {
 		return rr_list->_rrs[nr];
diff --git a/rr_functions.c b/rr_functions.c
index 2666e34a..c8e29f25 100644
--- a/rr_functions.c
+++ b/rr_functions.c
@@ -28,7 +28,7 @@
  * \return the rdf sought
  */
 static ldns_rdf *
-ldns_rr_function(ldns_rr_type type, ldns_rr *rr, size_t pos)
+ldns_rr_function(ldns_rr_type type, const ldns_rr *rr, size_t pos)
 {
         if (!rr || ldns_rr_get_type(rr) != type) {
                 return NULL;
@@ -62,7 +62,7 @@ ldns_rr_set_function(ldns_rr_type type, ldns_rr *rr, ldns_rdf *rdf, size_t pos)
 
 /* A/AAAA records */
 ldns_rdf *
-ldns_rr_a_address(ldns_rr *r)
+ldns_rr_a_address(const ldns_rr *r)
 {
 	/* 2 types to check, cannot use the macro */
 	if (!r || (ldns_rr_get_type(r) != LDNS_RR_TYPE_A &&
@@ -93,7 +93,7 @@ ldns_rr_a_set_address(ldns_rr *r, ldns_rdf *f)
 
 /* NS record */
 ldns_rdf *
-ldns_rr_ns_nsdname(ldns_rr *r)
+ldns_rr_ns_nsdname(const ldns_rr *r)
 {
 	return ldns_rr_function(LDNS_RR_TYPE_NS, r, 0);
 }
@@ -101,13 +101,13 @@ ldns_rr_ns_nsdname(ldns_rr *r)
 
 /* MX record */
 ldns_rdf *
-ldns_rr_mx_preference(ldns_rr *r)
+ldns_rr_mx_preference(const ldns_rr *r)
 {
 	return ldns_rr_function(LDNS_RR_TYPE_MX, r, 0);
 }
 
 ldns_rdf *
-ldns_rr_mx_exchange(ldns_rr *r)
+ldns_rr_mx_exchange(const ldns_rr *r)
 {
 	return ldns_rr_function(LDNS_RR_TYPE_MX, r, 1);
 }
@@ -115,7 +115,7 @@ ldns_rr_mx_exchange(ldns_rr *r)
 
 /* RRSIG record */
 ldns_rdf *
-ldns_rr_rrsig_typecovered(ldns_rr *r)
+ldns_rr_rrsig_typecovered(const ldns_rr *r)
 {
 	return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 0);
 }
@@ -127,7 +127,7 @@ ldns_rr_rrsig_set_typecovered(ldns_rr *r, ldns_rdf *f)
 }
 
 ldns_rdf *
-ldns_rr_rrsig_algorithm(ldns_rr *r)
+ldns_rr_rrsig_algorithm(const ldns_rr *r)
 {
 	return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 1);
 }
@@ -139,7 +139,7 @@ ldns_rr_rrsig_set_algorithm(ldns_rr *r, ldns_rdf *f)
 }
 
 ldns_rdf *
-ldns_rr_rrsig_labels(ldns_rr *r)
+ldns_rr_rrsig_labels(const ldns_rr *r)
 {
 	return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 2);
 }
@@ -150,7 +150,7 @@ ldns_rr_rrsig_set_labels(ldns_rr *r, ldns_rdf *f)
 }
 
 ldns_rdf *
-ldns_rr_rrsig_origttl(ldns_rr *r)
+ldns_rr_rrsig_origttl(const ldns_rr *r)
 {
 	return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 3);
 }
@@ -161,7 +161,7 @@ ldns_rr_rrsig_set_origttl(ldns_rr *r, ldns_rdf *f)
 }
 
 ldns_rdf *
-ldns_rr_rrsig_expiration(ldns_rr *r)
+ldns_rr_rrsig_expiration(const ldns_rr *r)
 {
 	return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 4);
 }
@@ -172,7 +172,7 @@ ldns_rr_rrsig_set_expiration(ldns_rr *r, ldns_rdf *f)
 }
 
 ldns_rdf *
-ldns_rr_rrsig_inception(ldns_rr *r)
+ldns_rr_rrsig_inception(const ldns_rr *r)
 {
 	return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 5);
 }
@@ -183,7 +183,7 @@ ldns_rr_rrsig_set_inception(ldns_rr *r, ldns_rdf *f)
 }
 
 ldns_rdf *
-ldns_rr_rrsig_keytag(ldns_rr *r)
+ldns_rr_rrsig_keytag(const ldns_rr *r)
 {
 	return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 6);
 }
@@ -194,7 +194,7 @@ ldns_rr_rrsig_set_keytag(ldns_rr *r, ldns_rdf *f)
 	return ldns_rr_set_function(LDNS_RR_TYPE_RRSIG, r, f, 6);
 }
 ldns_rdf *
-ldns_rr_rrsig_signame(ldns_rr *r)
+ldns_rr_rrsig_signame(const ldns_rr *r)
 {
 	return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 7);
 }
@@ -205,7 +205,7 @@ ldns_rr_rrsig_set_signame(ldns_rr *r, ldns_rdf *f)
 }
 
 ldns_rdf *
-ldns_rr_rrsig_sig(ldns_rr *r)
+ldns_rr_rrsig_sig(const ldns_rr *r)
 {
 	return ldns_rr_function(LDNS_RR_TYPE_RRSIG, r, 8);
 }
@@ -219,7 +219,7 @@ ldns_rr_rrsig_set_sig(ldns_rr *r, ldns_rdf *f)
 
 /* DNSKEY record */
 ldns_rdf *
-ldns_rr_dnskey_flags(ldns_rr *r)
+ldns_rr_dnskey_flags(const ldns_rr *r)
 {
 	return ldns_rr_function(LDNS_RR_TYPE_DNSKEY, r, 0);
 }
@@ -231,7 +231,7 @@ ldns_rr_dnskey_set_flags(ldns_rr *r, ldns_rdf *f)
 }
 
 ldns_rdf *
-ldns_rr_dnskey_protocol(ldns_rr *r)
+ldns_rr_dnskey_protocol(const ldns_rr *r)
 {
 	return ldns_rr_function(LDNS_RR_TYPE_DNSKEY, r, 1);
 }
@@ -242,7 +242,7 @@ ldns_rr_dnskey_set_protocol(ldns_rr *r, ldns_rdf *f)
 	return ldns_rr_set_function(LDNS_RR_TYPE_DNSKEY, r, f, 1);
 }
 ldns_rdf *
-ldns_rr_dnskey_algorithm(ldns_rr *r)
+ldns_rr_dnskey_algorithm(const ldns_rr *r)
 {
 	return ldns_rr_function(LDNS_RR_TYPE_DNSKEY, r, 2);
 }
@@ -253,7 +253,7 @@ ldns_rr_dnskey_set_algorithm(ldns_rr *r, ldns_rdf *f)
 	return ldns_rr_set_function(LDNS_RR_TYPE_DNSKEY, r, f, 2);
 }
 ldns_rdf *
-ldns_rr_dnskey_key(ldns_rr *r)
+ldns_rr_dnskey_key(const ldns_rr *r)
 {
 	return ldns_rr_function(LDNS_RR_TYPE_DNSKEY, r, 3);
 }
@@ -265,7 +265,7 @@ ldns_rr_dnskey_set_key(ldns_rr *r, ldns_rdf *f)
 }
 
 uint16_t 
-ldns_rr_dnskey_key_size(ldns_rr *key) {
+ldns_rr_dnskey_key_size(const ldns_rr *key) {
 	
 	ldns_rdf *keydata;
 	uint16_t length;