53 ldns_rbnode_t* node = (ldns_rbnode_t*) malloc(
sizeof(ldns_rbnode_t));
57 node->key = domain->
dname;
70 ldns_rbnode_t* node = (ldns_rbnode_t*) malloc(
sizeof(ldns_rbnode_t));
74 node->key = denial->
dname;
85 domain_compare(
const void* a,
const void* b)
87 ldns_rdf* x = (ldns_rdf*)a;
88 ldns_rdf* y = (ldns_rdf*)b;
89 return ldns_dname_compare(x, y);
101 db->
denials = ldns_rbtree_create(domain_compare);
115 db->
domains = ldns_rbtree_create(domain_compare);
142 namedb_init_domains(db);
173 namedb_domain_search(ldns_rbtree_t* tree, ldns_rdf* dname)
175 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
176 if (!tree || !dname) {
179 node = ldns_rbtree_search(tree, dname);
180 if (node && node != LDNS_RBTREE_NULL) {
181 return (
void*) node->data;
188 max(uint32_t a, uint32_t b)
200 uint32_t inbound_serial)
205 if (!db || !format || !zone_name) {
208 prev = max(db->
outserial, inbound_serial);
210 prev = inbound_serial;
212 ods_log_debug(
"[%s] zone %s update serial: format=%s in=%u internal=%u "
219 " increase %u. Serial set to %u",
db_str, zone_name, soa, prev,
227 }
else if (
ods_strcmp(format,
"unixtime") == 0) {
232 "%u does not increase %u. Serial set to %u",
db_str,
233 zone_name, soa, prev, (prev+1));
237 }
else if (
ods_strcmp(format,
"datecounter") == 0) {
242 "serial: %u does not increase %u. Serial set to %u",
db_str,
243 zone_name, soa, prev, (prev+1));
247 }
else if (
ods_strcmp(format,
"counter") == 0) {
248 soa = inbound_serial + 1;
254 soa = inbound_serial;
256 ods_log_error(
"[%s] zone %s cannot keep SOA SERIAL from input zone "
257 " (%u): previous output SOA SERIAL is %u",
db_str, zone_name,
268 if (update > 0x7FFFFFFF) {
289 ldns_rdf* parent_rdf = NULL;
301 while (domain && ldns_dname_is_subdomain(domain->
dname, apex) &&
302 ldns_dname_compare(domain->
dname, apex) != 0) {
310 parent_rdf = ldns_dname_left_chop(domain->
dname);
312 ods_log_error(
"[%s] unable to entize domain: left chop failed",
317 if (!parent_domain) {
319 ldns_rdf_deep_free(parent_rdf);
320 if (!parent_domain) {
325 domain->
parent = parent_domain;
327 domain = parent_domain;
329 ldns_rdf_deep_free(parent_rdf);
330 domain->
parent = parent_domain;
361 ldns_rbnode_t* new_node = LDNS_RBTREE_NULL;
362 if (!dname || !db || !db->
domains) {
367 ods_log_error(
"[%s] unable to add domain: domain_create() failed",
371 new_node = domain2node(domain);
373 ods_log_error(
"[%s] unable to add domain: domain2node() failed",
377 if (ldns_rbtree_insert(db->
domains, new_node) == NULL) {
381 free((
void*)new_node);
385 domain->
node = new_node;
399 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
400 if (!domain || !db || !db->
domains) {
409 node = ldns_rbtree_delete(db->
domains, (
const void*)domain->
dname);
446 ldns_rbnode_t* n = LDNS_RBTREE_NULL;
455 n = ldns_rbtree_next(domain->
node);
460 if(d && ldns_dname_is_subdomain(d->
dname, domain->
dname)) {
475 return (domain_is_empty_terminal(domain) && !domain->
denial);
486 ldns_rr_type dstatus = LDNS_RR_TYPE_FIRST;
492 if (dstatus == LDNS_RR_TYPE_DNAME || dstatus == LDNS_RR_TYPE_A) {
501 denial->
domain = (
void*) domain;
502 domain->
denial = (
void*) denial;
516 ldns_rr_type dstatus = LDNS_RR_TYPE_FIRST;
523 if (dstatus == LDNS_RR_TYPE_DNAME || dstatus == LDNS_RR_TYPE_A) {
538 denial->
domain = (
void*) domain;
539 domain->
denial = (
void*) denial;
556 zone = (
void*) domain->
zone;
560 namedb_add_nsec_trigger(db, domain);
577 ldns_rr_type dstatus = LDNS_RR_TYPE_FIRST;
583 if (dstatus == LDNS_RR_TYPE_DNAME || dstatus == LDNS_RR_TYPE_A ||
584 domain_is_empty_terminal(domain) || !domain->
rrsets) {
603 ldns_rr_type dstatus = LDNS_RR_TYPE_FIRST;
610 if (dstatus == LDNS_RR_TYPE_DNAME || dstatus == LDNS_RR_TYPE_A ||
611 domain_is_empty_terminal(domain)) {
617 }
else if (n3p->
flags) {
641 unsigned is_deleted = 0;
645 zone = (
void*) domain->
zone;
652 namedb_del_nsec_trigger(db, domain);
656 namedb_del_nsec3_trigger(db, domain,
662 if (domain_can_be_deleted(domain)) {
682 ldns_rdf* hashed_ownername = NULL;
683 ldns_rdf* hashed_label = NULL;
691 hashed_label = ldns_nsec3_hash_name(dname, nsec3params->
algorithm,
697 hashed_ownername = ldns_dname_cat_clone((
const ldns_rdf*) hashed_label,
698 (
const ldns_rdf*) apex);
699 if (!hashed_ownername) {
702 ldns_rdf_deep_free(hashed_label);
703 return hashed_ownername;
715 ldns_rbnode_t* new_node = LDNS_RBTREE_NULL;
716 ldns_rbnode_t* pnode = LDNS_RBTREE_NULL;
717 ldns_rdf* owner = NULL;
727 owner = dname_hash(dname, z->
apex, n3p);
729 owner = ldns_rdf_clone(dname);
732 ods_log_error(
"[%s] unable to add denial: create owner failed",
738 ods_log_error(
"[%s] unable to add denial: denial_create() failed",
742 new_node = denial2node(denial);
744 ods_log_error(
"[%s] unable to add denial: denial2node() failed",
748 if (!ldns_rbtree_insert(db->
denials, new_node)) {
752 free((
void*)new_node);
757 denial->
node = new_node;
759 pnode = ldns_rbtree_previous(new_node);
760 if (!pnode || pnode == LDNS_RBTREE_NULL) {
761 pnode = ldns_rbtree_last(db->
denials);
779 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
780 ldns_rbnode_t* pnode = LDNS_RBTREE_NULL;
783 if (!denial || !db || !db->
denials) {
787 ods_log_error(
"[%s] unable to delete denial: denial in use [#%u]",
792 pnode = ldns_rbtree_previous(denial->
node);
793 if (!pnode || pnode == LDNS_RBTREE_NULL) {
794 pnode = ldns_rbtree_last(db->
denials);
799 node = ldns_rbtree_delete(db->
denials, (
const void*)denial->
dname);
822 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
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);
836 node = ldns_rbtree_first(db->
domains);
837 if (!node || node == LDNS_RBTREE_NULL) {
840 while (node && node != LDNS_RBTREE_NULL) {
842 node = ldns_rbtree_next(node);
843 if (!namedb_del_denial_trigger(db, domain, 0)) {
845 namedb_add_denial_trigger(db, domain);
859 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
864 node = ldns_rbtree_first(db->
domains);
865 if (!node || node == LDNS_RBTREE_NULL) {
868 while (node && node != LDNS_RBTREE_NULL) {
870 node = ldns_rbtree_next(node);
872 (void) namedb_del_denial_trigger(db, domain, 1);
885 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
886 ldns_rbnode_t* nxt_node = LDNS_RBTREE_NULL;
889 uint32_t nsec_added = 0;
891 node = ldns_rbtree_first(db->
denials);
892 while (node && node != LDNS_RBTREE_NULL) {
894 nxt_node = ldns_rbtree_next(node);
895 if (!nxt_node || nxt_node == LDNS_RBTREE_NULL) {
896 nxt_node = ldns_rbtree_first(db->
denials);
900 node = ldns_rbtree_next(node);
903 *num_added = nsec_added;
917 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
929 if (db->
domains->root != LDNS_RBTREE_NULL) {
930 node = ldns_rbtree_first(db->
domains);
932 while (node && node != LDNS_RBTREE_NULL) {
940 "CNAME and other data at the same name",
LOG_ERR);
946 "multiple CNAMEs at the same name",
LOG_ERR);
955 "multiple DNAMEs at the same name",
LOG_ERR);
964 node = ldns_rbtree_next(node);
977 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
988 node = ldns_rbtree_first(db->
denials);
989 while (node && node != LDNS_RBTREE_NULL) {
991 if (!denial->
rrset) {
992 node = ldns_rbtree_next(node);
1015 denial->
rrset = NULL;
1016 node = ldns_rbtree_next(node);
1030 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
1032 if (!fd || !db || !db->
domains) {
1034 ods_log_error(
"[%s] unable to export namedb: file descriptor "
1035 "or name database missing",
db_str);
1040 node = ldns_rbtree_first(db->
domains);
1041 if (!node || node == LDNS_RBTREE_NULL) {
1042 fprintf(fd,
"; empty zone\n");
1048 while (node && node != LDNS_RBTREE_NULL) {
1053 node = ldns_rbtree_next(node);
1064 domain_delfunc(ldns_rbnode_t* elem)
1067 if (elem && elem != LDNS_RBTREE_NULL) {
1069 domain_delfunc(elem->left);
1070 domain_delfunc(elem->right);
1083 denial_delfunc(ldns_rbnode_t* elem)
1087 if (elem && elem != LDNS_RBTREE_NULL) {
1089 denial_delfunc(elem->left);
1090 denial_delfunc(elem->right);
1110 domain_delfunc(db->
domains->root);
1111 ldns_rbtree_free(db->
domains);
1126 denial_delfunc(db->
denials->root);
1127 ldns_rbtree_free(db->
denials);
1150 namedb_cleanup_domains(db);
1163 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
1169 node = ldns_rbtree_first(db->
domains);
1170 while (node && node != LDNS_RBTREE_NULL) {
1173 node = ldns_rbtree_next(node);
1176 node = ldns_rbtree_first(db->
denials);
1177 while (node && node != LDNS_RBTREE_NULL) {
1179 if (denial->
rrset) {
1182 node = ldns_rbtree_next(node);
1186 node = ldns_rbtree_first(db->
domains);
1187 while (node && node != LDNS_RBTREE_NULL) {
1190 node = ldns_rbtree_next(node);
1192 node = ldns_rbtree_first(db->
denials);
1193 while (node && node != LDNS_RBTREE_NULL) {
1195 if (denial->
rrset) {
1198 node = ldns_rbtree_next(node);
size_t domain_count_rrset_is_added(domain_type *domain)
void domain_cleanup(domain_type *domain)
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 ods_log_debug(const char *format,...)
uint32_t time_datestamp(time_t tt, const char *format, char **str)
denial_type * denial_create(void *zoneptr, ldns_rdf *dname)
void denial_cleanup(denial_type *denial)
void * allocator_alloc(allocator_type *allocator, size_t size)
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 ods_log_info(const char *format,...)
enum ods_enum_status ods_status
void ods_log_error(const char *format,...)
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)
int ods_strcmp(const char *s1, const char *s2)
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)
int util_serial_gt(uint32_t serial_new, uint32_t serial_old)
void namedb_nsecify(namedb_type *db, uint32_t *num_added)
#define lock_basic_lock(lock)
int domain_ent2unsignedns(domain_type *domain)
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)
void rrset_del_rrsig(rrset_type *rrset, uint16_t rrnum)
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)
allocator_type * allocator
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 allocator_deallocate(allocator_type *allocator, void *data)
#define ods_log_assert(x)
void namedb_wipe_denial(namedb_type *db)
#define lock_basic_unlock(lock)
void ods_log_warning(const char *format,...)
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)
domain_type * domain_create(void *zoneptr, ldns_rdf *dname)