const additions for the resolver

diff --git a/Changelog b/Changelog
index f919246179b59d1b65911fc8116956d164292634..4e1f370f3f4901c05df6484066cce880f0a04e96 100644 (file)
--- a/Changelog
+++ b/Changelog
@@ -32,6 +32,8 @@ XX Jan 2006: 1.1.0: ldns-team
        Code:
        * All networking code was moved to net.c
        * rdata.c: added asserts to the rdf set/get functions
+       * const keyword was added to pointer arguments that 
+         aren't changed
 
        API:
        Changed:

diff --git a/dname.c b/dname.c
index 4284e6093c6951f8e9207c0aaa84fa52f4db35b5..000483473cb5d62ecc6fc7c1bbfe268e460a2307 100644 (file)
--- a/dname.c
+++ b/dname.c
@@ -23,7 +23,7 @@
 #include <arpa/inet.h>
 
 ldns_rdf *
-ldns_dname_cat_clone(ldns_rdf *rd1, ldns_rdf *rd2)
+ldns_dname_cat_clone(const ldns_rdf *rd1, const ldns_rdf *rd2)
 {
        ldns_rdf *new;
        uint16_t new_size;

diff --git a/ldns/dname.h b/ldns/dname.h
index b9ee354dfe849637ef58dc3c4d583a1b3894952b..db0543ce7ca0821086693500e24fe027833b3fcd 100644 (file)
--- a/ldns/dname.h
+++ b/ldns/dname.h
@@ -24,7 +24,7 @@
  * \param[in] rd2 the rightside
  * \return a new rdf with leftside/rightside
  */
-ldns_rdf *ldns_dname_cat_clone(ldns_rdf *rd1, ldns_rdf *rd2);
+ldns_rdf *ldns_dname_cat_clone(const ldns_rdf *rd1, const ldns_rdf *rd2);
 /**
  * concatenates rd2 after rd1 (rd2 is copied, rd1 is modified)
  * \param[in] rd1 the leftside

diff --git a/ldns/net.h b/ldns/net.h
index de35bb1f39a9a8462d83ba768bbfe957d6a02f0b..eb60b617c233e63ffc6acd9e4e078fac676cace3 100644 (file)
--- a/ldns/net.h
+++ b/ldns/net.h
@@ -81,7 +81,7 @@ ldns_status ldns_tcp_send(uint8_t **result, ldns_buffer *qbin, const struct sock
  * \param[in] query_pkt the query to send
  * \return status
  */
-ldns_status ldns_send(ldns_pkt **pkt, ldns_resolver *r, ldns_pkt *query_pkt);
+ldns_status ldns_send(ldns_pkt **pkt, ldns_resolver *r, const ldns_pkt *query_pkt);
 
 /**
  * Create a tcp socket to the specified address

diff --git a/ldns/resolver.h b/ldns/resolver.h
index 4baf2eb300e976fa1f3058cabb38a4915592b4da..9aa29408056e285e5646d1a7f7f1f092c5ef27b4 100644 (file)
--- a/ldns/resolver.h
+++ b/ldns/resolver.h
@@ -121,147 +121,147 @@ typedef struct ldns_struct_resolver ldns_resolver;
  * \param[in] r the resolver
  * \return the port number 
  */
-uint16_t ldns_resolver_port(ldns_resolver *r);
+uint16_t ldns_resolver_port(const ldns_resolver *r);
 
 /**
  * Is the resolver set to recurse
  * \param[in] r the resolver
  * \return true if so, otherwise false
  */
-bool ldns_resolver_recursive(ldns_resolver *r);
+bool ldns_resolver_recursive(const ldns_resolver *r);
 
 /**
  * Get the debug status of the resolver
  * \param[in] r the resolver
  * \return true if so, otherwise false
  */
-bool ldns_resolver_debug(ldns_resolver *r);
+bool ldns_resolver_debug(const ldns_resolver *r);
 
 /**
  * Get the number of retries
  * \param[in] r the resolver
  * \return the number of retries
  */
-uint8_t ldns_resolver_retry(ldns_resolver *r);
+uint8_t ldns_resolver_retry(const ldns_resolver *r);
 
 /**
  * Get the retransmit interval
  * \param[in] r the resolver
  * \return the retransmit interval
  */
-uint8_t ldns_resolver_retrans(ldns_resolver *r);
+uint8_t ldns_resolver_retrans(const ldns_resolver *r);
 
 /**
  * Does the resolver use ip6 or ip4
  * \param[in] r the resolver
  * \return 0: both, 1: ip4, 2:ip6
  */
-uint8_t ldns_resolver_ip6(ldns_resolver *r);
+uint8_t ldns_resolver_ip6(const ldns_resolver *r);
 
 /**
  * Get the resolver's udp size
  * \param[in] r the resolver
  * \return the udp mesg size
  */
-uint16_t ldns_resolver_edns_udp_size(ldns_resolver *r);
+uint16_t ldns_resolver_edns_udp_size(const ldns_resolver *r);
 /**
  * Does the resolver use tcp or udp
  * \param[in] r the resolver
  * \return true: tcp, false: udp
  */
-bool ldns_resolver_usevc(ldns_resolver *r);
+bool ldns_resolver_usevc(const ldns_resolver *r);
 /**
  * Does the resolver only try the first nameserver
  * \param[in] r the resolver
  * \return true: yes, fail, false: no, try the others
  */
-bool ldns_resolver_fail(ldns_resolver *r);
+bool ldns_resolver_fail(const ldns_resolver *r);
 /**
  * Does the resolver do DNSSEC
  * \param[in] r the resolver
  * \return true: yes, false: no
  */
-bool ldns_resolver_dnssec(ldns_resolver *r);
+bool ldns_resolver_dnssec(const ldns_resolver *r);
 /**
  * Does the resolver set the CD bit 
  * \param[in] r the resolver
  * \return true: yes, false: no
  */
-bool ldns_resolver_dnssec_cd(ldns_resolver *r);
+bool ldns_resolver_dnssec_cd(const ldns_resolver *r);
 /**
  * Does the resolver ignore the TC bit (truncated)
  * \param[in] r the resolver
  * \return true: yes, false: no
  */
-bool ldns_resolver_igntc(ldns_resolver *r);
+bool ldns_resolver_igntc(const ldns_resolver *r);
 /**
  * Does the resolver randomize the nameserver before usage
  * \param[in] r the resolver
  * \return true: yes, false: no
  */
-bool ldns_resolver_random(ldns_resolver *r);
+bool ldns_resolver_random(const ldns_resolver *r);
 /**
  * How many nameserver are configured in the resolver
  * \param[in] r the resolver
  * \return number of nameservers
  */
-size_t ldns_resolver_nameserver_count(ldns_resolver *r);
+size_t ldns_resolver_nameserver_count(const ldns_resolver *r);
 /**
  * What is the default dname to add to relative queries
  * \param[in] r the resolver
  * \return the dname which is added
  */
-ldns_rdf *ldns_resolver_domain(ldns_resolver *r);
+ldns_rdf *ldns_resolver_domain(const ldns_resolver *r);
 /**
  * What is the timeout on socket connections
  * \param[in] r the resolver
  * \return the timeout as struct timeval
  */
-struct timeval ldns_resolver_timeout(ldns_resolver *r);
+struct timeval ldns_resolver_timeout(const ldns_resolver *r);
 /**
  * What is the searchlist as used by the resolver
  * \param[in] r the resolver
  * \return a ldns_rdf pointer to a list of the addresses
  */
-ldns_rdf** ldns_resolver_searchlist(ldns_resolver *r);
+ldns_rdf** ldns_resolver_searchlist(const ldns_resolver *r);
 /**
  * Return the configured nameserver ip address
  * \param[in] r the resolver
  * \return a ldns_rdf pointer to a list of the addresses
  */
-ldns_rdf** ldns_resolver_nameservers(ldns_resolver *r);
+ldns_rdf** ldns_resolver_nameservers(const ldns_resolver *r);
 /**
  * Return the used round trip times for the nameservers
  * \param[in] r the resolver
  * \return a size_t* pointer to the list.
  * yet)
  */
-size_t * ldns_resolver_rtt(ldns_resolver *r);
+size_t * ldns_resolver_rtt(const ldns_resolver *r);
 /**
  * Return the used round trip time for a specific nameserver
  * \param[in] r the resolver
  * \param[in] pos the index to the nameserver
  * \return the rrt, 0: infinite, >0: undefined (as of * yet)
  */
-size_t ldns_resolver_nameserver_rtt(ldns_resolver *r, size_t pos);
+size_t ldns_resolver_nameserver_rtt(const ldns_resolver *r, size_t pos);
 /**
  * Return the tsig keyname as used by the nameserver
  * \param[in] r the resolver
  * \return the name used.
  */
-char *ldns_resolver_tsig_keyname(ldns_resolver *r);
+char *ldns_resolver_tsig_keyname(const ldns_resolver *r);
 /**
  * Return the tsig algorithm as used by the nameserver
  * \param[in] r the resolver
  * \return the algorithm used.
  */
-char *ldns_resolver_tsig_algorithm(ldns_resolver *r);
+char *ldns_resolver_tsig_algorithm(const ldns_resolver *r);
 /**
  * Return the tsig keydata as used by the nameserver
  * \param[in] r the resolver
  * \return the keydata used.
  */
-char *ldns_resolver_tsig_keydata(ldns_resolver *r);
+char *ldns_resolver_tsig_keydata(const ldns_resolver *r);
 /**
  * pop the last nameserver from the resolver.
  * \param[in] r the resolver
@@ -274,7 +274,7 @@ ldns_rdf* ldns_resolver_pop_nameserver(ldns_resolver *r);
  * \param[in] r the resolver
  * \return the searchlist count
  */
-size_t ldns_resolver_searchlist_count(ldns_resolver *r);
+size_t ldns_resolver_searchlist_count(const ldns_resolver *r);
 
 /* write access function */
 /**
@@ -503,6 +503,8 @@ ldns_status ldns_resolver_push_nameserver_rr_list(ldns_resolver *r, ldns_rr_list
 
 /**
  * Send the query for using the resolver and take the search list into account
+ * The search algorithm is as follows:
+ *  If the is absolute, try it as-is, otherwise apply the search list
  * \param[in] *r operate using this resolver
  * \param[in] *rdf query for this name
  * \param[in] t query for this type (may be 0, defaults to A)
@@ -510,7 +512,7 @@ ldns_status ldns_resolver_push_nameserver_rr_list(ldns_resolver *r, ldns_rr_list
  * \param[in] flags the query flags
  * \return ldns_pkt* a packet with the reply from the nameserver
  */
-ldns_pkt* ldns_resolver_search(ldns_resolver *r, ldns_rdf *rdf, ldns_rr_type t, ldns_rr_class c, uint16_t flags);
+ldns_pkt* ldns_resolver_search(const ldns_resolver *r, const ldns_rdf *rdf, ldns_rr_type t, ldns_rr_class c, uint16_t flags);
 
 /**
  * Send the query for name as-is 
@@ -522,7 +524,7 @@ ldns_pkt* ldns_resolver_search(ldns_resolver *r, ldns_rdf *rdf, ldns_rr_type t,
  * \param[in] flags the query flags
  * \return ldns_pkt* a packet with the reply from the nameserver
  */
-ldns_status ldns_resolver_send(ldns_pkt **answer, ldns_resolver *r, ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags);
+ldns_status ldns_resolver_send(ldns_pkt **answer, ldns_resolver *r, const ldns_rdf *name, ldns_rr_type t, ldns_rr_class c, uint16_t flags);
 
 /**
  * Send the given packet to a nameserver
@@ -530,7 +532,7 @@ ldns_status ldns_resolver_send(ldns_pkt **answer, ldns_resolver *r, ldns_rdf *na
  * \param[in] *r operate using this resolver
  * \param[in] *query_pkt query
  */
-ldns_status ldns_resolver_send_pkt(ldns_pkt **answer, ldns_resolver *r, ldns_pkt *query_pkt);
+ldns_status ldns_resolver_send_pkt(ldns_pkt **answer, const ldns_resolver *r, const ldns_pkt *query_pkt);
 
 /**
  * Send a query to a nameserver
@@ -542,7 +544,7 @@ ldns_status ldns_resolver_send_pkt(ldns_pkt **answer, ldns_resolver *r, ldns_pkt
  * \return ldns_pkt* a packet with the reply from the nameserver
  * if _defnames is true the default domain will be added
  */
-ldns_pkt* ldns_resolver_query(ldns_resolver *r, ldns_rdf *name, ldns_rr_type type, ldns_rr_class class, uint16_t flags);
+ldns_pkt* ldns_resolver_query(ldns_resolver *r, const ldns_rdf *name, ldns_rr_type type, ldns_rr_class class, uint16_t flags);
 
 
 /** 
@@ -606,7 +608,7 @@ ldns_rr* ldns_axfr_next(ldns_resolver *resolver);
  * \param[in] resolver the resolver that is used
  * \return bool true if axfr transfer was completed without error
  */
-bool ldns_axfr_complete(ldns_resolver *resolver);
+bool ldns_axfr_complete(const ldns_resolver *resolver);
 
 /**
  * returns a pointer to the last ldns_pkt that was sent by the server in the AXFR transfer
@@ -614,7 +616,7 @@ bool ldns_axfr_complete(ldns_resolver *resolver);
  * \param[in] res the resolver that was used in the axfr transfer
  * \return ldns_pkt the last packet sent
  */
-ldns_pkt *ldns_axfr_last_pkt(ldns_resolver *res);
+ldns_pkt *ldns_axfr_last_pkt(const ldns_resolver *res);
 
 /**
  * randomize the nameserver list in the resolver

diff --git a/net.c b/net.c
index 50b4a47fb1417aef6b3a154208e8486f9a2895ad..de07261303d6498f9053769d9a1a29e280461b39 100644 (file)
--- a/net.c
+++ b/net.c
@@ -23,7 +23,7 @@
 #include <errno.h>
 
 ldns_status
-ldns_send(ldns_pkt **result, ldns_resolver *r, ldns_pkt *query_pkt)
+ldns_send(ldns_pkt **result, ldns_resolver *r, const ldns_pkt *query_pkt)
 {
        uint8_t i;
        

diff --git a/resolver.c b/resolver.c
index 0eccd52ab108d68b49e890cbf31e1f07e7df9ec6..21eca0136050eb0d0572199d8542593268580cae 100644 (file)
--- a/resolver.c
+++ b/resolver.c
@@ -21,121 +21,121 @@
 
 /* read */
 uint16_t
-ldns_resolver_port(ldns_resolver *r)
+ldns_resolver_port(const ldns_resolver *r)
 {
        return r->_port;
 }
 
 uint16_t
-ldns_resolver_edns_udp_size(ldns_resolver *r)
+ldns_resolver_edns_udp_size(const ldns_resolver *r)
 {
                return r->_edns_udp_size;
 }
 
 uint8_t
-ldns_resolver_retry(ldns_resolver *r)
+ldns_resolver_retry(const ldns_resolver *r)
 {
        return r->_retry;
 }
 
 uint8_t
-ldns_resolver_retrans(ldns_resolver *r)
+ldns_resolver_retrans(const ldns_resolver *r)
 {
        return r->_retrans;
 }
 
 uint8_t
-ldns_resolver_ip6(ldns_resolver *r)
+ldns_resolver_ip6(const ldns_resolver *r)
 {
        return r->_ip6;
 }
 
 bool
-ldns_resolver_recursive(ldns_resolver *r)
+ldns_resolver_recursive(const ldns_resolver *r)
 {
        return r->_recursive;
 }
 
 bool
-ldns_resolver_debug(ldns_resolver *r)
+ldns_resolver_debug(const ldns_resolver *r)
 {
        return r->_debug;
 }
 
 bool
-ldns_resolver_dnsrch(ldns_resolver *r)
+ldns_resolver_dnsrch(const ldns_resolver *r)
 {
        return r->_dnsrch;
 }
 
 bool
-ldns_resolver_fail(ldns_resolver *r)
+ldns_resolver_fail(const ldns_resolver *r)
 {
        return r->_fail;
 }
 
 bool
-ldns_resolver_defnames(ldns_resolver *r)
+ldns_resolver_defnames(const ldns_resolver *r)
 {
        return r->_defnames;
 }
 
 ldns_rdf *
-ldns_resolver_domain(ldns_resolver *r)
+ldns_resolver_domain(const ldns_resolver *r)
 {
        return r->_domain;
 }
 
 ldns_rdf **
-ldns_resolver_searchlist(ldns_resolver *r)
+ldns_resolver_searchlist(const ldns_resolver *r)
 {
        return r->_searchlist;
 }
 
 ldns_rdf **
-ldns_resolver_nameservers(ldns_resolver *r)
+ldns_resolver_nameservers(const ldns_resolver *r)
 {
        return r->_nameservers;
 }
 
 size_t
-ldns_resolver_nameserver_count(ldns_resolver *r)
+ldns_resolver_nameserver_count(const ldns_resolver *r)
 {
        return r->_nameserver_count;
 }
 
 bool
-ldns_resolver_dnssec(ldns_resolver *r)
+ldns_resolver_dnssec(const ldns_resolver *r)
 {
        return r->_dnssec;
 }
 
 bool
-ldns_resolver_dnssec_cd(ldns_resolver *r)
+ldns_resolver_dnssec_cd(const ldns_resolver *r)
 {
        return r->_dnssec_cd;
 }
 
 bool
-ldns_resolver_igntc(ldns_resolver *r)
+ldns_resolver_igntc(const ldns_resolver *r)
 {
        return r->_igntc;
 }
 
 bool
-ldns_resolver_usevc(ldns_resolver *r)
+ldns_resolver_usevc(const ldns_resolver *r)
 {
        return r->_usevc;
 }
 
 size_t *
-ldns_resolver_rtt(ldns_resolver *r)
+ldns_resolver_rtt(const ldns_resolver *r)
 {
        return r->_rtt;
 }
 
 size_t
-ldns_resolver_nameserver_rtt(ldns_resolver *r, size_t pos)
+ldns_resolver_nameserver_rtt(const ldns_resolver *r, size_t pos)
 {
        size_t *rtt;
 
@@ -153,37 +153,37 @@ ldns_resolver_nameserver_rtt(ldns_resolver *r, size_t pos)
 }
 
 struct timeval
-ldns_resolver_timeout(ldns_resolver *r)
+ldns_resolver_timeout(const ldns_resolver *r)
 {
        return r->_timeout;
 } 
 
 char *
-ldns_resolver_tsig_keyname(ldns_resolver *r)
+ldns_resolver_tsig_keyname(const ldns_resolver *r)
 {
        return r->_tsig_keyname;
 }
 
 char *
-ldns_resolver_tsig_algorithm(ldns_resolver *r)
+ldns_resolver_tsig_algorithm(const ldns_resolver *r)
 {
        return r->_tsig_algorithm;
 }
 
 char *
-ldns_resolver_tsig_keydata(ldns_resolver *r)
+ldns_resolver_tsig_keydata(const ldns_resolver *r)
 {
        return r->_tsig_keydata;
 }
 
 bool
-ldns_resolver_random(ldns_resolver *r)
+ldns_resolver_random(const ldns_resolver *r)
 {
        return r->_random;
 }
 
 size_t
-ldns_resolver_searchlist_count(ldns_resolver *r)
+ldns_resolver_searchlist_count(const ldns_resolver *r)
 {
        return r->_searchlist_count;
 }
@@ -710,27 +710,20 @@ ldns_resolver_deep_free(ldns_resolver *res)
        }
 }
 
-#if 0
-/** 
- * Send the query 
- * \param[in] *r operate using this resolver
- * \param[in] *name query for this name
- * \param[in] *type query for this type (may be 0, defaults to A)
- * \param[in] *class query for this class (may be 0, default to IN)
- * \param[in] flags the query flags
- * \return ldns_pkt* a packet with the reply from the nameserver
- * if _dnsrch is true add the searchlist
- */
 ldns_pkt *
-ldns_resolver_search(ldns_resolver *r, ldns_rdf *name, ldns_rr_type type, 
+ldns_resolver_search(const ldns_resolver *r,const  ldns_rdf *name, ldns_rr_type type, 
                 ldns_rr_class class, uint16_t flags)
 {
+       r = r;
+       name = name;
+       type = type;
+       class = class;
+       flags = flags;
        return NULL;
 }
-#endif
 
 ldns_pkt *
-ldns_resolver_query(ldns_resolver *r, ldns_rdf *name, ldns_rr_type type, ldns_rr_class class,
+ldns_resolver_query(ldns_resolver *r, const ldns_rdf *name, ldns_rr_type type, ldns_rr_class class,
                 uint16_t flags)
 {
        ldns_rdf *newname;
@@ -769,7 +762,7 @@ ldns_resolver_query(ldns_resolver *r, ldns_rdf *name, ldns_rr_type type, ldns_rr
                }
        }
 
-       newname = ldns_dname_cat_clone(name, ldns_resolver_domain(r));
+       newname = ldns_dname_cat_clone((const ldns_rdf*)name, ldns_resolver_domain(r));
        if (!newname) {
                if (pkt) {
                        ldns_pkt_free(pkt);
@@ -782,12 +775,12 @@ ldns_resolver_query(ldns_resolver *r, ldns_rdf *name, ldns_rr_type type, ldns_rr
 }
 
 ldns_status
-ldns_resolver_send_pkt(ldns_pkt **answer, ldns_resolver *r, ldns_pkt *query_pkt)
+ldns_resolver_send_pkt(ldns_pkt **answer,const ldns_resolver *r, const ldns_pkt *query_pkt)
 {
        ldns_pkt *answer_pkt = NULL;
        ldns_status stat = LDNS_STATUS_OK;
 
-       stat = ldns_send(&answer_pkt, r, query_pkt);
+       stat = ldns_send(&answer_pkt, (ldns_resolver *)r, query_pkt);
        if (stat != LDNS_STATUS_OK) {
                if(answer_pkt) {
                        ldns_pkt_free(answer_pkt);
@@ -803,7 +796,7 @@ ldns_resolver_send_pkt(ldns_pkt **answer, ldns_resolver *r, ldns_pkt *query_pkt)
 }
 
 ldns_status
-ldns_resolver_send(ldns_pkt **answer, ldns_resolver *r, ldns_rdf *name, 
+ldns_resolver_send(ldns_pkt **answer, ldns_resolver *r,const  ldns_rdf *name, 
                ldns_rr_type type, ldns_rr_class class, uint16_t flags)
 {
        ldns_pkt *query_pkt;
@@ -939,13 +932,13 @@ ldns_axfr_next(ldns_resolver *resolver)
 }
 
 bool
-ldns_axfr_complete(ldns_resolver *res) {
+ldns_axfr_complete(const ldns_resolver *res) {
        /* complete when soa count is 2? */
        return res->_axfr_soa_count == 2;
 }
 
 ldns_pkt *
-ldns_axfr_last_pkt(ldns_resolver *res) {
+ldns_axfr_last_pkt(const ldns_resolver *res) {
        return res->_cur_axfr_pkt;
 }