44 #include <ldns/ldns.h>
46 static const char* zd_str =
"data";
48 static ldns_rbnode_t* domain2node(
domain_type* domain);
55 log_rdf(ldns_rdf *rdf,
const char* pre,
int level)
61 str = ldns_rdf2str(rdf);
64 ods_log_error(
"[%s] %s : %s", zd_str, pre?pre:
"", str?str:
"(null)");
65 }
else if (level == 2) {
67 }
else if (level == 3) {
68 ods_log_info(
"[%s] %s : %s", zd_str, pre?pre:
"", str?str:
"(null)");
69 }
else if (level == 4) {
71 }
else if (level == 5) {
72 ods_log_debug(
"[%s] %s : %s", zd_str, pre?pre:
"", str?str:
"(null)");
73 }
else if (level == 6) {
92 ldns_rbnode_t* node = (ldns_rbnode_t*) malloc(
sizeof(ldns_rbnode_t));
96 node->key = domain->
dname;
106 static ldns_rbnode_t*
109 ldns_rbnode_t* node = (ldns_rbnode_t*) malloc(
sizeof(ldns_rbnode_t));
113 node->key = denial->
owner;
124 domain_compare(
const void* a,
const void* b)
126 ldns_rdf* x = (ldns_rdf*)a;
127 ldns_rdf* y = (ldns_rdf*)b;
128 return ldns_dname_compare(x, y);
154 zd->
domains = ldns_rbtree_create(domain_compare);
170 ods_log_error(
"[%s] cannot create zonedata: no allocator", zd_str);
177 ods_log_error(
"[%s] cannot create zonedata: allocator failed",
184 zonedata_init_domains(zd);
202 const char* token = NULL;
203 const char* owner = NULL;
207 ldns_rdf* rdf = NULL;
208 ldns_rbnode_t* denial_node = LDNS_RBTREE_NULL;
221 goto recover_domain_error;
224 rdf = ldns_dname_new_frm_str(owner);
227 ldns_rdf_deep_free(rdf);
233 goto recover_domain_error;
239 goto recover_domain_error;
242 denial_node = denial2node(domain->
denial);
244 if (!ldns_rbtree_insert(zd->
denial_chain, denial_node)) {
246 free((
void*)denial_node);
247 goto recover_domain_error;
264 goto recover_domain_error;
271 goto recover_domain_error;
276 recover_domain_error:
292 zonedata_domain_search(ldns_rbtree_t* tree, ldns_rdf* dname)
294 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
296 if (!tree || !dname) {
299 node = ldns_rbtree_search(tree, dname);
300 if (node && node != LDNS_RBTREE_NULL) {
314 if (!zd)
return NULL;
316 return zonedata_domain_search(zd->
domains, dname);
327 ldns_rbnode_t* new_node = LDNS_RBTREE_NULL;
330 ods_log_error(
"[%s] unable to add domain: no domain", zd_str);
336 log_rdf(domain->
dname,
"unable to add domain, no storage", 1);
342 new_node = domain2node(domain);
343 if (ldns_rbtree_insert(zd->
domains, new_node) == NULL) {
344 log_rdf(domain->
dname,
"unable to add domain, already present", 1);
345 free((
void*)new_node);
358 zonedata_del_domain_fixup(ldns_rbtree_t* tree,
domain_type* domain)
361 ldns_rbnode_t* del_node = LDNS_RBTREE_NULL;
367 del_node = ldns_rbtree_search(tree, (
const void*)domain->
dname);
369 del_node = ldns_rbtree_delete(tree, (
const void*)domain->
dname);
372 free((
void*)del_node);
375 log_rdf(domain->
dname,
"unable to del domain, not found", 1);
389 ods_log_error(
"[%s] unable to delete domain: no domain", zd_str);
396 log_rdf(domain->
dname,
"unable to delete domain, no zonedata", 1);
403 log_rdf(domain->
dname,
"unable to delete domain, failed to delete "
404 "denial of existence data point", 1);
409 return zonedata_del_domain_fixup(zd->
domains, domain);
418 zonedata_denial_search(ldns_rbtree_t* tree, ldns_rdf* dname)
420 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
422 if (!tree || !dname) {
425 node = ldns_rbtree_search(tree, dname);
426 if (node && node != LDNS_RBTREE_NULL) {
440 if (!zd)
return NULL;
453 ldns_rdf* hashed_ownername = NULL;
454 ldns_rdf* hashed_label = NULL;
464 hashed_label = ldns_nsec3_hash_name(dname, nsec3params->
algorithm,
468 log_rdf(dname,
"unable to hash dname, hash failed", 1);
471 hashed_ownername = ldns_dname_cat_clone((
const ldns_rdf*) hashed_label,
472 (
const ldns_rdf*) apex);
473 if (!hashed_ownername) {
474 log_rdf(dname,
"unable to hash dname, concat apex failed", 1);
477 ldns_rdf_deep_free(hashed_label);
478 return hashed_ownername;
490 ldns_rbnode_t* new_node = LDNS_RBTREE_NULL;
491 ldns_rbnode_t* prev_node = LDNS_RBTREE_NULL;
492 ldns_rdf* owner = NULL;
497 ods_log_error(
"[%s] unable to add denial of existence data point: "
498 "no domain", zd_str);
504 log_rdf(domain->
dname,
"unable to add denial of existence data "
505 "point for domain, no denial chain", 1);
512 log_rdf(domain->
dname,
"unable to add denial of existence data "
513 "point for domain, apex unknown", 1);
520 owner = dname_hash(domain->
dname, apex, nsec3params);
522 log_rdf(domain->
dname,
"unable to add denial of existence data "
523 "point for domain, dname hash failed", 1);
527 owner = ldns_rdf_clone(domain->
dname);
531 log_rdf(domain->
dname,
"unable to add denial of existence for "
532 "domain, data point exists", 1);
537 new_node = denial2node(denial);
538 ldns_rdf_deep_free(owner);
541 log_rdf(domain->
dname,
"unable to add denial of existence for "
542 "domain, insert failed", 1);
543 free((
void*)new_node);
550 prev_node = ldns_rbtree_previous(new_node);
551 if (!prev_node || prev_node == LDNS_RBTREE_NULL) {
569 zonedata_del_denial_fixup(ldns_rbtree_t* tree,
denial_type* denial)
573 ldns_rbnode_t* prev_node = LDNS_RBTREE_NULL;
574 ldns_rbnode_t* del_node = LDNS_RBTREE_NULL;
581 del_node = ldns_rbtree_search(tree, (
const void*)denial->
owner);
587 prev_node = ldns_rbtree_previous(del_node);
588 if (!prev_node || prev_node == LDNS_RBTREE_NULL) {
589 prev_node = ldns_rbtree_last(tree);
601 "point: failed to wipe out NSEC RRset", zd_str);
607 "point: failed to commit NSEC RRset", zd_str);
612 del_node = ldns_rbtree_delete(tree, (
const void*)denial->
owner);
615 free((
void*)del_node);
618 log_rdf(denial->
owner,
"unable to del denial of existence data "
619 "point, not found", 1);
633 ods_log_error(
"[%s] unable to delete denial of existence data "
634 "point: no data point", zd_str);
640 log_rdf(denial->
owner,
"unable to delete denial of existence data "
641 "point, no zone data", 1);
647 return zonedata_del_denial_fixup(zd->
denial_chain, denial);
658 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
665 if (zd->
domains->root != LDNS_RBTREE_NULL) {
666 node = ldns_rbtree_first(zd->
domains);
668 while (node && node != LDNS_RBTREE_NULL) {
674 node = ldns_rbtree_next(node);
687 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
688 ldns_rbnode_t* nxtnode = LDNS_RBTREE_NULL;
689 ldns_rbnode_t* tmpnode = LDNS_RBTREE_NULL;
697 if (zd->
domains->root != LDNS_RBTREE_NULL) {
698 node = ldns_rbtree_last(zd->
domains);
700 while (node && node != LDNS_RBTREE_NULL) {
707 node = ldns_rbtree_previous(node);
712 nxtnode = ldns_rbtree_next(tmpnode);
714 if (nxtnode && nxtnode != LDNS_RBTREE_NULL) {
718 !ldns_dname_is_subdomain(nxtdomain->
dname, domain->
dname)) {
739 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
745 if (zd->
domains->root != LDNS_RBTREE_NULL) {
746 node = ldns_rbtree_first(zd->
domains);
748 while (node && node != LDNS_RBTREE_NULL) {
751 node = ldns_rbtree_next(node);
762 domain_ent2glue(ldns_rbnode_t* node)
764 ldns_rbnode_t* nextnode = LDNS_RBTREE_NULL;
771 nextnode = ldns_rbtree_next(node);
772 while (nextnode && nextnode != LDNS_RBTREE_NULL) {
774 if (!ldns_dname_is_subdomain(nextdomain->
dname, domain->
dname)) {
784 nextnode = ldns_rbtree_next(nextnode);
801 domain_ent2unsigned(ldns_rbnode_t* node)
803 ldns_rbnode_t* nextnode = LDNS_RBTREE_NULL;
810 nextnode = ldns_rbtree_next(node);
811 while (nextnode && nextnode != LDNS_RBTREE_NULL) {
813 if (!ldns_dname_is_subdomain(nextdomain->
dname, domain->
dname)) {
824 nextnode = ldns_rbtree_next(nextnode);
843 ldns_rdf* parent_rdf = NULL;
857 while (domain && ldns_dname_is_subdomain(domain->
dname, apex) &&
858 ldns_dname_compare(domain->
dname, apex) != 0) {
867 parent_rdf = ldns_dname_left_chop(domain->
dname);
869 log_rdf(domain->
dname,
"unable to entize domain, left chop "
876 if (!parent_domain) {
878 ldns_rdf_deep_free(parent_rdf);
879 if (!parent_domain) {
880 log_rdf(domain->
dname,
"unable to entize domain, create "
886 log_rdf(domain->
dname,
"unable to entize domain, add parent "
892 domain->
parent = parent_domain;
894 domain = parent_domain;
896 ldns_rdf_deep_free(parent_rdf);
897 domain->
parent = parent_domain;
913 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
918 ods_log_error(
"[%s] unable to entize zone data: no zone data",
926 ods_log_error(
"[%s] unable to entize zone data: no zone apex",
932 node = ldns_rbtree_first(zd->
domains);
933 while (node && node != LDNS_RBTREE_NULL) {
935 status = domain_entize(zd, domain, apex);
937 ods_log_error(
"[%s] unable to entize zone data: entize domain "
942 node = ldns_rbtree_next(node);
956 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
957 ldns_rbnode_t* nxt_node = LDNS_RBTREE_NULL;
963 size_t nsec_added = 0;
971 node = ldns_rbtree_first(zd->
domains);
972 while (node && node != LDNS_RBTREE_NULL) {
983 log_rdf(domain->
dname,
"nsecify: don't do glue domain", 6);
985 log_rdf(domain->
dname,
"nsecify: don't do empty domain", 6);
990 "delete denial of existence data point", zd_str);
995 node = ldns_rbtree_next(node);
999 ods_log_alert(
"[%s] unable to nsecify: apex unknown", zd_str);
1007 log_rdf(domain->
dname,
"unable to nsecify: failed to add "
1008 "denial of existence for domain", 1);
1013 node = ldns_rbtree_next(node);
1018 while (node && node != LDNS_RBTREE_NULL) {
1020 nxt_node = ldns_rbtree_next(node);
1021 if (!nxt_node || nxt_node == LDNS_RBTREE_NULL) {
1028 ods_log_error(
"[%s] unable to nsecify: failed to add NSEC record",
1032 node = ldns_rbtree_next(node);
1035 *num_added = nsec_added;
1049 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
1050 ldns_rbnode_t* nxt_node = LDNS_RBTREE_NULL;
1056 size_t nsec3_added = 0;
1065 ods_log_error(
"[%s] unable to nsecify3: no nsec3 paramaters", zd_str);
1070 node = ldns_rbtree_first(zd->
domains);
1071 while (node && node != LDNS_RBTREE_NULL) {
1080 domain_ent2glue(node)) {
1081 log_rdf(domain->
dname,
"nsecify3: don't do glue domain" , 6);
1085 "delete denial of existence data point", zd_str);
1090 node = ldns_rbtree_next(node);
1094 if (nsec3params->
flags) {
1098 domain_ent2unsigned(node)) {
1104 "non-terminal (to unsigned delegation))", 5);
1109 "delete denial of existence data point", zd_str);
1114 node = ldns_rbtree_next(node);
1119 ods_log_alert(
"[%s] unable to nsecify3: apex unknown", zd_str);
1128 log_rdf(domain->
dname,
"unable to nsecify3: failed to add "
1129 "denial of existence for domain", 1);
1154 node = ldns_rbtree_next(node);
1159 while (node && node != LDNS_RBTREE_NULL) {
1161 nxt_node = ldns_rbtree_next(node);
1162 if (!nxt_node || nxt_node == LDNS_RBTREE_NULL) {
1169 ods_log_error(
"[%s] unable to nsecify3: failed to add NSEC3 "
1173 node = ldns_rbtree_next(node);
1176 *num_added = nsec3_added;
1183 max(uint32_t a, uint32_t b)
1197 uint32_t update = 0;
1203 ods_log_debug(
"[%s] update serial: in=%u internal=%u out=%u now=%u",
1216 "not greater than inbound serial %u", zd_str, soa,
1223 }
else if (strncmp(sc->
soa_serial,
"counter", 7) == 0) {
1230 }
else if (strncmp(sc->
soa_serial,
"datecounter", 11) == 0) {
1235 "not greater than inbound serial %u", zd_str, soa,
1242 }
else if (strncmp(sc->
soa_serial,
"keep", 4) == 0) {
1246 ods_log_error(
"[%s] cannot keep SOA SERIAL from input zone "
1247 " (%u): previous output SOA SERIAL is %u", zd_str, soa, prev);
1256 update = soa - prev;
1257 if (update > 0x7FFFFFFF) {
1258 update = 0x7FFFFFFF;
1266 ods_log_debug(
"[%s] update serial: %u + %u = %u", zd_str, prev, update,
1279 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
1286 if (zd->
domains->root != LDNS_RBTREE_NULL) {
1287 node = ldns_rbtree_first(zd->
domains);
1289 while (node && node != LDNS_RBTREE_NULL) {
1295 node = ldns_rbtree_next(node);
1309 ldns_rdf* parent_rdf = NULL;
1310 ldns_rdf* next_rdf = NULL;
1312 char* str_name = NULL;
1313 char* str_parent = NULL;
1321 if (ldns_dname_compare(domain->
dname, apex) == 0) {
1326 log_rdf(domain->
dname,
"occluded (non-glue non-DS) data at NS", 2);
1330 parent_rdf = ldns_dname_left_chop(domain->
dname);
1331 while (parent_rdf && ldns_dname_is_subdomain(parent_rdf, apex) &&
1332 ldns_dname_compare(parent_rdf, apex) != 0) {
1335 next_rdf = ldns_dname_left_chop(parent_rdf);
1336 ldns_rdf_deep_free(parent_rdf);
1338 if (parent_domain) {
1343 str_name = ldns_rdf2str(domain->
dname);
1344 str_parent = ldns_rdf2str(parent_domain->
dname);
1346 zd_str, str_name, str_parent);
1347 free((
void*)str_name);
1348 free((
void*)str_parent);
1351 LDNS_RR_TYPE_NS, 0) &&
1354 str_name = ldns_rdf2str(domain->
dname);
1355 str_parent = ldns_rdf2str(parent_domain->
dname);
1357 "%s NS)", zd_str, str_name, str_parent);
1358 free((
void*)str_name);
1359 free((
void*)str_parent);
1376 parent_rdf = next_rdf;
1379 ldns_rdf_deep_free(parent_rdf);
1393 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
1404 if (zd->
domains->root != LDNS_RBTREE_NULL) {
1405 node = ldns_rbtree_first(zd->
domains);
1407 while (node && node != LDNS_RBTREE_NULL) {
1423 zonedata_examine_domain_is_occluded(zd, domain, apex);
1428 node = ldns_rbtree_next(node);
1441 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
1446 while (node && node != LDNS_RBTREE_NULL) {
1448 if (denial->
rrset) {
1451 denial->
rrset = NULL;
1453 node = ldns_rbtree_next(node);
1465 domain_delfunc(ldns_rbnode_t* elem)
1469 if (elem && elem != LDNS_RBTREE_NULL) {
1471 domain_delfunc(elem->left);
1472 domain_delfunc(elem->right);
1486 denial_delfunc(ldns_rbnode_t* elem)
1492 if (elem && elem != LDNS_RBTREE_NULL) {
1494 denial_delfunc(elem->left);
1495 denial_delfunc(elem->right);
1517 domain_delfunc(zd->
domains->root);
1518 ldns_rbtree_free(zd->
domains);
1554 zonedata_cleanup_domains(zd);
1568 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
1575 node = ldns_rbtree_first(zd->
domains);
1576 while (node && node != LDNS_RBTREE_NULL) {
1579 node = ldns_rbtree_next(node);
1581 fprintf(fd,
";;\n");
1593 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
1597 ods_log_error(
"[%s] unable to print zone data: no file descriptor",
1604 ods_log_error(
"[%s] unable to print zone data: no zone data",
1611 node = ldns_rbtree_first(zd->
domains);
1612 if (!node || node == LDNS_RBTREE_NULL) {
1613 fprintf(fd,
"; empty zone\n");
1616 while (node && node != LDNS_RBTREE_NULL) {
1619 node = ldns_rbtree_next(node);