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: " 168 namedb_domain_search(ldns_rbtree_t* tree, ldns_rdf* dname)
170 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
171 if (!tree || !dname) {
174 node = ldns_rbtree_search(tree, dname);
175 if (node && node != LDNS_RBTREE_NULL) {
176 return (
void*) node->data;
183 max(uint32_t a, uint32_t b)
195 uint32_t inbound_serial)
200 if (!db || !format || !zone_name) {
201 return ODS_STATUS_ASSERT_ERR;
203 prev = max(db->
outserial, inbound_serial);
205 prev = inbound_serial;
207 ods_log_debug(
"[%s] zone %s update serial: format=%s in=%u internal=%u " 212 if (!util_serial_gt(soa, prev)) {
213 ods_log_warning(
"[%s] zone %s unable to enforce serial: %u does not " 214 " increase %u. Serial set to %u",
db_str, zone_name, soa, prev,
218 ods_log_info(
"[%s] zone %s enforcing serial %u",
db_str, zone_name,
222 }
else if (ods_strcmp(format,
"unixtime") == 0) {
223 soa = (uint32_t) time_now();
224 if (!util_serial_gt(soa, prev)) {
226 ods_log_warning(
"[%s] zone %s unable to use unixtime as serial: " 227 "%u does not increase %u. Serial set to %u",
db_str,
228 zone_name, soa, prev, (prev+1));
232 }
else if (ods_strcmp(format,
"datecounter") == 0) {
233 soa = (uint32_t) time_datestamp(0,
"%Y%m%d", NULL) * 100;
234 if (!util_serial_gt(soa, prev)) {
236 ods_log_info(
"[%s] zone %s unable to use datecounter as " 237 "serial: %u does not increase %u. Serial set to %u",
db_str,
238 zone_name, soa, prev, (prev+1));
242 }
else if (ods_strcmp(format,
"counter") == 0) {
243 soa = inbound_serial + 1;
244 if (db->
have_serial && !util_serial_gt(soa, prev)) {
247 }
else if (ods_strcmp(format,
"keep") == 0) {
249 soa = inbound_serial;
250 if (db->
have_serial && !util_serial_gt(soa, prev)) {
251 ods_log_error(
"[%s] zone %s cannot keep SOA SERIAL from input zone " 252 " (%u): previous output SOA SERIAL is %u",
db_str, zone_name,
254 return ODS_STATUS_CONFLICT_ERR;
257 ods_log_error(
"[%s] zone %s unknown serial type %s",
db_str, zone_name,
259 return ODS_STATUS_ERR;
263 if (update > 0x7FFFFFFF) {
271 ods_log_debug(
"[%s] zone %s update serial: %u + %u = %u",
db_str, zone_name,
273 return ODS_STATUS_OK;
284 ldns_rdf* parent_rdf = NULL;
286 ods_log_assert(apex);
287 ods_log_assert(domain);
288 ods_log_assert(domain->
dname);
293 return ODS_STATUS_OK;
296 while (domain && ldns_dname_is_subdomain(domain->
dname, apex) &&
297 ldns_dname_compare(domain->
dname, apex) != 0) {
305 parent_rdf = ldns_dname_left_chop(domain->
dname);
307 ods_log_error(
"[%s] unable to entize domain: left chop failed",
309 return ODS_STATUS_ERR;
312 if (!parent_domain) {
314 ldns_rdf_deep_free(parent_rdf);
315 if (!parent_domain) {
316 ods_log_error(
"[%s] unable to entize domain: failed to add " 318 return ODS_STATUS_ERR;
320 domain->
parent = parent_domain;
322 domain = parent_domain;
324 ldns_rdf_deep_free(parent_rdf);
325 domain->
parent = parent_domain;
330 return ODS_STATUS_OK;
356 ldns_rbnode_t* new_node = LDNS_RBTREE_NULL;
357 if (!dname || !db || !db->
domains) {
362 ods_log_error(
"[%s] unable to add domain: domain_create() failed",
366 new_node = domain2node(domain);
368 ods_log_error(
"[%s] unable to add domain: domain2node() failed",
372 if (ldns_rbtree_insert(db->
domains, new_node) == NULL) {
373 ods_log_error(
"[%s] unable to add domain: already present",
db_str);
376 free((
void*)new_node);
380 domain->
node = new_node;
394 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
395 if (!domain || !db || !db->
domains) {
396 ods_log_error(
"[%s] unable to delete domain: !db || !domain",
db_str);
400 ods_log_error(
"[%s] unable to delete domain: domain in use",
db_str);
404 node = ldns_rbtree_delete(db->
domains, (
const void*)domain->
dname);
406 ods_log_assert(domain->
node == node);
407 ods_log_assert(!domain->
rrsets);
408 ods_log_assert(!domain->
denial);
414 ods_log_error(
"[%s] unable to delete domain: not found",
db_str);
441 ldns_rbnode_t* n = LDNS_RBTREE_NULL;
443 ods_log_assert(domain);
450 n = ldns_rbtree_next(domain->
node);
455 if(d && ldns_dname_is_subdomain(d->
dname, domain->
dname)) {
469 ods_log_assert(domain);
470 return (domain_is_empty_terminal(domain) && !domain->
denial);
481 ldns_rr_type dstatus = LDNS_RR_TYPE_FIRST;
484 ods_log_assert(domain);
485 ods_log_assert(!domain->
denial);
487 if (dstatus == LDNS_RR_TYPE_DNAME || dstatus == LDNS_RR_TYPE_A) {
495 ods_log_assert(denial);
496 denial->
domain = (
void*) domain;
497 domain->
denial = (
void*) denial;
510 ldns_rr_type dstatus = LDNS_RR_TYPE_FIRST;
514 ods_log_assert(domain);
515 ods_log_assert(!domain->
denial);
517 if (dstatus == LDNS_RR_TYPE_DNAME || dstatus == LDNS_RR_TYPE_A) {
525 if (dstatus == LDNS_RR_TYPE_NS) {
531 ods_log_assert(denial);
532 denial->
domain = (
void*) domain;
533 domain->
denial = (
void*) denial;
547 ods_log_assert(domain);
550 ods_log_assert(zone);
554 namedb_add_nsec_trigger(db, domain);
571 ldns_rr_type dstatus = LDNS_RR_TYPE_FIRST;
574 ods_log_assert(domain);
575 ods_log_assert(domain->
denial);
577 if (dstatus == LDNS_RR_TYPE_DNAME || dstatus == LDNS_RR_TYPE_A ||
578 domain_is_empty_terminal(domain) || !domain->
rrsets) {
596 ldns_rr_type dstatus = LDNS_RR_TYPE_FIRST;
600 ods_log_assert(domain);
601 ods_log_assert(domain->
denial);
603 if (dstatus == LDNS_RR_TYPE_DNAME || dstatus == LDNS_RR_TYPE_A ||
604 domain_is_empty_terminal(domain)) {
610 }
else if (n3p->
flags) {
614 if (dstatus == LDNS_RR_TYPE_NS) {
633 unsigned is_deleted = 0;
635 ods_log_assert(domain);
636 ods_log_assert(domain->
dname);
638 ods_log_assert(zone);
644 namedb_del_nsec_trigger(db, domain);
648 namedb_del_nsec3_trigger(db, domain,
654 if (domain_can_be_deleted(domain)) {
674 ldns_rdf* hashed_ownername = NULL;
675 ldns_rdf* hashed_label = NULL;
676 ods_log_assert(dname);
677 ods_log_assert(apex);
678 ods_log_assert(nsec3params);
683 hashed_label = ldns_nsec3_hash_name(dname, nsec3params->
algorithm,
689 hashed_ownername = ldns_dname_cat_clone((
const ldns_rdf*) hashed_label,
690 (
const ldns_rdf*) apex);
691 if (!hashed_ownername) {
694 ldns_rdf_deep_free(hashed_label);
695 return hashed_ownername;
707 ldns_rbnode_t* new_node = LDNS_RBTREE_NULL;
708 ldns_rbnode_t* pnode = LDNS_RBTREE_NULL;
709 ldns_rdf* owner = NULL;
715 ods_log_assert(dname);
719 owner = dname_hash(dname, z->
apex, n3p);
721 owner = ldns_rdf_clone(dname);
724 ods_log_error(
"[%s] unable to add denial: create owner failed",
730 ods_log_error(
"[%s] unable to add denial: denial_create() failed",
734 new_node = denial2node(denial);
736 ods_log_error(
"[%s] unable to add denial: denial2node() failed",
740 if (!ldns_rbtree_insert(db->
denials, new_node)) {
741 ods_log_error(
"[%s] unable to add denial: already present",
db_str);
744 free((
void*)new_node);
749 denial->
node = new_node;
751 pnode = ldns_rbtree_previous(new_node);
752 if (!pnode || pnode == LDNS_RBTREE_NULL) {
753 pnode = ldns_rbtree_last(db->
denials);
755 ods_log_assert(pnode);
757 ods_log_assert(pdenial);
771 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
772 ldns_rbnode_t* pnode = LDNS_RBTREE_NULL;
775 if (!denial || !db || !db->
denials) {
779 ods_log_error(
"[%s] unable to delete denial: denial in use [#%lu]",
784 pnode = ldns_rbtree_previous(denial->
node);
785 if (!pnode || pnode == LDNS_RBTREE_NULL) {
786 pnode = ldns_rbtree_last(db->
denials);
788 ods_log_assert(pnode);
790 ods_log_assert(pdenial);
791 node = ldns_rbtree_delete(db->
denials, (
const void*)denial->
dname);
793 ods_log_error(
"[%s] unable to delete denial: not found",
db_str);
797 ods_log_assert(denial->
node == node);
814 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
819 node = ldns_rbtree_first(db->
domains);
820 if (!node || node == LDNS_RBTREE_NULL) {
823 while (node && node != LDNS_RBTREE_NULL) {
825 node = ldns_rbtree_next(node);
828 node = ldns_rbtree_first(db->
domains);
829 if (!node || node == LDNS_RBTREE_NULL) {
832 while (node && node != LDNS_RBTREE_NULL) {
834 node = ldns_rbtree_next(node);
835 if (!namedb_del_denial_trigger(db, domain, 0)) {
837 namedb_add_denial_trigger(db, domain);
850 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
855 node = ldns_rbtree_first(db->
domains);
856 if (!node || node == LDNS_RBTREE_NULL) {
859 while (node && node != LDNS_RBTREE_NULL) {
861 node = ldns_rbtree_next(node);
863 (void) namedb_del_denial_trigger(db, domain, 1);
875 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
876 ldns_rbnode_t* nxt_node = LDNS_RBTREE_NULL;
879 uint32_t nsec_added = 0;
881 node = ldns_rbtree_first(db->
denials);
882 while (node && node != LDNS_RBTREE_NULL) {
884 nxt_node = ldns_rbtree_next(node);
885 if (!nxt_node || nxt_node == LDNS_RBTREE_NULL) {
886 nxt_node = ldns_rbtree_first(db->
denials);
890 node = ldns_rbtree_next(node);
893 *num_added = nsec_added;
905 ods_status status = ODS_STATUS_OK;
906 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
917 return ODS_STATUS_OK;
919 if (db->
domains->root != LDNS_RBTREE_NULL) {
920 node = ldns_rbtree_first(db->
domains);
922 while (node && node != LDNS_RBTREE_NULL) {
930 "CNAME and other data at the same name", LOG_ERR);
931 return ODS_STATUS_CONFLICT_ERR;
936 "multiple CNAMEs at the same name", LOG_ERR);
937 return ODS_STATUS_CONFLICT_ERR;
945 "multiple DNAMEs at the same name", LOG_ERR);
946 return ODS_STATUS_CONFLICT_ERR;
949 if (!soa_seen && domain->
is_apex) {
955 "Wrong number of SOA records, should be 1", LOG_ERR);
956 return ODS_STATUS_CONFLICT_ERR;
961 return ODS_STATUS_CONFLICT_ERR;
969 node = ldns_rbtree_next(node);
982 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
989 ods_log_assert(zone);
990 ods_log_assert(zone->
name);
991 ods_log_debug(
"[%s] wipe denial of existence space zone %s",
db_str,
993 node = ldns_rbtree_first(db->
denials);
994 while (node && node != LDNS_RBTREE_NULL) {
996 if (!denial->
rrset) {
997 node = ldns_rbtree_next(node);
1013 denial->
rrset = NULL;
1014 node = ldns_rbtree_next(node);
1026 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
1028 if (!fd || !db || !db->
domains) {
1030 ods_log_error(
"[%s] unable to export namedb: file descriptor " 1031 "or name database missing",
db_str);
1032 *status = ODS_STATUS_ASSERT_ERR;
1036 node = ldns_rbtree_first(db->
domains);
1037 if (!node || node == LDNS_RBTREE_NULL) {
1038 fprintf(fd,
"; empty zone\n");
1040 *status = ODS_STATUS_OK;
1044 while (node && node != LDNS_RBTREE_NULL) {
1049 node = ldns_rbtree_next(node);
1059 domain_delfunc(ldns_rbnode_t* elem)
1062 if (elem && elem != LDNS_RBTREE_NULL) {
1064 domain_delfunc(elem->left);
1065 domain_delfunc(elem->right);
1077 denial_delfunc(ldns_rbnode_t* elem)
1081 if (elem && elem != LDNS_RBTREE_NULL) {
1083 denial_delfunc(elem->left);
1084 denial_delfunc(elem->right);
1103 domain_delfunc(db->
domains->root);
1104 ldns_rbtree_free(db->
domains);
1118 denial_delfunc(db->
denials->root);
1119 ldns_rbtree_free(db->
denials);
1141 namedb_cleanup_domains(db);
1153 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
1159 node = ldns_rbtree_first(db->
domains);
1160 while (node && node != LDNS_RBTREE_NULL) {
1163 node = ldns_rbtree_next(node);
1166 node = ldns_rbtree_first(db->
denials);
1167 while (node && node != LDNS_RBTREE_NULL) {
1169 if (denial->
rrset) {
1172 node = ldns_rbtree_next(node);
1176 node = ldns_rbtree_first(db->
domains);
1177 while (node && node != LDNS_RBTREE_NULL) {
1180 node = ldns_rbtree_next(node);
1182 node = ldns_rbtree_first(db->
denials);
1183 while (node && node != LDNS_RBTREE_NULL) {
1185 if (denial->
rrset) {
1188 node = ldns_rbtree_next(node);
size_t domain_count_rrset_is_added(domain_type *domain)
void domain_cleanup(domain_type *domain)
denial_type * denial_create(zone_type *zone, ldns_rdf *dname)
void namedb_cleanup_denials(namedb_type *db)
void namedb_export(FILE *fd, namedb_type *db, ods_status *status)
void rrset_cleanup(rrset_type *rrset)
void domain_backup2(FILE *fd, domain_type *domain, int sigs)
rrset_type * domain_lookup_rrset(domain_type *domain, ldns_rr_type rrtype)
domain_type * namedb_del_domain(namedb_type *db, domain_type *domain)
void denial_cleanup(denial_type *denial)
void namedb_cleanup(namedb_type *db)
void domain_print(FILE *fd, domain_type *domain, ods_status *status)
size_t rrset_count_rr_is_added(rrset_type *rrset)
void ixfr_del_rr(ixfr_type *ixfr, ldns_rr *rr)
void rrset_drop_rrsigs(zone_type *zone, rrset_type *rrset)
void namedb_init_denials(namedb_type *db)
ods_status namedb_update_serial(namedb_type *db, const char *zone_name, const char *format, uint32_t inbound_serial)
void namedb_diff(namedb_type *db, unsigned is_ixfr, unsigned more_coming)
void domain_diff(domain_type *domain, unsigned is_ixfr, unsigned more_coming)
void namedb_backup2(FILE *fd, namedb_type *db)
void namedb_nsecify(namedb_type *db, uint32_t *num_added)
void log_rrset(ldns_rdf *dname, ldns_rr_type type, const char *pre, int level)
denial_type * namedb_del_denial(namedb_type *db, denial_type *denial)
ldns_rr_type domain_is_delegpt(domain_type *domain)
ods_status namedb_domain_entize(namedb_type *db, domain_type *domain, ldns_rdf *apex)
ldns_rr_type domain_is_occluded(domain_type *domain)
domain_type * domain_create(zone_type *zone, ldns_rdf *dname)
void namedb_rollback(namedb_type *db, unsigned keepsc)
void log_dname(ldns_rdf *rdf, const char *pre, int level)
domain_type * namedb_lookup_domain(namedb_type *db, ldns_rdf *dname)
void rrset_backup2(FILE *fd, rrset_type *rrset)
void rrset_del_rr(rrset_type *rrset, uint16_t rrnum)
namedb_type * namedb_create(void *zone)
void denial_diff(denial_type *denial)
lock_basic_type ixfr_lock
nsec3params_type * nsec3params
ods_status namedb_examine(namedb_type *db)
domain_type * namedb_add_domain(namedb_type *db, ldns_rdf *dname)
void domain_rollback(domain_type *domain, int keepsc)
void namedb_wipe_denial(namedb_type *db)
void denial_nsecify(denial_type *denial, denial_type *nxt, uint32_t *num_added)
denial_type * namedb_add_denial(namedb_type *db, ldns_rdf *dname, nsec3params_type *n3p)
denial_type * namedb_lookup_denial(namedb_type *db, ldns_rdf *dname)
void rrset_print(FILE *fd, rrset_type *rrset, int skip_rrsigs, ods_status *status)