information wants to be free.

synced all calls to MALLOC and FREE for runtest[1-4].

diff --git a/buffer.c b/buffer.c
index 20e56f70f9a21155499eb3ada793a166d86cdbe8..31a3e6d967031d1bf17b19231cb9115271b9374b 100644 (file)
--- a/buffer.c
+++ b/buffer.c
@@ -163,9 +163,13 @@ ldns_buffer_free(ldns_buffer *buffer)
                return;
        }
 
+/*
        if (!buffer->_fixed) {
+*/
                FREE(buffer->_data);
+/*
        }
+*/
        FREE(buffer);
 }
 

diff --git a/host2str.c b/host2str.c
index 4c17f3f06eb585395b60657d1a66ff90facc0396..1de6931e82d2676c962d778e4db7517b3be2686f 100644 (file)
--- a/host2str.c
+++ b/host2str.c
@@ -874,6 +874,7 @@ ldns_pkt2buffer_str(ldns_buffer *output, ldns_pkt *pkt)
 {
        uint16_t i;
        ldns_status status = LDNS_STATUS_OK;
+       char *tmp;
        
        if (ldns_buffer_status_ok(output)) {
                status = ldns_pktheader2buffer_str(output, pkt);
@@ -935,7 +936,9 @@ ldns_pkt2buffer_str(ldns_buffer *output, ldns_pkt *pkt)
                /* add some futher fields */
                ldns_buffer_printf(output, ";; Query time: %d msec\n", ldns_pkt_querytime(pkt));
                if (ldns_pkt_answerfrom(pkt)) {
-                       ldns_buffer_printf(output, ";; SERVER: %s\n", ldns_rdf2str(ldns_pkt_answerfrom(pkt)));
+                       tmp = ldns_rdf2str(ldns_pkt_answerfrom(pkt));
+                       ldns_buffer_printf(output, ";; SERVER: %s\n", tmp);
+                       FREE(tmp);
                }
                if (ldns_pkt_when(pkt)) {
                        /* \n included in when buffer, see ctime(3) */
@@ -971,6 +974,11 @@ buffer2str(ldns_buffer *buffer)
 
        tmp_str = ldns_buffer_export(buffer);
        str = XMALLOC(char, strlen(tmp_str) + 1);
+/*
+if(str == 0x80530f0){
+memcpy(0, "a", 1);
+}
+*/
        memcpy(str, tmp_str, strlen(tmp_str) + 1);
 
        return str;
@@ -1031,6 +1039,7 @@ ldns_rdf_print(FILE *output, ldns_rdf *rdf)
        } else {
                fprintf(output, "Unable to convert rdf to string\n");
        }
+       FREE(str);
 }
 
 void

diff --git a/host2wire.c b/host2wire.c
index 9be10a869ea22998a89e10d3799623ae978cd623..3fc6cc436fc097beb02def2fffa0d524dec5e7e6 100644 (file)
--- a/host2wire.c
+++ b/host2wire.c
@@ -222,6 +222,7 @@ uint8_t *
 ldns_pkt2wire(ldns_pkt *packet, size_t *result_size)
 {
        ldns_buffer *buffer = ldns_buffer_new(MAX_PACKETLEN);
+       uint8_t *result2 = NULL;
        uint8_t *result = NULL;
        *result_size = 0;
        if (ldns_pkt2buffer_wire(buffer, packet) == LDNS_STATUS_OK) {
@@ -230,7 +231,13 @@ ldns_pkt2wire(ldns_pkt *packet, size_t *result_size)
        } else {
                /* TODO: what about the error? */
        }
+       
+       if (result) {
+               result2 = XMALLOC(uint8_t, ldns_buffer_position(buffer));
+               memcpy(result2, result, ldns_buffer_position(buffer));
+       }
+       
        ldns_buffer_free(buffer);
-       return result;
+       return result2;
 }
 

diff --git a/net.c b/net.c
index cb87db9b38197b91a820e7cce095fa6a0f103ee6..35387aaaf4f1459d33534df0521d45f8b1fed5e0 100644 (file)
--- a/net.c
+++ b/net.c
@@ -94,7 +94,7 @@ ldns_send(ldns_resolver *r, ldns_pkt *query_pkt)
                                ns_len = (socklen_t)sizeof(struct sockaddr_in6);
                                break;
                }
-
+               
                gettimeofday(&tv_s, NULL);
                /* query */
                if (1 == ldns_resolver_usevc(r)) {
@@ -103,6 +103,7 @@ ldns_send(ldns_resolver *r, ldns_pkt *query_pkt)
                        /* udp here, please */
                        reply = ldns_send_udp(qb, ns, ns_len);
                }
+               FREE(ns);
                gettimeofday(&tv_e, NULL);
 
                if (reply) {
@@ -192,9 +193,11 @@ ldns_send_udp(ldns_buffer *qbin, const struct sockaddr_storage *to, socklen_t to
 
         if (ldns_wire2pkt(&answer_pkt, answer, (size_t) bytes) != 
                        LDNS_STATUS_OK) {
+               FREE(answer);
                return NULL;
        } else {
                ldns_pkt_set_size(answer_pkt, (size_t) bytes);
+               FREE(answer);
                return answer_pkt;
        }
 }

diff --git a/packet.c b/packet.c
index 0acd3a68aedae3d0fab2036c5581793812328dd3..3c0fb99548da3b333e51c7d400a4ed32a958f451 100644 (file)
--- a/packet.c
+++ b/packet.c
@@ -407,19 +407,16 @@ ldns_pkt_free(ldns_pkt *packet)
 {
        FREE(packet->_header);
        if (packet->_question) {
-               /*ldns_rr_list_destroy(packet->_question);*/
+               ldns_rr_list_free(packet->_question);
        }
        if (packet->_answer) {
-               /*ldns_rr_list_destroy(packet->_answer);*/
-               FREE(packet->_answer);
+               ldns_rr_list_free(packet->_answer);
        }
        if (packet->_authority) {
-               /*ldns_rr_list_destroy(packet->_authority);*/
-               FREE(packet->_authority);
+               ldns_rr_list_free(packet->_authority);
        }
        if (packet->_additional) {
-               /*ldns_rr_list_destroy(packet->_additional);*/
-               FREE(packet->_authority);
+               ldns_rr_list_free(packet->_additional);
        }
        FREE(packet);
 }

diff --git a/rdata.c b/rdata.c
index 0936692578f3402c06056c6a182c07333a3dd43b..d5956b1942c048ae7207c5a3a2a2dc6c9455ab47 100644 (file)
--- a/rdata.c
+++ b/rdata.c
@@ -250,7 +250,12 @@ ldns_rdf_free_data(ldns_rdf *rd)
 void 
 ldns_rdf_free(ldns_rdf *rd)
 {
-       FREE(rd);
+       if (rd) {
+               if (rd->_data) {
+                       FREE(rd->_data);
+               }
+               FREE(rd);
+       }
 }
 
 /**

diff --git a/resolver.c b/resolver.c
index 1a5f3ed97471569ec42e5d7288bf50daffa9aaba..0c426d9c77be2d14aaf8a451ca3d7ca7aa654ae6 100644 (file)
--- a/resolver.c
+++ b/resolver.c
@@ -250,6 +250,28 @@ ldns_resolver_new(void)
        return r;
 }
 
+/**
+ * Frees the allocated space for this resolver and all it's data
+ *
+ * \param res resolver to free
+ */
+void
+ldns_resolver_free(ldns_resolver *res)
+{
+       size_t i;
+/*
+       for (i = 0; i < res->_nameserver_count; i++) {
+               ldns_rdf_free(res->_nameservers[i]);
+       }
+       for (i = 0; i < res->_searchlist_count; i++) {
+               ldns_rdf_free(res->_searchlist[i]);
+       }
+*/
+       FREE(res->_searchlist);
+       FREE(res->_nameservers);
+       FREE(res);
+}
+
 /** 
  * Send the query 
  * \param[in] *r operate using this resolver
@@ -338,7 +360,7 @@ ldns_resolver_send(ldns_resolver *r, ldns_rdf *name, ldns_rr_type type, ldns_rr_
        }
        /* prepare a question pkt from the parameters
         * and then send this */
-       query_pkt = ldns_pkt_query_new(name, type, class, flags);
+       query_pkt = ldns_pkt_query_new(ldns_rdf_clone(name), type, class, flags);
        if (!query_pkt) {
                printf("Failed to generate pkt\n");
                return NULL;
@@ -346,6 +368,8 @@ ldns_resolver_send(ldns_resolver *r, ldns_rdf *name, ldns_rr_type type, ldns_rr_
 
        /* return NULL on error */
        answer_pkt = ldns_send(r, query_pkt);
+       
+       ldns_pkt_free(query_pkt);
                
        return answer_pkt;
 }

diff --git a/rr.c b/rr.c
index 3b50105a036fb14cb1cd0647f703963df0af1858..d7b828bcaaa332e3812fb04247523088e2f13347 100644 (file)
--- a/rr.c
+++ b/rr.c
@@ -45,6 +45,9 @@ void
 ldns_rr_free(ldns_rr *rr)
 {
        uint16_t i;
+       if (ldns_rr_owner(rr)) {
+               ldns_rdf_free(ldns_rr_owner(rr));
+       }
        for (i = 0; i < ldns_rr_rd_count(rr); i++) {
                ldns_rdf_free(ldns_rr_rdf(rr, i));
        }

diff --git a/run-test1.c b/run-test1.c
index 4ff6620c65f30ce7ad01a7855adfe85da3631a52..ea7880b096a29b93d3c580880379be42c67ca9f6 100644 (file)
--- a/run-test1.c
+++ b/run-test1.c
@@ -38,29 +38,39 @@ doit(void)
        ldns_rdf *cat_test1;
        ldns_rdf *cat_test2;
        ldns_rdf *concat;
-
+       char *str;
+       
        buf = ldns_buffer_new(10); /* alloc away! */
        if (!buf) {
                printf("Nooooo\n");
        }
 
        printf("Setting 15242\n");
+       
        if (ldns_str2rdf_int16(&rdata, "15242") != LDNS_STATUS_OK) {
                printf("_short: ah man, shit hit the fan\n");
        }
        
        (void) ldns_rdf2buffer_str_int16(buf, rdata); 
-       fprintf(stderr, "%s\n", buffer2str(buf));
+       str = buffer2str(buf);
+       fprintf(stderr, "%s\n", str);
+
+       FREE(str);
+       ldns_buffer_free(buf);
+       ldns_rdf_free(rdata);
 
        /* test the label counter */
        cnt_test = ldns_dname_new_frm_str("miek.nl.");
        printf("Labels miek.nl. %d\n", ldns_rdf_dname_label_count(cnt_test));
+       ldns_rdf_free(cnt_test);
 
        cnt_test = ldns_dname_new_frm_str("miek.nl");
        printf("Labels miek.nl %d\n", ldns_rdf_dname_label_count(cnt_test));
+       ldns_rdf_free(cnt_test);
        
        cnt_test = ldns_dname_new_frm_str("miek");
        printf("Labels miek %d\n", ldns_rdf_dname_label_count(cnt_test));
+       ldns_rdf_free(cnt_test);
        
 /* this errors
        cnt_test = ldns_dname_new_frm_str(".");
@@ -76,6 +86,7 @@ printf("counting: %s\n", ldns_rdf2str(cnt_test));
 
        cnt_test = ldns_dname_new_frm_str("nl");
        printf("Labels nl %d\n", ldns_rdf_dname_label_count(cnt_test));
+       ldns_rdf_free(cnt_test);
 
 
        /* concat tests */
@@ -84,8 +95,13 @@ printf("counting: %s\n", ldns_rdf2str(cnt_test));
        concat = ldns_dname_concat(cat_test1, cat_test2);
 
        ldns_rdf_print(stdout, concat);
+
        printf(" [%d]\n", ldns_rdf_size(concat));
        printf("Labels nl %d\n", ldns_rdf_dname_label_count(concat));
+
+       ldns_rdf_free(cat_test1);
+       ldns_rdf_free(cat_test2);
+       ldns_rdf_free(concat);
 }
 
 
@@ -96,10 +112,13 @@ main(void)
        if (ldns_str2rdf_int16(&bla, "15242") != LDNS_STATUS_OK) {
                printf("_int16: ah man, shit hit the fan\n");
        }
+       ldns_rdf_free(bla);
+       
        /* %Y%m%d%H%M%S */
        if (ldns_str2rdf_time(&bla, "20041222134100") != LDNS_STATUS_OK) {
                printf("_time: ah man, shit hit the fan\n");
        }
+       ldns_rdf_free(bla);
 
        printf("succes\n");
        doit();

diff --git a/run-test2.c b/run-test2.c
index e3b6577f1e9e8277ae25ea0642b118b85447dd87..af59e0c7e50a1006aa1f7e39a2704cfb53218a0b 100644 (file)
--- a/run-test2.c
+++ b/run-test2.c
@@ -167,8 +167,12 @@ file2pkt(const char *filename)
                wirelen = (size_t) hexbufpos;
        }
        
+       FREE(hexbuf);
+       
        status = ldns_wire2pkt(&pkt, wire, wirelen);
        
+       FREE(wire);
+       
        if (status == LDNS_STATUS_OK) {
                return pkt;
        } else {
@@ -186,6 +190,7 @@ main(int argc, char **argv)
        uint8_t *target_buf;
        size_t len;
        uint16_t i;
+       char *str;
        
        if (argc == 2) {
                file = argv[1];
@@ -196,7 +201,9 @@ main(int argc, char **argv)
        pkt = file2pkt(file);
        if (pkt) {
                printf("packet:\n");
-               printf("%s", ldns_pkt2str(pkt));
+               str = ldns_pkt2str(pkt);
+               printf("%s", str);
+               FREE(str);
        } else {
                printf("\n");
        }
@@ -212,6 +219,8 @@ main(int argc, char **argv)
        }
        printf("\n\n");
 
+       ldns_pkt_free(pkt);
+       FREE(target_buf);
        
        return 0;
 }

diff --git a/run-test3.c b/run-test3.c
index c4e1eab5358b311f9e9b2435e12754412beef705..1f0140871cec1b29b17744194a50d74760f84c94 100644 (file)
--- a/run-test3.c
+++ b/run-test3.c
@@ -18,12 +18,20 @@ main(void)
 
        fprintf(stdout, "www.\n");
        (void) ldns_str2rdf_dname(&rd, "www.");
+       ldns_rdf_free(rd);
+
        fprintf(stdout, "www.miek.nl\n");
        (void) ldns_str2rdf_dname(&rd, "www.miek.nl");
+       ldns_rdf_free(rd);
+
        fprintf(stdout, "www\n");
        (void) ldns_str2rdf_dname(&rd, "www");
+       ldns_rdf_free(rd);
+
        fprintf(stdout, "www.miek.nl..\n");
        (void) ldns_str2rdf_dname(&rd, "www.miek.nl..");
+       
+       ldns_rdf_free(rd);
 
        return 0;
 }

diff --git a/run-test4.c b/run-test4.c
index 0052ebf585c6a114af6d09049b4b4005d3e9bafa..00dcb5bdb3c5d7889f62867de0e1f5a3cd83efdb 100644 (file)
--- a/run-test4.c
+++ b/run-test4.c
@@ -60,11 +60,19 @@ main(void)
 
        if (!pkt)  {
                printf("error pkt sending\n");
-               return 1;
-       }
+       } else {
         
         /* print the resulting pkt to stdout */
-        ldns_pkt_print(stdout, pkt);
+/*
+               ldns_pkt_print(stdout, pkt);
+*/
+               ldns_pkt_free(pkt);
+       }
+
+        ldns_rdf_free(qname);
+        ldns_rdf_free(default_dom);
+        ldns_rdf_free(nameserver);
+        ldns_resolver_free(res);
 
         return 0;
 }

diff --git a/run-test7.c b/run-test7.c
index 3a0b30e412846bc015bd51e5cd6c631b6701a160..f080f4290b8ec440086766f28452bf8db1232638 100644 (file)
--- a/run-test7.c
+++ b/run-test7.c
@@ -94,5 +94,6 @@ main(int argc, char **argv)
         /* print the resulting pkt to stdout */
         ldns_pkt_print(stdout, pkt);
 
+        ldns_resolver_free(res);
         return 0;
 }

diff --git a/str2host.c b/str2host.c
index cdaff02441a36293c1ed4a57474789e05081381d..df79a4cf3e096de13d38557fa8ee9971dce64d4b 100644 (file)
--- a/str2host.c
+++ b/str2host.c
@@ -48,6 +48,7 @@ ldns_str2rdf_int16(ldns_rdf **rd, const char *shortstr)
                return LDNS_STATUS_INT_EXP;
        } else {
                *rd = ldns_rdf_new_frm_data(sizeof(uint16_t), LDNS_RDF_TYPE_INT16, (uint8_t*)r);
+               FREE(r);
                return LDNS_STATUS_OK;
        }
 }
@@ -76,6 +77,7 @@ ldns_str2rdf_time(ldns_rdf **rd, const char *time)
                l = htonl(timegm(&tm));
                memcpy(r, &l, sizeof(uint32_t));
                *rd = ldns_rdf_new_frm_data(sizeof(uint32_t), LDNS_RDF_TYPE_TIME, (uint8_t*)r);
+               FREE(r);
                return LDNS_STATUS_OK;
        }
 }
@@ -151,6 +153,7 @@ ldns_str2rdf_dname(ldns_rdf **d, const char *str)
 
        uint8_t *s,*p,*q, *pq, val, label_len;
        uint8_t buf[MAX_DOMAINLEN + 1];
+       *d = NULL;
        
        len = strlen((char*)str);
        if (len > MAX_DOMAINLEN) {