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);
174 namedb_domain_search(ldns_rbtree_t* tree, ldns_rdf* dname)
176 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
177 if (!tree || !dname) {
180 node = ldns_rbtree_search(tree, dname);
181 if (node && node != LDNS_RBTREE_NULL) {
182 return (
void*) node->data;
189 max(uint32_t a, uint32_t b)
201 uint32_t inbound_serial)
206 if (!db || !format || !zone_name) {
209 prev = max(db->
outserial, inbound_serial);
211 prev = inbound_serial;
213 ods_log_debug(
"[%s] zone %s update serial: format=%s in=%u internal=%u "
220 " increase %u. Serial set to %u",
db_str, zone_name, soa, prev,
228 }
else if (
ods_strcmp(format,
"unixtime") == 0) {
233 "%u does not increase %u. Serial set to %u",
db_str,
234 zone_name, soa, prev, (prev+1));
238 }
else if (
ods_strcmp(format,
"datecounter") == 0) {
243 "serial: %u does not increase %u. Serial set to %u",
db_str,
244 zone_name, soa, prev, (prev+1));
248 }
else if (
ods_strcmp(format,
"counter") == 0) {
249 soa = inbound_serial + 1;
255 soa = inbound_serial;
257 ods_log_error(
"[%s] zone %s cannot keep SOA SERIAL from input zone "
258 " (%u): previous output SOA SERIAL is %u",
db_str, zone_name,
269 if (update > 0x7FFFFFFF) {
290 ldns_rdf* parent_rdf = NULL;
302 while (domain && ldns_dname_is_subdomain(domain->
dname, apex) &&
303 ldns_dname_compare(domain->
dname, apex) != 0) {
311 parent_rdf = ldns_dname_left_chop(domain->
dname);
313 ods_log_error(
"[%s] unable to entize domain: left chop failed",
318 if (!parent_domain) {
320 ldns_rdf_deep_free(parent_rdf);
321 if (!parent_domain) {
326 domain->
parent = parent_domain;
328 domain = parent_domain;
330 ldns_rdf_deep_free(parent_rdf);
331 domain->
parent = parent_domain;
362 ldns_rbnode_t* new_node = LDNS_RBTREE_NULL;
363 if (!dname || !db || !db->
domains) {
368 ods_log_error(
"[%s] unable to add domain: domain_create() failed",
372 new_node = domain2node(domain);
374 ods_log_error(
"[%s] unable to add domain: domain2node() failed",
378 if (ldns_rbtree_insert(db->
domains, new_node) == NULL) {
382 free((
void*)new_node);
386 domain->
node = new_node;
400 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
401 if (!domain || !db || !db->
domains) {
410 node = ldns_rbtree_delete(db->
domains, (
const void*)domain->
dname);
447 ldns_rbnode_t* n = LDNS_RBTREE_NULL;
456 n = ldns_rbtree_next(domain->
node);
461 if(d && ldns_dname_is_subdomain(d->
dname, domain->
dname)) {
476 return (domain_is_empty_terminal(domain) && !domain->
denial);
487 ldns_rr_type dstatus = LDNS_RR_TYPE_FIRST;
493 if (dstatus == LDNS_RR_TYPE_DNAME || dstatus == LDNS_RR_TYPE_A) {
502 denial->
domain = (
void*) domain;
503 domain->
denial = (
void*) denial;
517 ldns_rr_type dstatus = LDNS_RR_TYPE_FIRST;
524 if (dstatus == LDNS_RR_TYPE_DNAME || dstatus == LDNS_RR_TYPE_A) {
539 denial->
domain = (
void*) domain;
540 domain->
denial = (
void*) denial;
557 zone = (
void*) domain->
zone;
561 namedb_add_nsec_trigger(db, domain);
578 ldns_rr_type dstatus = LDNS_RR_TYPE_FIRST;
584 if (dstatus == LDNS_RR_TYPE_DNAME || dstatus == LDNS_RR_TYPE_A ||
585 domain_is_empty_terminal(domain) || !domain->
rrsets) {
604 ldns_rr_type dstatus = LDNS_RR_TYPE_FIRST;
611 if (dstatus == LDNS_RR_TYPE_DNAME || dstatus == LDNS_RR_TYPE_A ||
612 domain_is_empty_terminal(domain)) {
618 }
else if (n3p->
flags) {
642 unsigned is_deleted = 0;
646 zone = (
void*) domain->
zone;
653 namedb_del_nsec_trigger(db, domain);
657 namedb_del_nsec3_trigger(db, domain,
663 if (domain_can_be_deleted(domain)) {
683 ldns_rdf* hashed_ownername = NULL;
684 ldns_rdf* hashed_label = NULL;
692 hashed_label = ldns_nsec3_hash_name(dname, nsec3params->
algorithm,
698 hashed_ownername = ldns_dname_cat_clone((
const ldns_rdf*) hashed_label,
699 (
const ldns_rdf*) apex);
700 if (!hashed_ownername) {
703 ldns_rdf_deep_free(hashed_label);
704 return hashed_ownername;
716 ldns_rbnode_t* new_node = LDNS_RBTREE_NULL;
717 ldns_rbnode_t* pnode = LDNS_RBTREE_NULL;
718 ldns_rdf* owner = NULL;
728 owner = dname_hash(dname, z->
apex, n3p);
730 owner = ldns_rdf_clone(dname);
733 ods_log_error(
"[%s] unable to add denial: create owner failed",
739 ods_log_error(
"[%s] unable to add denial: denial_create() failed",
743 new_node = denial2node(denial);
745 ods_log_error(
"[%s] unable to add denial: denial2node() failed",
749 if (!ldns_rbtree_insert(db->
denials, new_node)) {
753 free((
void*)new_node);
758 denial->
node = new_node;
760 pnode = ldns_rbtree_previous(new_node);
761 if (!pnode || pnode == LDNS_RBTREE_NULL) {
762 pnode = ldns_rbtree_last(db->
denials);
780 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
781 ldns_rbnode_t* pnode = LDNS_RBTREE_NULL;
784 if (!denial || !db || !db->
denials) {
788 ods_log_error(
"[%s] unable to delete denial: denial in use [#%u]",
793 pnode = ldns_rbtree_previous(denial->
node);
794 if (!pnode || pnode == LDNS_RBTREE_NULL) {
795 pnode = ldns_rbtree_last(db->
denials);
800 node = ldns_rbtree_delete(db->
denials, (
const void*)denial->
dname);
823 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
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);
837 node = ldns_rbtree_first(db->
domains);
838 if (!node || node == LDNS_RBTREE_NULL) {
841 while (node && node != LDNS_RBTREE_NULL) {
843 node = ldns_rbtree_next(node);
844 if (!namedb_del_denial_trigger(db, domain, 0)) {
846 namedb_add_denial_trigger(db, domain);
860 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
865 node = ldns_rbtree_first(db->
domains);
866 if (!node || node == LDNS_RBTREE_NULL) {
869 while (node && node != LDNS_RBTREE_NULL) {
871 node = ldns_rbtree_next(node);
873 (void) namedb_del_denial_trigger(db, domain, 1);
886 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
887 ldns_rbnode_t* nxt_node = LDNS_RBTREE_NULL;
890 uint32_t nsec_added = 0;
892 node = ldns_rbtree_first(db->
denials);
893 while (node && node != LDNS_RBTREE_NULL) {
895 nxt_node = ldns_rbtree_next(node);
896 if (!nxt_node || nxt_node == LDNS_RBTREE_NULL) {
897 nxt_node = ldns_rbtree_first(db->
denials);
901 node = ldns_rbtree_next(node);
904 *num_added = nsec_added;
918 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
930 if (db->
domains->root != LDNS_RBTREE_NULL) {
931 node = ldns_rbtree_first(db->
domains);
933 while (node && node != LDNS_RBTREE_NULL) {
941 "CNAME and other data at the same name",
LOG_ERR);
947 "multiple CNAMEs at the same name",
LOG_ERR);
956 "multiple DNAMEs at the same name",
LOG_ERR);
965 node = ldns_rbtree_next(node);
978 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
989 node = ldns_rbtree_first(db->
denials);
990 while (node && node != LDNS_RBTREE_NULL) {
992 if (!denial->
rrset) {
993 node = ldns_rbtree_next(node);
1016 denial->
rrset = NULL;
1017 node = ldns_rbtree_next(node);
1031 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
1033 if (!fd || !db || !db->
domains) {
1035 ods_log_error(
"[%s] unable to export namedb: file descriptor "
1036 "or name database missing",
db_str);
1041 node = ldns_rbtree_first(db->
domains);
1042 if (!node || node == LDNS_RBTREE_NULL) {
1043 fprintf(fd,
"; empty zone\n");
1049 while (node && node != LDNS_RBTREE_NULL) {
1054 node = ldns_rbtree_next(node);
1065 domain_delfunc(ldns_rbnode_t* elem)
1068 if (elem && elem != LDNS_RBTREE_NULL) {
1070 domain_delfunc(elem->left);
1071 domain_delfunc(elem->right);
1084 denial_delfunc(ldns_rbnode_t* elem)
1088 if (elem && elem != LDNS_RBTREE_NULL) {
1090 denial_delfunc(elem->left);
1091 denial_delfunc(elem->right);
1111 domain_delfunc(db->
domains->root);
1112 ldns_rbtree_free(db->
domains);
1127 denial_delfunc(db->
denials->root);
1128 ldns_rbtree_free(db->
denials);
1151 namedb_cleanup_domains(db);
1164 ldns_rbnode_t* node = LDNS_RBTREE_NULL;
1170 node = ldns_rbtree_first(db->
domains);
1171 while (node && node != LDNS_RBTREE_NULL) {
1174 node = ldns_rbtree_next(node);
1177 node = ldns_rbtree_first(db->
denials);
1178 while (node && node != LDNS_RBTREE_NULL) {
1180 if (denial->
rrset) {
1183 node = ldns_rbtree_next(node);
1187 node = ldns_rbtree_first(db->
domains);
1188 while (node && node != LDNS_RBTREE_NULL) {
1191 node = ldns_rbtree_next(node);
1193 node = ldns_rbtree_first(db->
denials);
1194 while (node && node != LDNS_RBTREE_NULL) {
1196 if (denial->
rrset) {
1199 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)