Stuff that came out of clang static analysis

diff --git a/dnssec.c b/dnssec.c
index 113b44e2ee93a2cdea19ec0457bdf3a2fa455a5c..52c35ee760f9426352bce7f3d64034f3324bdaf4 100644 (file)
--- a/dnssec.c
+++ b/dnssec.c
@@ -371,7 +371,6 @@ ldns_key_buf2dsa_raw(const unsigned char* key, size_t len)
        offset += length;
 
        Y = BN_bin2bn(key+offset, (int)length, NULL);
-       offset += length;
 
        /* create the key and set its properties */
        if(!Q || !P || !G || !Y || !(dsa = DSA_new())) {

diff --git a/dnssec_sign.c b/dnssec_sign.c
index 207438e085bbf9893dc5df0b67cef610fa113ac9..c6d1dd2f34e00c00e0bf5819b947a91c15297e34 100644 (file)
--- a/dnssec_sign.c
+++ b/dnssec_sign.c
@@ -997,7 +997,6 @@ ldns_dnssec_zone_create_nsec3s_mkmap(ldns_dnssec_zone *zone,
            ; hashmap_node != LDNS_RBTREE_NULL
            ; hashmap_node  = ldns_rbtree_next(hashmap_node)
            ) {
-               current_name = (ldns_dnssec_name *) hashmap_node->data;
                nsec_rr = ((ldns_dnssec_name *) hashmap_node->data)->nsec;
                if (nsec_rr) {
                        ldns_rr_list_push_rr(nsec3_list, nsec_rr);

diff --git a/dnssec_verify.c b/dnssec_verify.c
index 8cf0c7c0c0d8aedf98c0a8be4d38c083060ddac2..d22962eb907ad4b5979292804e0960f85d8bdd0d 100644 (file)
--- a/dnssec_verify.c
+++ b/dnssec_verify.c
@@ -906,8 +906,9 @@ ldns_dnssec_derive_trust_tree_dnskey_rrset_time(
                                cur_status = ldns_verify_rrsig_time(
                                                cur_rrset, cur_sig_rr, 
                                                cur_parent_rr, check_time);
-                               (void) ldns_dnssec_trust_tree_add_parent(new_tree,
-                                           cur_parent_tree, cur_sig_rr, cur_status);
+                               if (ldns_dnssec_trust_tree_add_parent(new_tree,
+                                           cur_parent_tree, cur_sig_rr, cur_status))
+                                       ldns_dnssec_trust_tree_free(cur_parent_tree);
                        }
                }
        }
@@ -1021,8 +1022,10 @@ ldns_dnssec_derive_trust_tree_no_sig_time(
                                                data_chain->parent, 
                                                cur_parent_rr,
                                                check_time);
-                       (void) ldns_dnssec_trust_tree_add_parent(new_tree,
-                                   cur_parent_tree, NULL, result);
+                       if (ldns_dnssec_trust_tree_add_parent(new_tree,
+                                   cur_parent_tree, NULL, result))
+                               ldns_dnssec_trust_tree_free(cur_parent_tree);
+
                }
        }
 }

diff --git a/drill/chasetrace.c b/drill/chasetrace.c
index 1f8a2901ab2658b93bc885e21095e2dbf0c33cd6..dd495db5a969d9741f58780ddee866e00052b158 100644 (file)
--- a/drill/chasetrace.c
+++ b/drill/chasetrace.c
@@ -295,7 +295,7 @@ do_trace(ldns_resolver *local_res, ldns_rdf *name, ldns_rr_type t,
 
        ldns_pkt_free(p);
        p = NULL;
-       status = ldns_resolver_send(&p, res, name, t, c, 0);
+       (void) ldns_resolver_send(&p, res, name, t, c, 0);
        if (!p) {
                goto cleanup;
        }

diff --git a/drill/drill.c b/drill/drill.c
index 74023a731ffd7948f300394055da119ee04a8d70..6efd29a5ca49bb433b140601f2321b2c48cf79ad 100644 (file)
--- a/drill/drill.c
+++ b/drill/drill.c
@@ -366,6 +366,10 @@ main(int argc, char *argv[])
 #ifdef HAVE_SSL
                                if (strchr(optarg, ':')) {
                                        tsig_separator = (size_t) (strchr(optarg, ':') - optarg);
+                                       if (tsig_algorithm) {
+                                               free(tsig_algorithm);
+                                               tsig_algorithm = NULL;
+                                       }
                                        if (strchr(optarg + tsig_separator + 1, ':')) {
                                                tsig_separator2 = (size_t) (strchr(optarg + tsig_separator + 1, ':') - optarg);
                                                tsig_algorithm = xmalloc(strlen(optarg) - tsig_separator2);

diff --git a/drill/securetrace.c b/drill/securetrace.c
index b58d86eea6d71ceb05b371a5acb37d47217270fb..6967265de5500cce89b7f8f22ad8268bded48740 100644 (file)
--- a/drill/securetrace.c
+++ b/drill/securetrace.c
@@ -241,7 +241,7 @@ do_secure_trace(ldns_resolver *local_res, ldns_rdf *name, ldns_rr_type t,
                        goto done;
                }
        }
-       labels = LDNS_XMALLOC(ldns_rdf*, labels_count + 2);
+       labels = LDNS_CALLOC(ldns_rdf*, labels_count + 2);
        if (!labels) {
                goto done;
        }
@@ -256,6 +256,13 @@ do_secure_trace(ldns_resolver *local_res, ldns_rdf *name, ldns_rr_type t,
         */
        for(i = (ssize_t)labels_count + 1; i > 0; i--) {
                status = ldns_resolver_send(&local_p, res, labels[i], LDNS_RR_TYPE_NS, c, 0);
+               if (status != LDNS_STATUS_OK) {
+                       fprintf(stderr, "Error sending query: %s\n", ldns_get_errorstr_by_id(status));
+                       result = status;
+                       goto done;
+               }
+
+               /* TODO: handle status */
 
                if (verbosity >= 5) {
                        ldns_pkt_print(stdout, local_p);

diff --git a/duration.c b/duration.c
index bcd163651f06d54030b52a804fc5e5aaf71fa900..0a8d79b519bc722c16046eae01b7b5ac3e818637 100644 (file)
--- a/duration.c
+++ b/duration.c
@@ -183,7 +183,6 @@ ldns_duration_create_from_string(const char* str)
             return NULL;
         } else {
             duration->weeks = (time_t) atoi(str+1);
-            str = W;
         }
     }
     return duration;

diff --git a/examples/ldns-compare-zones.c b/examples/ldns-compare-zones.c
index 3fa88b495369555153ca4f2fe9cca4072f8bafcf..3cba5444d17c8dae7ba768b9ac80a30818630ab6 100644 (file)
--- a/examples/ldns-compare-zones.c
+++ b/examples/ldns-compare-zones.c
@@ -118,7 +118,6 @@ main(int argc, char **argv)
        argv += optind;
 
        if (argc != 2) {
-               argc -= optind;
                argv -= optind;
                usage(argv[0]);
                exit(EXIT_FAILURE);

diff --git a/examples/ldns-dpa.c b/examples/ldns-dpa.c
index 0a6c07009c946a6c1e5ac746061fcdb390a325ba..1f080e6d53fcc97c90f2dcc44dd97cd0034b0a51 100644 (file)
--- a/examples/ldns-dpa.c
+++ b/examples/ldns-dpa.c
@@ -1650,7 +1650,7 @@ parse_match_expression(char *string)
        match_expression *expr;
        size_t i,j;
        size_t leftstart, leftend = 0;
-       char *left_str, *op, *val;
+       char *left_str, *op = NULL, *val;
        match_table *mt;
        match_operation *mo = NULL;
        const type_operators *tos;
@@ -1658,7 +1658,7 @@ parse_match_expression(char *string)
        ldns_lookup_table *lt = NULL;
 
        /* remove whitespace */
-       char *str = malloc(strlen(string) + 1);
+       char *str = calloc(1, strlen(string) + 1);
 
        j = 0;
        for (i = 0; i < strlen(string); i++) {
@@ -1785,6 +1785,8 @@ parse_match_expression(char *string)
                                if (i > strlen(str)) {
                                        printf("parse error no right hand side: %s\n", str);
                                        result = NULL;
+                                       if (op)
+                                               free(op);
                                        goto done;
                                }
                        }
@@ -1795,6 +1797,8 @@ parse_match_expression(char *string)
                        mt = get_match_by_name(left_str);
                        if (!mt) {
                                printf("parse error: unknown match name: %s\n", left_str);
+                               if (op)
+                                       free(op);
                                result = NULL;
                                goto done;
                        } else {
@@ -1802,6 +1806,8 @@ parse_match_expression(char *string)
                                tos = get_type_operators(mt->type);
                                for (j = 0; j < tos->operator_count; j++) {
                                        if (get_op_id(op) == tos->operators[j]) {
+                                               if (mo)
+                                                       free(mo);
                                                mo = malloc(sizeof(match_operation));
                                                mo->id = mt->id;
                                                mo->operator = get_op_id(op);
@@ -1875,6 +1881,8 @@ parse_match_expression(char *string)
                                if (!mo) {
                                        printf("parse error: operator %s not allowed for match %s\n", op, left_str);
                                        result = NULL;
+                                       if (op)
+                                               free(op);
                                        goto done;
                                }
                        }
@@ -2041,7 +2049,7 @@ handle_ether_packet(const u_char *data, struct pcap_pkthdr cur_hdr, match_counte
        int ip_hdr_size;
        uint8_t protocol;
        size_t data_offset = 0;
-       ldns_rdf *src_addr, *dst_addr;
+       ldns_rdf *src_addr = NULL, *dst_addr = NULL;
        uint8_t *ap;
        char *astr;
        bpf_u_int32 len = cur_hdr.caplen;
@@ -2255,6 +2263,8 @@ printf("timeval: %u ; %u\n", cur_hdr.ts.tv_sec, cur_hdr.ts.tv_usec);
                                                        ldns_pkt_free(pkt);
                                                        ldns_rdf_deep_free(src_addr);
                                                        ldns_rdf_deep_free(dst_addr);
+                                                       if (newdata && newdata != data)
+                                                               free((void *)newdata);
                                                        return 0;
                                                }
                                        } else {
@@ -2293,6 +2303,10 @@ printf("timeval: %u ; %u\n", cur_hdr.ts.tv_sec, cur_hdr.ts.tv_usec);
                                /* tcp packets are skipped */
                                tcp_packets++;
                        }
+                       if (newdata && newdata != data) {
+                               free((void *)newdata);
+                               newdata = NULL;
+                       }
        /* don't have a define for ethertype ipv6 */
        } else  if (ntohs (eptr->ether_type) == ETHERTYPE_IPV6) {
                /*printf("IPv6!\n");*/
@@ -2313,16 +2327,16 @@ printf("timeval: %u ; %u\n", cur_hdr.ts.tv_sec, cur_hdr.ts.tv_usec);
                        if (ldns_str2rdf_aaaa(&src_addr, astr) == LDNS_STATUS_OK) {
                                
                        }
-                       free(astr);
                }
+               free(astr);
                ap = (uint8_t *) &(ip6_hdr->ip6_dst);
                astr = malloc(INET6_ADDRSTRLEN);
                if (inet_ntop(AF_INET6, ap, astr, INET6_ADDRSTRLEN)) {
                        if (ldns_str2rdf_aaaa(&dst_addr, astr) == LDNS_STATUS_OK) {
                                
                        }
-                       free(astr);
                }
+               free(astr);
 
                ip_hdr_size = IP6_HEADER_LENGTH;
                protocol = (uint8_t) ip6_hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt;
@@ -2503,7 +2517,7 @@ parse_uniques(match_id ids[], size_t *count, char *string)
        match_table *mt;
 
        /*printf("Parsing unique counts: '%s'\n", string);*/
-       str = malloc(strlen(string) + 1);
+       str = calloc(1, strlen(string) + 1);
        j = 0;
        for (i = 0; i < strlen(string); i++) {
                if (!isspace((unsigned char)string[i])) {
@@ -2516,7 +2530,10 @@ parse_uniques(match_id ids[], size_t *count, char *string)
        lastpos = 0;
        for (i = 0; i <= strlen(str); i++) {
                if (str[i] == ',' || i >= strlen(str)) {
-                       strpart = malloc(i - lastpos + 1);
+                       if (!(strpart = malloc(i - lastpos + 1))) {
+                               free(str);
+                               return false;
+                       }
                        strncpy(strpart, &str[lastpos], i - lastpos);
                        strpart[i - lastpos] = '\0';
                        if ((mt = get_match_by_name(strpart))) {
@@ -2524,6 +2541,7 @@ parse_uniques(match_id ids[], size_t *count, char *string)
                                *count = *count + 1;
                        } else {
                                printf("Error parsing match list; unknown match name: %s\n", strpart);
+                               free(strpart);
                                free(str);
                                return false;
                        }
@@ -2543,7 +2561,6 @@ parse_uniques(match_id ids[], size_t *count, char *string)
                        return false;
                }
                free(strpart);
-               lastpos = i + 1;
        }
        free(str);
        return true;

diff --git a/examples/ldns-key2ds.c b/examples/ldns-key2ds.c
index be1f8c654ac1df08ec90a04071e16caa46651a34..898755dd3944a162af2e45342ec55fcf67d28642 100644 (file)
--- a/examples/ldns-key2ds.c
+++ b/examples/ldns-key2ds.c
@@ -93,7 +93,6 @@ main(int argc, char *argv[])
        ldns_status result = LDNS_STATUS_OK;
        int sep_only = 1;
 
-       alg = 0;
        h = LDNS_SHA1;
 
        argv++, argc--;

diff --git a/examples/ldns-keyfetcher.c b/examples/ldns-keyfetcher.c
index 10a47ddc4dd92f94bfce97b487ec019ed3b5edaf..a15a63cd9ad328a6a3bd61ce6ae970ca37f58eca 100644 (file)
--- a/examples/ldns-keyfetcher.c
+++ b/examples/ldns-keyfetcher.c
@@ -447,6 +447,7 @@ retrieve_dnskeys(ldns_resolver *local_res, ldns_rdf *name, ldns_rr_type t,
 
                if (!p) {
                        fprintf(stderr, "no packet received\n");
+                       LDNS_FREE(last_nameservers);
                        return NULL;
                }
 
@@ -454,12 +455,14 @@ retrieve_dnskeys(ldns_resolver *local_res, ldns_rdf *name, ldns_rr_type t,
                        fprintf(stderr, "Error: nameserver at ");
                        ldns_rdf_print(stderr, last_nameservers[nss_i]);
                        fprintf(stderr, " not responding. Unable to check RRset here, aborting.\n");
+                       LDNS_FREE(last_nameservers);
                        return NULL;
                }
 
                if (ldns_pkt_get_rcode(p) != LDNS_RCODE_NOERROR) {
                        printf("Error in packet:\n");
                        ldns_pkt_print(stdout, p);
+                       LDNS_FREE(last_nameservers);
                        return NULL;
                }
 

diff --git a/examples/ldns-notify.c b/examples/ldns-notify.c
index 2cbc223383c84502584760051cc1ec6a36540a06..bfd1238475ec78a95d3a2702523a3bc5aabdc4dd 100644 (file)
--- a/examples/ldns-notify.c
+++ b/examples/ldns-notify.c
@@ -344,11 +344,13 @@ main(int argc, char **argv)
        }
 
        status = ldns_pkt2wire(&wire, notify, &wiresize);
-       if(wiresize == 0) {
+       if (status) {
+               printf("Error converting notify packet to hex: %s\n",
+                               ldns_get_errorstr_by_id(status));
+       } else if(wiresize == 0) {
                printf("Error converting notify packet to hex.\n");
                exit(1);
        }
-
        if(do_hexdump && verbose > 1) {
                printf("Hexdump of notify packet:\n");
                for(i=0; i<(int)wiresize; i++)

diff --git a/examples/ldns-nsec3-hash.c b/examples/ldns-nsec3-hash.c
index 0ba2e68aec443b608c55da56f5a5ce1bc9f886e6..f9325d3bd52561a07eda98a09f11251becc6de93 100644 (file)
--- a/examples/ldns-nsec3-hash.c
+++ b/examples/ldns-nsec3-hash.c
@@ -60,6 +60,7 @@ main(int argc, char *argv[])
                                fprintf(stderr, "Salt too long\n");
                                exit(EXIT_FAILURE);
                        }
+                       if (nsec3_salt) LDNS_FREE(nsec3_salt);
                        nsec3_salt_length = (uint8_t) (strlen(optarg) / 2);
                        nsec3_salt = LDNS_XMALLOC(uint8_t, nsec3_salt_length);
                        for (c = 0; c < (int) strlen(optarg); c += 2) {
@@ -97,6 +98,8 @@ main(int argc, char *argv[])
        } else {
                dname = ldns_dname_new_frm_str(argv[0]);
                if (!dname) {
+                       free(prog);
+                       if (nsec3_salt) free(nsec3_salt);
                        fprintf(stderr,
                                "Error: unable to parse domain name\n");
                        return EXIT_FAILURE;
@@ -107,6 +110,8 @@ main(int argc, char *argv[])
                                                    nsec3_salt_length,
                                                    nsec3_salt);
                if (!hashed_dname) {
+                       free(prog);
+                       if (nsec3_salt) free(nsec3_salt);
                        fprintf(stderr,
                                "Error creating NSEC3 hash\n");
                        return EXIT_FAILURE;

diff --git a/examples/ldns-rrsig.c b/examples/ldns-rrsig.c
index a665861600828a4b4a336ca63e8978bf5c3ab63c..6aba96c20e42b42965aa7cf984745d3d6584d711 100644 (file)
--- a/examples/ldns-rrsig.c
+++ b/examples/ldns-rrsig.c
@@ -61,7 +61,7 @@ main(int argc, char *argv[])
 
        if (argc == 3) {
                /* optional type arg */
-               type_name = strdup(argv[2]);
+               type_name = argv[2];
                t = ldns_rdf2rr_type(
                        ldns_rdf_new_frm_str(LDNS_RDF_TYPE_TYPE, type_name));
                if (t == 0) {

diff --git a/examples/ldns-testns.c b/examples/ldns-testns.c
index 144b945717598c3301072920444d5e075eae8af9..3a7dbae7f0e3fa8c7a293e2466d5d49b80d56573 100644 (file)
--- a/examples/ldns-testns.c
+++ b/examples/ldns-testns.c
@@ -326,7 +326,7 @@ handle_tcp(int tcp_sock, struct entry* entries, int *count)
        struct sockaddr_storage addr_him;
        socklen_t hislen;
        uint8_t inbuf[INBUF_SIZE];
-       uint16_t tcplen;
+       uint16_t tcplen = 0;
        struct handle_tcp_userdata userdata;
 
        /* accept */

diff --git a/examples/ldns-testpkts.c b/examples/ldns-testpkts.c
index cc339790df3c430d268285de915786ac67eafa05..c67541d0b1c04f9063894c2f395a0b771dd389f9 100644 (file)
--- a/examples/ldns-testpkts.c
+++ b/examples/ldns-testpkts.c
@@ -35,6 +35,7 @@ static const char* prog_name = "ldns-testpkts";
 void verbose(int lvl, const char* msg, ...) ATTR_FORMAT(printf, 2, 3);
 
 /** print error and exit */
+static void error(const char* msg, ...) __attribute__((noreturn));
 static void error(const char* msg, ...)
 {
        va_list args;

diff --git a/examples/ldns-walk.c b/examples/ldns-walk.c
index 2afe24e24aed899bb9087d76fc3653de5de0c9a6..ae6342dd0878ba9558dba1725ec6d5ca63754339 100644 (file)
--- a/examples/ldns-walk.c
+++ b/examples/ldns-walk.c
@@ -120,7 +120,7 @@ create_plus_1_dname(ldns_rdf *dname)
        return label;
 }
 
-static ldns_status
+static void 
 query_type_bitmaps(ldns_resolver *res, 
                    uint16_t res_flags,
                    const ldns_rdf *name,
@@ -191,11 +191,8 @@ query_type_bitmaps(ldns_resolver *res,
                                }
                        }
                }
-               
                pos += (uint16_t) bitmap_length;
        }
-       
-       return LDNS_STATUS_OK;
 }
 
 
@@ -639,7 +636,7 @@ main(int argc, char *argv[])
                        /* ok, so now we know all the types present at this name,
                         * query for those one by one (...)
                         */
-                       status = query_type_bitmaps(res, LDNS_RD, ldns_rr_owner(nsec_rr),
+                       query_type_bitmaps(res, LDNS_RD, ldns_rr_owner(nsec_rr),
                                           ldns_rr_rdf(nsec_rr, 1));
                        /* print this nsec and its signatures too */
                        ldns_rr_print(stdout, nsec_rr);

diff --git a/examples/ldnsd.c b/examples/ldnsd.c
index c742f04d94450d1a7c56b606f2bc06ad883c50e6..e39c4283e221705ab6e2d9cb7da3efbc3b602142 100644 (file)
--- a/examples/ldnsd.c
+++ b/examples/ldnsd.c
@@ -223,7 +223,7 @@ main(int argc, char **argv)
                if (status != LDNS_STATUS_OK) {
                        printf("Error creating answer: %s\n", ldns_get_errorstr_by_id(status));
                } else {
-                       nb = sendto(sock, (void*)outbuf, answer_size, 0, 
+                       (void) sendto(sock, (void*)outbuf, answer_size, 0, 
                                &addr_him, hislen);
                }
                

diff --git a/host2str.c b/host2str.c
index 1c976dfe76646a981025f0b8b7381bece06c041c..3ca23c2017485caff160caee0225c9113b49f7dc 100644 (file)
--- a/host2str.c
+++ b/host2str.c
@@ -483,7 +483,7 @@ ldns_rdf2buffer_str_str(ldns_buffer *output, const ldns_rdf *rdf)
 ldns_status
 ldns_rdf2buffer_str_b64(ldns_buffer *output, const ldns_rdf *rdf)
 {
-       size_t size = ldns_b64_ntop_calculate_size(ldns_rdf_size(rdf));
+       size_t size;
        char *b64;
 
        if (ldns_rdf_size(rdf) == 0) {
@@ -2327,6 +2327,7 @@ ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k)
                                ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k));
                                 status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k));
                                ldns_buffer_printf(output, ")\n");
+                               if (status) break;
                                status = ldns_ed25519_key2buffer_str(output,
                                        k->_key.key);
                                break;
@@ -2337,6 +2338,7 @@ ldns_key2buffer_str(ldns_buffer *output, const ldns_key *k)
                                ldns_buffer_printf(output, "Algorithm: %d (", ldns_key_algorithm(k));
                                 status=ldns_algorithm2buffer_str(output, (ldns_algorithm)ldns_key_algorithm(k));
                                ldns_buffer_printf(output, ")\n");
+                               if (status) break;
                                status = ldns_ed448_key2buffer_str(output,
                                        k->_key.key);
                                break;

diff --git a/net.c b/net.c
index 0656c1cb8570d94b51fedaed1f1858899a881629..38d00cffac5143650f08da1bd4b7c7fd482eb345 100644 (file)
--- a/net.c
+++ b/net.c
@@ -355,12 +355,7 @@ ldns_tcp_send_from(uint8_t **result,  ldns_buffer *qbin,
                return LDNS_STATUS_NETWORK_ERR;
        }
 
-       /* resize accordingly */
-       *result = LDNS_XREALLOC(answer, uint8_t, (size_t)*answer_size);
-        if(!*result) {
-                LDNS_FREE(answer);
-                return LDNS_STATUS_MEM_ERR;
-        }
+       *result = answer;
        return LDNS_STATUS_OK;
 }
 
@@ -622,10 +617,12 @@ ldns_send_buffer(ldns_pkt **result, ldns_resolver *r, ldns_buffer *qb, ldns_rdf
                
                status = ldns_wire2pkt(&reply, reply_bytes, reply_size);
                if (status != LDNS_STATUS_OK) {
+                       if(src) LDNS_FREE(src);
                        LDNS_FREE(reply_bytes);
                        LDNS_FREE(ns);
                        return status;
                }
+               assert(reply);
                
                LDNS_FREE(ns);
                gettimeofday(&tv_e, NULL);

diff --git a/resolver.c b/resolver.c
index a1a746e5b2b4136363b7c4ad7e1a8e781a367220..84dfe95ba0491b3b97793b814d69a83be36f23a6 100644 (file)
--- a/resolver.c
+++ b/resolver.c
@@ -764,7 +764,7 @@ ldns_resolver_new_frm_fp(ldns_resolver **res, FILE *fp)
 ldns_status
 ldns_resolver_new_frm_fp_l(ldns_resolver **res, FILE *fp, int *line_nr)
 {
-       ldns_resolver *r;
+       ldns_resolver *r = NULL;
        const char *keyword[LDNS_RESOLV_KEYWORDS];
        char word[LDNS_MAX_LINELEN + 1];
        int8_t expect;
@@ -800,7 +800,6 @@ ldns_resolver_new_frm_fp_l(ldns_resolver **res, FILE *fp, int *line_nr)
        keyword[LDNS_RESOLV_SORTLIST] = "sortlist";
        keyword[LDNS_RESOLV_OPTIONS] = "options";
        keyword[LDNS_RESOLV_ANCHOR] = "anchor";
-       expect = LDNS_RESOLV_KEYWORD;
 
        r = ldns_resolver_new();
        if (!r) {
@@ -860,6 +859,7 @@ ldns_resolver_new_frm_fp_l(ldns_resolver **res, FILE *fp, int *line_nr)
                                gtr = ldns_fget_token_l(myfp, word, LDNS_PARSE_NORMAL, 0, line_nr);
                                if (gtr == 0) {
                                        if(!fp) fclose(myfp);
+                                       ldns_resolver_deep_free(r);
                                        return LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR;
                                }
                                 if(word[0] == '#') {
@@ -868,8 +868,8 @@ ldns_resolver_new_frm_fp_l(ldns_resolver **res, FILE *fp, int *line_nr)
                                 }
                                tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, word);
                                if (!tmp) {
-                                       ldns_resolver_deep_free(r);
                                        if(!fp) fclose(myfp);
+                                       ldns_resolver_deep_free(r);
                                        return LDNS_STATUS_SYNTAX_DNAME_ERR;
                                }
 
@@ -882,6 +882,7 @@ ldns_resolver_new_frm_fp_l(ldns_resolver **res, FILE *fp, int *line_nr)
                                gtr = ldns_fget_token_l(myfp, word, LDNS_PARSE_NORMAL, 0, line_nr);
                                if (gtr == 0) {
                                        if(!fp) fclose(myfp);
+                                       ldns_resolver_deep_free(r);
                                        return LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR;
                                }
                                 if(word[0] == '#') {

diff --git a/rr.c b/rr.c
index 9f82bb66e0f84b24b888cd74162d4a2e36ac1a41..9a834e37cf3931ff8b51fe01e454b162bac1325e 100644 (file)
--- a/rr.c
+++ b/rr.c
@@ -395,6 +395,7 @@ ldns_rr_new_frm_str_internal(ldns_rr **newrr, const char *str,
                                rd_buf, rd, delimiters, LDNS_MAX_RDFLEN))) {
 
                        done = true;
+                       (void)done; /* we're breaking, so done not read anymore */
                        break;
                }
                /* hmmz, rfc3597 specifies that any type can be represented 

diff --git a/sha1.c b/sha1.c
index 18a4dd28f34e3f549724c6b43c0c05ce00895f41..96e8f968309c3051d2a340ce25928b5174f18da9 100644 (file)
--- a/sha1.c
+++ b/sha1.c
@@ -97,6 +97,7 @@ ldns_sha1_transform(uint32_t state[5], const unsigned char buffer[LDNS_SHA1_BLOC
     state[4] += e;
     /* Wipe variables */
     a = b = c = d = e = 0;
+    (void)a;
 }
 
 

diff --git a/sha2.c b/sha2.c
index 9a27122bfe1e3b38a39252b9dc76c227231bc9ff..e0b1f4b911539764c5f88db6b468516f6a41e270 100644 (file)
--- a/sha2.c
+++ b/sha2.c
@@ -494,6 +494,7 @@ static void ldns_sha256_Transform(ldns_sha256_CTX* context,
 
        /* Clean up */
        a = b = c = d = e = f = g = h = T1 = T2 = 0;
+       (void)a;
 }
 
 #endif /* SHA2_UNROLL_TRANSFORM */
@@ -527,6 +528,7 @@ void ldns_sha256_update(ldns_sha256_CTX* context, const sha2_byte *data, size_t
                        context->bitcount += len << 3;
                        /* Clean up: */
                        usedspace = freespace = 0;
+                       (void)usedspace;
                        return;
                }
        }
@@ -544,6 +546,7 @@ void ldns_sha256_update(ldns_sha256_CTX* context, const sha2_byte *data, size_t
        }
        /* Clean up: */
        usedspace = freespace = 0;
+       (void)usedspace;
 }
 
 typedef union _ldns_sha2_buffer_union {
@@ -614,6 +617,7 @@ void ldns_sha256_final(sha2_byte digest[], ldns_sha256_CTX* context) {
        /* Clean up state data: */
        MEMSET_BZERO(context, sizeof(ldns_sha256_CTX));
        usedspace = 0;
+       (void)usedspace;
 }
 
 unsigned char *
@@ -803,6 +807,7 @@ static void ldns_sha512_Transform(ldns_sha512_CTX* context,
 
        /* Clean up */
        a = b = c = d = e = f = g = h = T1 = T2 = 0;
+       (void)a;
 }
 
 #endif /* SHA2_UNROLL_TRANSFORM */
@@ -836,6 +841,7 @@ void ldns_sha512_update(ldns_sha512_CTX* context, const sha2_byte *data, size_t
                        ADDINC128(context->bitcount, len << 3);
                        /* Clean up: */
                        usedspace = freespace = 0;
+                       (void)usedspace;
                        return;
                }
        }
@@ -853,6 +859,7 @@ void ldns_sha512_update(ldns_sha512_CTX* context, const sha2_byte *data, size_t
        }
        /* Clean up: */
        usedspace = freespace = 0;
+       (void)usedspace;
 }
 
 static void ldns_sha512_Last(ldns_sha512_CTX* context) {

diff --git a/str2host.c b/str2host.c
index a0b7650e1d28c35c271962b15c562575951707a6..435ad1a4343585b841ded35062959cfece48a930 100644 (file)
--- a/str2host.c
+++ b/str2host.c
@@ -57,13 +57,13 @@ ldns_status
 ldns_str2rdf_time(ldns_rdf **rd, const char *time)
 {
        /* convert a time YYYYDDMMHHMMSS to wireformat */
-       uint16_t *r = NULL;
+       uint32_t *r = NULL;
        struct tm tm;
        uint32_t l;
        char *end;
 
        /* Try to scan the time... */
-       r = (uint16_t*)LDNS_MALLOC(uint32_t);
+       r = (uint32_t *)LDNS_MALLOC(uint32_t);
         if(!r) return LDNS_STATUS_MEM_ERR;
 
        memset(&tm, 0, sizeof(tm));
@@ -197,10 +197,10 @@ ldns_status
 ldns_str2rdf_int32(ldns_rdf **rd, const char *longstr)
 {
        char *end;
-       uint16_t *r = NULL;
+       uint32_t *r = NULL;
        uint32_t l;
 
-       r = (uint16_t*)LDNS_MALLOC(uint32_t);
+       r = (uint32_t*)LDNS_MALLOC(uint32_t);
         if(!r) return LDNS_STATUS_MEM_ERR;
        errno = 0; /* must set to zero before call,
                        note race condition on errno */
@@ -1579,7 +1579,7 @@ ldns_str2rdf_hip(ldns_rdf **rd, const char *str)
        size_t rdf_size = 4 + hit_wire_size + pk_wire_size;
 
        char *endptr; /* utility var for strtol usage */
-       int algorithm = strtol(str, &endptr, 10);
+       int algorithm = str == NULL ? 0 : strtol(str, &endptr, 10);
 
        uint8_t *data, *dp;
        int hi, lo, written;