50 ldns_rbnode_t* node = (ldns_rbnode_t*) malloc(
sizeof(ldns_rbnode_t));
54 node->key = domain->
dname;
67 ldns_rbnode_t* node = (ldns_rbnode_t*) malloc(
sizeof(ldns_rbnode_t));
71 node->key = denial->
dname;
82 domain_compare(
const void* a,
const void* b)
84 ldns_rdf* x = (ldns_rdf*)a;
85 ldns_rdf* y = (ldns_rdf*)b;
86 return ldns_dname_compare(x, y);
98 db->
denials = ldns_rbtree_create(domain_compare);
111 db->
domains = ldns_rbtree_create(domain_compare);
127 ods_log_assert(z->
name);
130 ods_log_error(
"[%s] unable to create namedb for zone %s: "
136 namedb_init_domains(db);
138 ods_log_error(
"[%s] unable to create namedb for zone %s: "
145 ods_log_error(
"[%s] unable to create namedb for zone %s: "
167 namedb_domain_search(ldns_rbtree_t* tree, ldns_rdf* dname)
169 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
170 if (!tree || !dname) {
173 node = ldns_rbtree_search(tree, dname);
174 if (node && node != LDNS_RBTREE_NULL) {
175 return (
void*) node->data;
182 max(uint32_t a, uint32_t b)
194 uint32_t inbound_serial)
199 if (!db || !format || !zone_name) {
200 return ODS_STATUS_ASSERT_ERR;
202 prev = max(db->
outserial, inbound_serial);
204 prev = inbound_serial;
206 ods_log_debug(
"[%s] zone %s update serial: format=%s in=%u internal=%u "
211 if (!util_serial_gt(soa, prev)) {
212 ods_log_warning(
"[%s] zone %s unable to enforce serial: %u does not "
213 " increase %u. Serial set to %u",
db_str, zone_name, soa, prev,
217 ods_log_info(
"[%s] zone %s enforcing serial %u",
db_str, zone_name,
221 }
else if (ods_strcmp(format,
"unixtime") == 0) {
222 soa = (uint32_t) time_now();
223 if (!util_serial_gt(soa, prev)) {
225 ods_log_warning(
"[%s] zone %s unable to use unixtime as serial: "
226 "%u does not increase %u. Serial set to %u",
db_str,
227 zone_name, soa, prev, (prev+1));
231 }
else if (ods_strcmp(format,
"datecounter") == 0) {
232 soa = (uint32_t) time_datestamp(0,
"%Y%m%d", NULL) * 100;
233 if (!util_serial_gt(soa, prev)) {
235 ods_log_info(
"[%s] zone %s unable to use datecounter as "
236 "serial: %u does not increase %u. Serial set to %u",
db_str,
237 zone_name, soa, prev, (prev+1));
241 }
else if (ods_strcmp(format,
"counter") == 0) {
242 soa = inbound_serial + 1;
243 if (db->
have_serial && !util_serial_gt(soa, prev)) {
246 }
else if (ods_strcmp(format,
"keep") == 0) {
248 soa = inbound_serial;
249 if (db->
have_serial && !util_serial_gt(soa, prev)) {
250 ods_log_error(
"[%s] zone %s cannot keep SOA SERIAL from input zone "
251 " (%u): previous output SOA SERIAL is %u",
db_str, zone_name,
253 return ODS_STATUS_CONFLICT_ERR;
256 ods_log_error(
"[%s] zone %s unknown serial type %s",
db_str, zone_name,
258 return ODS_STATUS_ERR;
262 if (update > 0x7FFFFFFF) {
270 ods_log_debug(
"[%s] zone %s update serial: %u + %u = %u",
db_str, zone_name,
272 return ODS_STATUS_OK;
283 ldns_rdf* parent_rdf = NULL;
285 ods_log_assert(apex);
286 ods_log_assert(domain);
287 ods_log_assert(domain->
dname);
292 return ODS_STATUS_OK;
295 while (domain && ldns_dname_is_subdomain(domain->
dname, apex) &&
296 ldns_dname_compare(domain->
dname, apex) != 0) {
304 parent_rdf = ldns_dname_left_chop(domain->
dname);
306 ods_log_error(
"[%s] unable to entize domain: left chop failed",
308 return ODS_STATUS_ERR;
311 if (!parent_domain) {
313 ldns_rdf_deep_free(parent_rdf);
314 if (!parent_domain) {
315 ods_log_error(
"[%s] unable to entize domain: failed to add "
317 return ODS_STATUS_ERR;
319 domain->
parent = parent_domain;
321 domain = parent_domain;
323 ldns_rdf_deep_free(parent_rdf);
324 domain->
parent = parent_domain;
329 return ODS_STATUS_OK;
355 ldns_rbnode_t* new_node = LDNS_RBTREE_NULL;
356 if (!dname || !db || !db->
domains) {
361 ods_log_error(
"[%s] unable to add domain: domain_create() failed",
365 new_node = domain2node(domain);
367 ods_log_error(
"[%s] unable to add domain: domain2node() failed",
371 if (ldns_rbtree_insert(db->
domains, new_node) == NULL) {
372 ods_log_error(
"[%s] unable to add domain: already present",
db_str);
375 free((
void*)new_node);
379 domain->
node = new_node;
393 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
394 if (!domain || !db || !db->
domains) {
395 ods_log_error(
"[%s] unable to delete domain: !db || !domain",
db_str);
399 ods_log_error(
"[%s] unable to delete domain: domain in use",
db_str);
403 node = ldns_rbtree_delete(db->
domains, (
const void*)domain->
dname);
405 ods_log_assert(domain->
node == node);
406 ods_log_assert(!domain->
rrsets);
407 ods_log_assert(!domain->
denial);
413 ods_log_error(
"[%s] unable to delete domain: not found",
db_str);
440 ldns_rbnode_t* n = LDNS_RBTREE_NULL;
442 ods_log_assert(domain);
449 n = ldns_rbtree_next(domain->
node);
454 if(d && ldns_dname_is_subdomain(d->
dname, domain->
dname)) {
468 ods_log_assert(domain);
469 return (domain_is_empty_terminal(domain) && !domain->
denial);
480 ldns_rr_type dstatus = LDNS_RR_TYPE_FIRST;
483 ods_log_assert(domain);
484 ods_log_assert(!domain->
denial);
486 if (dstatus == LDNS_RR_TYPE_DNAME || dstatus == LDNS_RR_TYPE_A) {
494 ods_log_assert(denial);
495 denial->
domain = (
void*) domain;
496 domain->
denial = (
void*) denial;
509 ldns_rr_type dstatus = LDNS_RR_TYPE_FIRST;
513 ods_log_assert(domain);
514 ods_log_assert(!domain->
denial);
516 if (dstatus == LDNS_RR_TYPE_DNAME || dstatus == LDNS_RR_TYPE_A) {
524 if (dstatus == LDNS_RR_TYPE_NS) {
530 ods_log_assert(denial);
531 denial->
domain = (
void*) domain;
532 domain->
denial = (
void*) denial;
546 ods_log_assert(domain);
549 ods_log_assert(zone);
553 namedb_add_nsec_trigger(db, domain);
570 ldns_rr_type dstatus = LDNS_RR_TYPE_FIRST;
573 ods_log_assert(domain);
574 ods_log_assert(domain->
denial);
576 if (dstatus == LDNS_RR_TYPE_DNAME || dstatus == LDNS_RR_TYPE_A ||
577 domain_is_empty_terminal(domain) || !domain->
rrsets) {
595 ldns_rr_type dstatus = LDNS_RR_TYPE_FIRST;
599 ods_log_assert(domain);
600 ods_log_assert(domain->
denial);
602 if (dstatus == LDNS_RR_TYPE_DNAME || dstatus == LDNS_RR_TYPE_A ||
603 domain_is_empty_terminal(domain)) {
609 }
else if (n3p->
flags) {
613 if (dstatus == LDNS_RR_TYPE_NS) {
632 unsigned is_deleted = 0;
634 ods_log_assert(domain);
635 ods_log_assert(domain->
dname);
637 ods_log_assert(zone);
643 namedb_del_nsec_trigger(db, domain);
647 namedb_del_nsec3_trigger(db, domain,
653 if (domain_can_be_deleted(domain)) {
673 ldns_rdf* hashed_ownername = NULL;
674 ldns_rdf* hashed_label = NULL;
675 ods_log_assert(dname);
676 ods_log_assert(apex);
677 ods_log_assert(nsec3params);
682 hashed_label = ldns_nsec3_hash_name(dname, nsec3params->
algorithm,
688 hashed_ownername = ldns_dname_cat_clone((
const ldns_rdf*) hashed_label,
689 (
const ldns_rdf*) apex);
690 if (!hashed_ownername) {
693 ldns_rdf_deep_free(hashed_label);
694 return hashed_ownername;
706 ldns_rbnode_t* new_node = LDNS_RBTREE_NULL;
707 ldns_rbnode_t* pnode = LDNS_RBTREE_NULL;
708 ldns_rdf* owner = NULL;
714 ods_log_assert(dname);
718 owner = dname_hash(dname, z->
apex, n3p);
720 owner = ldns_rdf_clone(dname);
723 ods_log_error(
"[%s] unable to add denial: create owner failed",
729 ods_log_error(
"[%s] unable to add denial: denial_create() failed",
733 new_node = denial2node(denial);
735 ods_log_error(
"[%s] unable to add denial: denial2node() failed",
739 if (!ldns_rbtree_insert(db->
denials, new_node)) {
740 ods_log_error(
"[%s] unable to add denial: already present",
db_str);
743 free((
void*)new_node);
748 denial->
node = new_node;
750 pnode = ldns_rbtree_previous(new_node);
751 if (!pnode || pnode == LDNS_RBTREE_NULL) {
752 pnode = ldns_rbtree_last(db->
denials);
754 ods_log_assert(pnode);
756 ods_log_assert(pdenial);
770 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
771 ldns_rbnode_t* pnode = LDNS_RBTREE_NULL;
774 if (!denial || !db || !db->
denials) {
778 ods_log_error(
"[%s] unable to delete denial: denial in use [#%lu]",
783 pnode = ldns_rbtree_previous(denial->
node);
784 if (!pnode || pnode == LDNS_RBTREE_NULL) {
785 pnode = ldns_rbtree_last(db->
denials);
787 ods_log_assert(pnode);
789 ods_log_assert(pdenial);
790 node = ldns_rbtree_delete(db->
denials, (
const void*)denial->
dname);
792 ods_log_error(
"[%s] unable to delete denial: not found",
db_str);
796 ods_log_assert(denial->
node == node);
813 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
818 node = ldns_rbtree_first(db->
domains);
819 if (!node || node == LDNS_RBTREE_NULL) {
822 while (node && node != LDNS_RBTREE_NULL) {
824 node = ldns_rbtree_next(node);
827 node = ldns_rbtree_first(db->
domains);
828 if (!node || node == LDNS_RBTREE_NULL) {
831 while (node && node != LDNS_RBTREE_NULL) {
833 node = ldns_rbtree_next(node);
834 if (!namedb_del_denial_trigger(db, domain, 0)) {
836 namedb_add_denial_trigger(db, domain);
849 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
854 node = ldns_rbtree_first(db->
domains);
855 if (!node || node == LDNS_RBTREE_NULL) {
858 while (node && node != LDNS_RBTREE_NULL) {
860 node = ldns_rbtree_next(node);
862 (void) namedb_del_denial_trigger(db, domain, 1);
874 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
875 ldns_rbnode_t* nxt_node = LDNS_RBTREE_NULL;
878 uint32_t nsec_added = 0;
880 node = ldns_rbtree_first(db->
denials);
881 while (node && node != LDNS_RBTREE_NULL) {
883 nxt_node = ldns_rbtree_next(node);
884 if (!nxt_node || nxt_node == LDNS_RBTREE_NULL) {
885 nxt_node = ldns_rbtree_first(db->
denials);
889 node = ldns_rbtree_next(node);
892 *num_added = nsec_added;
904 ods_status status = ODS_STATUS_OK;
905 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
916 return ODS_STATUS_OK;
918 if (db->
domains->root != LDNS_RBTREE_NULL) {
919 node = ldns_rbtree_first(db->
domains);
921 while (node && node != LDNS_RBTREE_NULL) {
929 "CNAME and other data at the same name", LOG_ERR);
930 return ODS_STATUS_CONFLICT_ERR;
935 "multiple CNAMEs at the same name", LOG_ERR);
936 return ODS_STATUS_CONFLICT_ERR;
944 "multiple DNAMEs at the same name", LOG_ERR);
945 return ODS_STATUS_CONFLICT_ERR;
948 if (!soa_seen && domain->
is_apex) {
954 "Wrong number of SOA records, should be 1", LOG_ERR);
955 return ODS_STATUS_CONFLICT_ERR;
960 return ODS_STATUS_CONFLICT_ERR;
968 node = ldns_rbtree_next(node);
981 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
988 ods_log_assert(zone);
989 ods_log_assert(zone->
name);
990 ods_log_debug(
"[%s] wipe denial of existence space zone %s",
db_str,
992 node = ldns_rbtree_first(db->
denials);
993 while (node && node != LDNS_RBTREE_NULL) {
995 if (!denial->
rrset) {
996 node = ldns_rbtree_next(node);
1014 denial->
rrset = NULL;
1015 node = ldns_rbtree_next(node);
1027 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
1029 if (!fd || !db || !db->
domains) {
1031 ods_log_error(
"[%s] unable to export namedb: file descriptor "
1032 "or name database missing",
db_str);
1033 *status = ODS_STATUS_ASSERT_ERR;
1037 node = ldns_rbtree_first(db->
domains);
1038 if (!node || node == LDNS_RBTREE_NULL) {
1039 fprintf(fd,
"; empty zone\n");
1041 *status = ODS_STATUS_OK;
1045 while (node && node != LDNS_RBTREE_NULL) {
1050 node = ldns_rbtree_next(node);
1060 domain_delfunc(ldns_rbnode_t* elem)
1063 if (elem && elem != LDNS_RBTREE_NULL) {
1065 domain_delfunc(elem->left);
1066 domain_delfunc(elem->right);
1078 denial_delfunc(ldns_rbnode_t* elem)
1082 if (elem && elem != LDNS_RBTREE_NULL) {
1084 denial_delfunc(elem->left);
1085 denial_delfunc(elem->right);
1104 domain_delfunc(db->
domains->root);
1105 ldns_rbtree_free(db->
domains);
1119 denial_delfunc(db->
denials->root);
1120 ldns_rbtree_free(db->
denials);
1142 namedb_cleanup_domains(db);
1154 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
1160 node = ldns_rbtree_first(db->
domains);
1161 while (node && node != LDNS_RBTREE_NULL) {
1164 node = ldns_rbtree_next(node);
1167 node = ldns_rbtree_first(db->
denials);
1168 while (node && node != LDNS_RBTREE_NULL) {
1170 if (denial->
rrset) {
1173 node = ldns_rbtree_next(node);
1177 node = ldns_rbtree_first(db->
domains);
1178 while (node && node != LDNS_RBTREE_NULL) {
1181 node = ldns_rbtree_next(node);
1183 node = ldns_rbtree_first(db->
denials);
1184 while (node && node != LDNS_RBTREE_NULL) {
1186 if (denial->
rrset) {
1189 node = ldns_rbtree_next(node);
void denial_cleanup(denial_type *denial)
void denial_diff(denial_type *denial)
void denial_nsecify(denial_type *denial, denial_type *nxt, uint32_t *num_added)
denial_type * denial_create(zone_type *zone, ldns_rdf *dname)
ldns_rr_type domain_is_delegpt(domain_type *domain)
size_t domain_count_rrset_is_added(domain_type *domain)
domain_type * domain_create(zone_type *zone, ldns_rdf *dname)
void domain_diff(domain_type *domain, unsigned is_ixfr, unsigned more_coming)
void domain_backup2(FILE *fd, domain_type *domain, int sigs)
void domain_cleanup(domain_type *domain)
ldns_rr_type domain_is_occluded(domain_type *domain)
rrset_type * domain_lookup_rrset(domain_type *domain, ldns_rr_type rrtype)
void log_dname(ldns_rdf *rdf, const char *pre, int level)
void domain_print(FILE *fd, domain_type *domain, ods_status *status)
void domain_rollback(domain_type *domain, int keepsc)
void ixfr_del_rr(ixfr_type *ixfr, ldns_rr *rr)
domain_type * namedb_add_domain(namedb_type *db, ldns_rdf *dname)
void namedb_export(FILE *fd, namedb_type *db, ods_status *status)
void namedb_rollback(namedb_type *db, unsigned keepsc)
denial_type * namedb_add_denial(namedb_type *db, ldns_rdf *dname, nsec3params_type *n3p)
ods_status namedb_examine(namedb_type *db)
denial_type * namedb_del_denial(namedb_type *db, denial_type *denial)
domain_type * namedb_lookup_domain(namedb_type *db, ldns_rdf *dname)
void namedb_diff(namedb_type *db, unsigned is_ixfr, unsigned more_coming)
void namedb_cleanup(namedb_type *db)
void namedb_backup2(FILE *fd, namedb_type *db)
ods_status namedb_domain_entize(namedb_type *db, domain_type *domain, ldns_rdf *apex)
void namedb_cleanup_denials(namedb_type *db)
namedb_type * namedb_create(void *zone)
ods_status namedb_update_serial(namedb_type *db, const char *zone_name, const char *format, uint32_t inbound_serial)
denial_type * namedb_lookup_denial(namedb_type *db, ldns_rdf *dname)
domain_type * namedb_del_domain(namedb_type *db, domain_type *domain)
void namedb_init_denials(namedb_type *db)
void namedb_nsecify(namedb_type *db, uint32_t *num_added)
void namedb_wipe_denial(namedb_type *db)
size_t rrset_count_rr_is_added(rrset_type *rrset)
void rrset_del_rr(rrset_type *rrset, uint16_t rrnum)
void rrset_drop_rrsigs(zone_type *zone, rrset_type *rrset)
void rrset_cleanup(rrset_type *rrset)
void log_rrset(ldns_rdf *dname, ldns_rr_type type, const char *pre, int level)
void rrset_backup2(FILE *fd, rrset_type *rrset)
void rrset_print(FILE *fd, rrset_type *rrset, int skip_rrsigs, ods_status *status)
pthread_mutex_t ixfr_lock
nsec3params_type * nsec3params