Bugfix #431, #432 and #433 from Jerry Lundström

#431: Error message for the LDNS_STATUS_INVALID_B32_EXT return code
#432: Use LDNS_MALLOC and LDNS_FREE whenever possible
    , but use free() when memory was not allocated with LDNS_MALLOC
      (such as with strdup and with i2d_DSA_SIG)
#433: Use ldns_rdf_new in stead of filling the structure ourselve in
      ldns_dname_label

diff --git a/Changelog b/Changelog
index 9f2a08dd2d96404e8dc482ddd8ec5174feb23f96..ab04fd43484fd1d41010c4ed76490a5215f24fd3 100644 (file)
--- a/Changelog
+++ b/Changelog
@@ -1,4 +1,7 @@
 1.6.13
+       * bugfix #433: Allocate rdf using ldns_rdf_new in ldns_dname_label
+       * bugfix #432: Use LDNS_MALLOC & LDNS_FREE i.s.o. malloc & free
+       * bugfix #431: Added error message for LDNS_STATUS_INVALID_B32_EXT
        * bugfix #427: Eplicitely link ssl with the programs that use it.
        * Fix reading \DDD: Error on values that are outside range (>255).
        * bugfix #429: fix doxyparse.plfails on NetBSD because specified

diff --git a/dname.c b/dname.c
index 0e63ef2689520c9de2eec0e031f12b20df16b205..9054e0f05d5b6c2cdcec6ac89cb061274acb7d32 100644 (file)
--- a/dname.c
+++ b/dname.c
@@ -530,6 +530,7 @@ ldns_dname_label(const ldns_rdf *rdf, uint8_t labelpos)
        uint16_t len;
        ldns_rdf *tmpnew;
        size_t s;
+       uint8_t *data;
 
        if (ldns_rdf_get_type(rdf) != LDNS_RDF_TYPE_DNAME) {
                return NULL;
@@ -543,19 +544,19 @@ ldns_dname_label(const ldns_rdf *rdf, uint8_t labelpos)
        while ((len > 0) && src_pos < s) {
                if (labelcnt == labelpos) {
                        /* found our label */
-                       tmpnew = LDNS_MALLOC(ldns_rdf);
-                       if (!tmpnew) {
+                       data = LDNS_XMALLOC(uint8_t, len + 2);
+                       if (!data) {
                                return NULL;
                        }
-                       tmpnew->_type = LDNS_RDF_TYPE_DNAME;
-                       tmpnew->_data = LDNS_XMALLOC(uint8_t, len + 2);
-                       if (!tmpnew->_data) {
-                               LDNS_FREE(tmpnew);
+                       memcpy(data, ldns_rdf_data(rdf) + src_pos, len + 1);
+                       data[len + 2 - 1] = 0;
+
+                       tmpnew = ldns_rdf_new( LDNS_RDF_TYPE_DNAME
+                                            , len + 2, data);
+                       if (!tmpnew) {
+                               LDNS_FREE(data);
                                return NULL;
                        }
-                       memset(tmpnew->_data, 0, len + 2);
-                       memcpy(tmpnew->_data, ldns_rdf_data(rdf) + src_pos, len + 1);
-                       tmpnew->_size = len + 2;
                        return tmpnew;
                }
                src_pos++;

diff --git a/dnssec_verify.c b/dnssec_verify.c
index aeb20712e93472bdf3c3152f920ce54a62d5497b..4693a0e33f0aab583ac7c3588cf2e93fe63c3d09 100644 (file)
--- a/dnssec_verify.c
+++ b/dnssec_verify.c
@@ -509,7 +509,7 @@ ldns_dnssec_trust_tree_print_sm_fmt(FILE *out,
        
        if (!sibmap) {
                treedepth = ldns_dnssec_trust_tree_depth(tree);
-               sibmap = malloc(treedepth);
+               sibmap = LDNS_MALLOC(treedepth);
                 if(!sibmap)
                         return; /* mem err */
                memset(sibmap, 0, treedepth);
@@ -623,7 +623,7 @@ ldns_dnssec_trust_tree_print_sm_fmt(FILE *out,
        }
        
        if (mapset) {
-               free(sibmap);
+               LDNS_FREE(sibmap);
        }
 }
 

diff --git a/dnssec_zone.c b/dnssec_zone.c
index 89bdf8dd0ccb0d55b97cc81daafe72d8e7e03a6a..26394e0ac8b311c3fab8f41702836ca64dad4d73 100644 (file)
--- a/dnssec_zone.c
+++ b/dnssec_zone.c
@@ -625,14 +625,14 @@ void
 ldns_dnssec_name_node_free(ldns_rbnode_t *node, void *arg) {
        (void) arg;
        ldns_dnssec_name_free((ldns_dnssec_name *)node->data);
-       free(node);
+       LDNS_FREE(node);
 }
 
 void
 ldns_dnssec_name_node_deep_free(ldns_rbnode_t *node, void *arg) {
        (void) arg;
        ldns_dnssec_name_deep_free((ldns_dnssec_name *)node->data);
-       free(node);
+       LDNS_FREE(node);
 }
 
 void
@@ -644,7 +644,7 @@ ldns_dnssec_zone_free(ldns_dnssec_zone *zone)
                        ldns_traverse_postorder(zone->names,
                                                    ldns_dnssec_name_node_free,
                                                    NULL);
-                       free(zone->names);
+                       LDNS_FREE(zone->names);
                }
                LDNS_FREE(zone);
        }
@@ -659,7 +659,7 @@ ldns_dnssec_zone_deep_free(ldns_dnssec_zone *zone)
                        ldns_traverse_postorder(zone->names,
                                                    ldns_dnssec_name_node_deep_free,
                                                    NULL);
-                       free(zone->names);
+                       LDNS_FREE(zone->names);
                }
                LDNS_FREE(zone);
        }

diff --git a/error.c b/error.c
index a6195022ea0bceb265db09614ea0c5cfff7463b8..df0e5b1fa42979bb8c6e73251aaab5471cf99473 100644 (file)
--- a/error.c
+++ b/error.c
@@ -29,6 +29,7 @@ ldns_lookup_table ldns_error_str[] = {
         { LDNS_STATUS_INVALID_IP4, "Conversion error, ip4 addr expected" },
         { LDNS_STATUS_INVALID_IP6, "Conversion error, ip6 addr expected" },
         { LDNS_STATUS_INVALID_STR, "Conversion error, string expected" },
+       { LDNS_STATUS_INVALID_B32_EXT, "Conversion error, b32 ext encoding expected" },
         { LDNS_STATUS_INVALID_B64, "Conversion error, b64 encoding expected" },
         { LDNS_STATUS_INVALID_HEX, "Conversion error, hex encoding expected" },
         { LDNS_STATUS_INVALID_TIME, "Conversion error, time encoding expected" },

diff --git a/keys.c b/keys.c
index 0e82a102bd3a4404918d66d3bb760fa08e94afb8..615b314f7225a4ddbd1baee3dfcc324059a8d970 100644 (file)
--- a/keys.c
+++ b/keys.c
@@ -1541,7 +1541,7 @@ ldns_key_deep_free(ldns_key *key)
        }
 #endif /* HAVE_SSL */
        if (ldns_key_hmac_key(key)) {
-               free(ldns_key_hmac_key(key));
+               LDNS_FREE(ldns_key_hmac_key(key));
        }
        LDNS_FREE(key);
 }

diff --git a/rbtree.c b/rbtree.c
index 217e61d27576fd5ad8fa3f517e1f79714927ecc6..f7fdcc352f4a994b13a733c12ca53ad615ab5adc 100644 (file)
--- a/rbtree.c
+++ b/rbtree.c
@@ -43,6 +43,7 @@
 
 #include <ldns/config.h>
 #include <ldns/rbtree.h>
+#include <ldns/utils.h>
 #include <stdlib.h>
 
 /** Node colour black */
@@ -81,7 +82,7 @@ ldns_rbtree_create (int (*cmpf)(const void *, const void *))
        ldns_rbtree_t *rbtree;
 
        /* Allocate memory for it */
-       rbtree = (ldns_rbtree_t *) malloc(sizeof(ldns_rbtree_t));
+       rbtree = (ldns_rbtree_t *) LDNS_MALLOC(sizeof(ldns_rbtree_t));
        if (!rbtree) {
                return NULL;
        }
@@ -104,7 +105,7 @@ ldns_rbtree_init(ldns_rbtree_t *rbtree, int (*cmpf)(const void *, const void *))
 void 
 ldns_rbtree_free(ldns_rbtree_t *rbtree)
 {
-       free(rbtree);
+       LDNS_FREE(rbtree);
 }
 
 /*

diff --git a/resolver.c b/resolver.c
index 732f2a8a776de413ecf359a57dead26c8558372f..1a788a363fe95ae2b8e7518c21fd587eec804131 100644 (file)
--- a/resolver.c
+++ b/resolver.c
@@ -1274,7 +1274,7 @@ ldns_axfr_next(ldns_resolver *resolver)
 
                status = ldns_wire2pkt(&resolver->_cur_axfr_pkt, packet_wire,
                                     packet_wire_size);
-               free(packet_wire);
+               LDNS_FREE(packet_wire);
 
                resolver->_axfr_i = 0;
                if (status != LDNS_STATUS_OK) {