#include <arpa/inet.h>
#endif
+static bool
+ldns_dname_has_root_label(const ldns_rdf* dname)
+{
+ size_t src_pos;
+ size_t len = 0;
+
+ for (src_pos = 0; src_pos < ldns_rdf_size(dname); src_pos += len + 1) {
+ len = ldns_rdf_data(dname)[src_pos];
+ }
+ assert(src_pos == ldns_rdf_size(dname));
+
+ return src_pos > 0 && len == 0;
+}
+
ldns_rdf *
ldns_dname_cat_clone(const ldns_rdf *rd1, const ldns_rdf *rd2)
{
* rd, by reducing the size with 1
*/
left_size = ldns_rdf_size(rd1);
- if (left_size > 0 &&ldns_rdf_data(rd1)[left_size - 1] == 0) {
+ if (ldns_dname_has_root_label(rd1)) {
left_size--;
}
* rd, by reducing the size with 1
*/
left_size = ldns_rdf_size(rd1);
- if (left_size > 0 &&ldns_rdf_data(rd1)[left_size - 1] == 0) {
+ if (ldns_dname_has_root_label(rd1)) {
left_size--;
}
return LDNS_STATUS_OK;
}
-ldns_rdf *
-ldns_dname_reverse(const ldns_rdf *d)
+ldns_rdf*
+ldns_dname_reverse(const ldns_rdf *dname)
{
- ldns_rdf *new;
- ldns_rdf *tmp;
- ldns_rdf *d_tmp;
- ldns_status status;
-
- d_tmp = ldns_rdf_clone(d);
-
- new = ldns_dname_new_frm_str(".");
- if(!new)
- return NULL;
-
- while(ldns_dname_label_count(d_tmp) > 0) {
- tmp = ldns_dname_label(d_tmp, 0);
- status = ldns_dname_cat(tmp, new);
- if(status != LDNS_STATUS_OK) {
- ldns_rdf_deep_free(new);
- ldns_rdf_deep_free(d_tmp);
- return NULL;
- }
- ldns_rdf_deep_free(new);
- new = tmp;
- tmp = ldns_dname_left_chop(d_tmp);
- ldns_rdf_deep_free(d_tmp);
- d_tmp = tmp;
+ size_t rd_size;
+ uint8_t* buf;
+ ldns_rdf* new;
+ size_t src_pos;
+ size_t len ;
+
+ assert(ldns_rdf_get_type(dname) == LDNS_RDF_TYPE_DNAME);
+
+ rd_size = ldns_rdf_size(dname);
+ buf = LDNS_XMALLOC(uint8_t, rd_size);
+ if (! buf) {
+ return NULL;
+ }
+ new = ldns_rdf_new(LDNS_RDF_TYPE_DNAME, rd_size, buf);
+ if (! new) {
+ LDNS_FREE(buf);
+ return NULL;
+ }
+
+ /* If dname ends in a root label, the reverse should too.
+ */
+ if (ldns_dname_has_root_label(dname)) {
+ buf[rd_size - 1] = 0;
+ rd_size -= 1;
+ }
+ for (src_pos = 0; src_pos < rd_size; src_pos += len + 1) {
+ len = ldns_rdf_data(dname)[src_pos];
+ memcpy(&buf[rd_size - src_pos - len - 1],
+ &ldns_rdf_data(dname)[src_pos], len + 1);
}
- ldns_rdf_deep_free(d_tmp);
-
return new;
}
salt_length,
salt);
status = ldns_dname_cat(hashed_owner, cur_zone);
- if(status != LDNS_STATUS_OK)
+ if(status != LDNS_STATUS_OK) {
+ ldns_rdf_deep_free(hashed_owner);
return NULL;
-
+ }
nsec = ldns_rr_new_frm_type(LDNS_RR_TYPE_NSEC3);
- if(!nsec)
+ if(!nsec) {
+ ldns_rdf_deep_free(hashed_owner);
return NULL;
+ }
ldns_rr_set_type(nsec, LDNS_RR_TYPE_NSEC3);
ldns_rr_set_owner(nsec, hashed_owner);
sigs = s;
} else {
/* otherwise get them from the packet */
- sigs = ldns_pkt_rr_list_by_name_and_type(p, o, LDNS_RR_TYPE_RRSIG,
- LDNS_SECTION_ANY_NOQUESTION);
+ sigs = ldns_pkt_rr_list_by_name_and_type(p, o,
+ LDNS_RR_TYPE_RRSIG,
+ LDNS_SECTION_ANY_NOQUESTION);
if (!sigs) {
/* no sigs */
return LDNS_STATUS_ERR;
*/
t_netorder = htons(t); /* rdf are in network order! */
/* a type identifier is a 16-bit number, so the size is 2 bytes */
- rdf_t = ldns_rdf_new(LDNS_RDF_TYPE_TYPE,
- 2,
- &t_netorder);
- sigs_covered = ldns_rr_list_subtype_by_rdf(sigs, rdf_t, 0);
+ rdf_t = ldns_rdf_new(LDNS_RDF_TYPE_TYPE, 2, &t_netorder);
- rrset = ldns_pkt_rr_list_by_name_and_type(p,
- o,
- t,
- LDNS_SECTION_ANY_NOQUESTION);
-
- if (!rrset) {
+ sigs_covered = ldns_rr_list_subtype_by_rdf(sigs, rdf_t, 0);
+ ldns_rdf_deep_free(rdf_t);
+ if (! sigs_covered) {
+ if (! s) {
+ ldns_rr_list_deep_free(sigs);
+ }
return LDNS_STATUS_ERR;
}
+ ldns_rr_list_deep_free(sigs_covered);
- if (!sigs_covered) {
+ rrset = ldns_pkt_rr_list_by_name_and_type(p, o, t,
+ LDNS_SECTION_ANY_NOQUESTION);
+ if (!rrset) {
+ if (! s) {
+ ldns_rr_list_deep_free(sigs);
+ }
return LDNS_STATUS_ERR;
}
-
return ldns_verify_time(rrset, sigs, k, check_time, good_keys);
}
ldns_buffer_free(sign_buf);
/* ERROR */
ldns_rr_list_deep_free(rrset_clone);
+ ldns_rr_free(current_sig);
+ ldns_rr_list_deep_free(signatures);
return NULL;
}
!= LDNS_STATUS_OK) {
ldns_buffer_free(sign_buf);
ldns_rr_list_deep_free(rrset_clone);
+ ldns_rr_free(current_sig);
+ ldns_rr_list_deep_free(signatures);
return NULL;
}
if (!b64rdf) {
/* signing went wrong */
ldns_rr_list_deep_free(rrset_clone);
+ ldns_rr_free(current_sig);
+ ldns_rr_list_deep_free(signatures);
return NULL;
}
(unsigned char*)ldns_buffer_begin(b64sig),
&siglen, key);
if (result != 1) {
- return NULL;
- }
-
- if (result != 1) {
+ ldns_buffer_free(b64sig);
return NULL;
}
ldns_rbtree_next(current_name_node));
}
if (result != LDNS_STATUS_OK) {
+ ldns_rr_list_free(nsec3_list);
return result;
}
ldns_rr_list_sort_nsec3(nsec3_list);
result = ldns_dnssec_chain_nsec3_list(nsec3_list);
- if (result != LDNS_STATUS_OK) {
- return result;
- }
-
ldns_rr_list_free(nsec3_list);
+
return result;
}
if (signatures && ldns_rr_list_rr_count(signatures) > 0) {
key_name = ldns_rr_rdf(ldns_rr_list_rr(signatures, 0), 7);
}
-
if (!key_name) {
+ if (signatures) {
+ ldns_rr_list_deep_free(signatures);
+ }
return ldns_dnssec_build_data_chain_nokeyname(res,
qflags,
orig_rr,
rrset,
new_chain);
}
-
if (type != LDNS_RR_TYPE_DNSKEY) {
ldns_dnssec_build_data_chain_dnskey(res,
qflags,
new_chain,
key_name,
c
- );
+ );
} else {
ldns_dnssec_build_data_chain_other(res,
qflags,
key_name,
c,
dss
-
- );
+ );
}
if (signatures) {
ldns_rr_list_deep_free(signatures);
}
-
return new_chain;
}
/* might contain different names!
sort and split */
ldns_rr_list_sort(cur_rrset);
- if (tmp_rrset && tmp_rrset != cur_rrset) {
- ldns_rr_list_deep_free(tmp_rrset);
- tmp_rrset = NULL;
- }
+ assert(tmp_rrset == cur_rrset);
tmp_rrset = ldns_rr_list_pop_rrset(cur_rrset);
/* with nsecs, this might be the wrong one */
cur_sig_rr,
cur_parent_rr,
check_time);
+ if (tmp_rrset && tmp_rrset != cur_rrset
+ ) {
+ ldns_rr_list_deep_free(
+ tmp_rrset);
+ tmp_rrset = NULL;
+ }
/* avoid dupes */
for (i = 0; i < new_tree->parent_count; i++) {
if (cur_parent_rr == new_tree->parents[i]->rr) {
}
}
done:
- if (tmp_rrset && tmp_rrset != cur_rrset) {
- ldns_rr_list_deep_free(tmp_rrset);
- }
ldns_rr_list_deep_free(cur_rrset);
}
rr_name = ldns_rr_owner(rr);
chopped_dname = ldns_dname_left_chop(rr_name);
result = ldns_dname_cat(wildcard_name, chopped_dname);
+ ldns_rdf_deep_free(chopped_dname);
if (result != LDNS_STATUS_OK) {
return result;
}
- ldns_rdf_deep_free(chopped_dname);
-
for (i = 0; i < ldns_rr_list_rr_count(nsecs); i++) {
cur_nsec = ldns_rr_list_rr(nsecs, i);
if (ldns_dname_compare(rr_name, ldns_rr_owner(cur_nsec)) == 0) {
case LDNS_STATUS_SYNTAX_EMPTY: /* empty line was seen */
case LDNS_STATUS_SYNTAX_TTL: /* the ttl was set*/
case LDNS_STATUS_SYNTAX_ORIGIN: /* the origin was set*/
+ status = LDNS_STATUS_OK;
break;
case LDNS_STATUS_SYNTAX_INCLUDE:/* $include not implemented */
if (ldns_rr_list_rr_count(todo_nsec3s) > 0) {
(void) ldns_dnssec_zone_add_empty_nonterminals(newzone);
- for (i = 0; i < ldns_rr_list_rr_count(todo_nsec3s); i++) {
+ for (i = 0; status == LDNS_STATUS_OK &&
+ i < ldns_rr_list_rr_count(todo_nsec3s); i++) {
cur_rr = ldns_rr_list_rr(todo_nsec3s, i);
status = ldns_dnssec_zone_add_rr(newzone, cur_rr);
}
- for (i = 0; i < ldns_rr_list_rr_count(todo_nsec3_rrsigs); i++){
+ for (i = 0; status == LDNS_STATUS_OK &&
+ i < ldns_rr_list_rr_count(todo_nsec3_rrsigs);
+ i++){
cur_rr = ldns_rr_list_rr(todo_nsec3_rrsigs, i);
status = ldns_dnssec_zone_add_rr(newzone, cur_rr);
}
} else if (ldns_rr_list_rr_count(todo_nsec3_rrsigs) > 0) {
- for (i = 0; i < ldns_rr_list_rr_count(todo_nsec3_rrsigs); i++){
+ for (i = 0; status == LDNS_STATUS_OK &&
+ i < ldns_rr_list_rr_count(todo_nsec3_rrsigs);
+ i++){
cur_rr = ldns_rr_list_rr(todo_nsec3_rrsigs, i);
status = ldns_dnssec_zone_add_rr(newzone, cur_rr);
}
}
- ldns_rr_list_free(todo_nsec3_rrsigs);
- ldns_rr_list_free(todo_nsec3s);
-
if (z) {
*z = newzone;
+ newzone = NULL;
} else {
ldns_dnssec_zone_free(newzone);
}
- return LDNS_STATUS_OK;
-
error:
#ifdef FASTER_DNSSEC_ZONE_NEW_FRM_FP
if (zone) {
ldns_zone_free(zone);
}
#endif
+ ldns_rr_list_free(todo_nsec3_rrsigs);
+ ldns_rr_list_free(todo_nsec3s);
+
if (my_origin) {
ldns_rdf_deep_free(my_origin);
}
p = ldns_pkt_new();
res = ldns_resolver_new();
- if (!p || !res) {
+ if (!p) {
+ if (res) {
+ ldns_resolver_free(res);
+ }
+ error("Memory allocation failed");
+ return NULL;
+ }
+ if (!res) {
+ ldns_pkt_free(p);
error("Memory allocation failed");
return NULL;
}
if (status != LDNS_STATUS_OK) {
fprintf(stderr, "Error adding root servers to resolver: %s\n", ldns_get_errorstr_by_id(status));
ldns_rr_list_print(stdout, global_dns_root);
+ ldns_resolver_free(res);
+ ldns_pkt_free(p);
return NULL;
}
p = ldns_pkt_new();
found = NULL;
- if (ldns_resolver_send(&p, res, zname, t, c, 0) != LDNS_STATUS_OK) {
- /* oops */
- return NULL;
- } else {
+ if (ldns_resolver_send(&p, res, zname, t, c, 0) == LDNS_STATUS_OK) {
found = ldns_pkt_rr_list_by_type(p, t, LDNS_SECTION_ANY_NOQUESTION);
}
+ ldns_pkt_free(p);
return found;
}
{
ldns_rr_list *new_nss;
ldns_rr_list *hostnames;
+ char *answerfrom_str;
if (verbosity < 5) {
return;
new_nss = ldns_pkt_rr_list_by_type(p,
LDNS_RR_TYPE_NS, LDNS_SECTION_ANSWER);
ldns_rr_list_print(fd, new_nss);
-
- /* new_nss can be empty.... */
+ ldns_rr_list_deep_free(new_nss);
fprintf(fd, ";; Received %d bytes from %s#%d(",
(int) ldns_pkt_size(p),
ldns_rr_rdf(ldns_rr_list_rr(hostnames, 0), 0));
ldns_rr_list_deep_free(hostnames);
} else {
- fprintf(fd, "%s", ldns_rdf2str(ldns_pkt_answerfrom(p)));
+ answerfrom_str = ldns_rdf2str(ldns_pkt_answerfrom(p));
+ if (answerfrom_str) {
+ fprintf(fd, "%s", answerfrom_str);
+ LDNS_FREE(answerfrom_str);
+ }
}
fprintf(fd, ") in %u ms\n\n", (unsigned int)ldns_pkt_querytime(p));
}
drill_pkt_print_footer(FILE *fd, ldns_resolver *r, ldns_pkt *p)
{
ldns_rr_list *hostnames;
+ char *answerfrom_str;
if (verbosity < 5) {
return;
ldns_rr_rdf(ldns_rr_list_rr(hostnames, 0), 0));
ldns_rr_list_deep_free(hostnames);
} else {
- fprintf(fd, "%s", ldns_rdf2str(ldns_pkt_answerfrom(p)));
+ answerfrom_str = ldns_rdf2str(ldns_pkt_answerfrom(p));
+ if (answerfrom_str) {
+ fprintf(fd, "%s", answerfrom_str);
+ LDNS_FREE(answerfrom_str);
+ }
}
fprintf(fd, ") in %u ms\n\n", (unsigned int)ldns_pkt_querytime(p));
}
ldns_rr_list **rrlist, ldns_rr_list **sig)
{
ldns_pkt_type pt = LDNS_PACKET_UNKNOWN;
- ldns_rr_list *rr = NULL;
ldns_rr_list *sigs = NULL;
size_t i;
pt = ldns_pkt_reply_type(p);
if (name) {
- rr = ldns_pkt_rr_list_by_name_and_type(p, name, t, LDNS_SECTION_ANSWER);
- if (!rr) {
- rr = ldns_pkt_rr_list_by_name_and_type(p, name, t, LDNS_SECTION_AUTHORITY);
+ if (rrlist) {
+ *rrlist = ldns_pkt_rr_list_by_name_and_type(p, name, t,
+ LDNS_SECTION_ANSWER);
+ if (!*rrlist) {
+ *rrlist = ldns_pkt_rr_list_by_name_and_type(
+ p, name, t,
+ LDNS_SECTION_AUTHORITY);
+ }
}
- sigs = ldns_pkt_rr_list_by_name_and_type(p, name, LDNS_RR_TYPE_RRSIG,
- LDNS_SECTION_ANSWER);
- if (!sigs) {
- sigs = ldns_pkt_rr_list_by_name_and_type(p, name, LDNS_RR_TYPE_RRSIG,
- LDNS_SECTION_AUTHORITY);
+ if (sig) {
+ sigs = ldns_pkt_rr_list_by_name_and_type(p, name,
+ LDNS_RR_TYPE_RRSIG,
+ LDNS_SECTION_ANSWER);
+ if (!sigs) {
+ sigs = ldns_pkt_rr_list_by_name_and_type(
+ p, name, LDNS_RR_TYPE_RRSIG,
+ LDNS_SECTION_AUTHORITY);
+ }
}
} else {
- /* A DS-referral - get the DS records if they are there */
- rr = ldns_pkt_rr_list_by_type(p, t, LDNS_SECTION_AUTHORITY);
- sigs = ldns_pkt_rr_list_by_type(p, LDNS_RR_TYPE_RRSIG,
- LDNS_SECTION_AUTHORITY);
+ /* A DS-referral - get the DS records if they are there */
+ if (rrlist) {
+ *rrlist = ldns_pkt_rr_list_by_type(
+ p, t, LDNS_SECTION_AUTHORITY);
+ }
+ if (sig) {
+ sigs = ldns_pkt_rr_list_by_type(p,
+ LDNS_RR_TYPE_RRSIG,
+ LDNS_SECTION_AUTHORITY);
+ }
}
if (sig) {
*sig = ldns_rr_list_new();
for (i = 0; i < ldns_rr_list_rr_count(sigs); i++) {
/* only add the sigs that cover this type */
- if (ldns_rdf2rr_type(ldns_rr_rrsig_typecovered(ldns_rr_list_rr(sigs, i))) ==
- t) {
- ldns_rr_list_push_rr(*sig, ldns_rr_clone(ldns_rr_list_rr(sigs, i)));
+ if (t == ldns_rdf2rr_type(ldns_rr_rrsig_typecovered(
+ ldns_rr_list_rr(sigs, i)))) {
+
+ ldns_rr_list_push_rr(*sig,
+ ldns_rr_clone(
+ ldns_rr_list_rr(
+ sigs, i)));
}
}
}
ldns_rr_list_deep_free(sigs);
- if (rrlist) {
- *rrlist = rr;
- }
if (pt == LDNS_PACKET_NXDOMAIN || pt == LDNS_PACKET_NODATA) {
return pt;
ldns_rr_list* sigs = ldns_pkt_rr_list_by_type(pkt, LDNS_RR_TYPE_RRSIG, LDNS_SECTION_ANY_NOQUESTION);
ldns_rr* q = ldns_rr_new();
ldns_rr* match = NULL;
- if(!sigs) return LDNS_STATUS_MEM_ERR;
- if(!q) return LDNS_STATUS_MEM_ERR;
+
+ if(!sigs) {
+ if (q) {
+ ldns_rr_free(q);
+ }
+ ldns_rr_list_deep_free(nsecs);
+ return LDNS_STATUS_MEM_ERR;
+ }
+ if(!q) {
+ ldns_rr_list_deep_free(nsecs);
+ ldns_rr_list_deep_free(sigs);
+ return LDNS_STATUS_MEM_ERR;
+ }
ldns_rr_set_question(q, 1);
ldns_rr_set_ttl(q, 0);
ldns_rr_set_owner(q, ldns_rdf_clone(name));
- if(!ldns_rr_owner(q)) return LDNS_STATUS_MEM_ERR;
+ if(!ldns_rr_owner(q)) {
+ ldns_rr_free(q);
+ ldns_rr_list_deep_free(sigs);
+ ldns_rr_list_deep_free(nsecs);
+ return LDNS_STATUS_MEM_ERR;
+ }
ldns_rr_set_type(q, type);
/* result = ldns_dnssec_verify_denial_nsec3(q, nsecs, sigs, ldns_pkt_get_rcode(pkt), type, ldns_pkt_ancount(pkt) == 0); */
ds = ldns_key_rr2ds(ldns_rr_list_rr(keys, i), LDNS_SHA256);
local_print_ds(stdout, "; sha256: ", ds);
}
+ ldns_rr_list_deep_free(keys);
}
}
if (status != LDNS_STATUS_OK) {
printf("ERRRRR: %s\n", ldns_get_errorstr_by_id(status));
ldns_rr_list_print(stdout, global_dns_root);
- return status;
+ result = status;
+ goto done;
}
labels_count = ldns_dname_label_count(name);
if (start_name) {
if (status != LDNS_STATUS_OK) {
error("Unable to convert packet: error code %u", status);
+ LDNS_FREE(wire);
return;
}
ssl_err(s);
} else {
fprintf(stderr, "error: %s\n", ldns_get_errorstr_by_id(err));
+ assert(0);
exit(EXIT_FAILURE);
}
}
if (! insecure_is_ok) {
error:
ldns_rr_list_deep_free(*rrs);
- *rrs = NULL;
+ *rrs = ldns_rr_list_new();
}
cleanup:
if (keys) {
char *
ldns_buffer_export2str(ldns_buffer *buffer)
{
- /* check if buffer ends with \0, if not, and
- if there is space, add it */
- if (*(ldns_buffer_at(buffer, ldns_buffer_position(buffer))) != 0) {
- if (!ldns_buffer_reserve(buffer, 1)) {
- return NULL;
- }
- ldns_buffer_write_u8(buffer, (uint8_t) '\0');
- if (!ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer))) {
- return NULL;
- }
+ /* Append '\0' as string terminator */
+ if (! ldns_buffer_reserve(buffer, 1)) {
+ return NULL;
}
+ ldns_buffer_write_u8(buffer, 0);
+ /* reallocate memory to the size of the string and export */
+ ldns_buffer_set_capacity(buffer, ldns_buffer_position(buffer));
return ldns_buffer_export(buffer);
}
echo start the test at `date` in `pwd`
$TPKG clean
$TPKG -a ../.. fake 01-compile.tpkg
+$TPKG -a ../.. fake 02-lint.tpkg
$TPKG -a ../.. fake 07-compile-examples.tpkg
$TPKG -a ../.. fake 16-compile-builddir.tpkg
$TPKG -a ../.. fake 999-compile-nossl.tpkg
+$TPKG -a ../.. fake codingstyle.tpkg
for tests in *.tpkg
do
projects / thirdparty / ldns.git / commitdiff
