/** * Lookup zone. * */ static zone_type* zonelist_lookup_zone(zonelist_type* zonelist, zone_type* zone) { ldns_rbnode_t* node = LDNS_RBTREE_NULL; if (zonelist && zonelist->zones && zone) { node = ldns_rbtree_search(zonelist->zones, zone); if (node) { return (zone_type*) node->data; } } return NULL; }
ldns_status ldns_dnssec_zone_add_rr(ldns_dnssec_zone *zone, ldns_rr *rr) { ldns_status result = LDNS_STATUS_OK; ldns_dnssec_name *cur_name; ldns_rbnode_t *cur_node; ldns_rr_type type_covered = 0; if (!zone || !rr) { return LDNS_STATUS_ERR; } if (!zone->names) { zone->names = ldns_rbtree_create(ldns_dname_compare_v); if(!zone->names) return LDNS_STATUS_MEM_ERR; } /* we need the original of the hashed name if this is an NSEC3, or an RRSIG that covers an NSEC3 */ if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_RRSIG) { type_covered = ldns_rdf2rr_type(ldns_rr_rrsig_typecovered(rr)); } if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_NSEC3 || type_covered == LDNS_RR_TYPE_NSEC3) { cur_node = ldns_dnssec_zone_find_nsec3_original(zone, rr); if (!cur_node) { return LDNS_STATUS_DNSSEC_NSEC3_ORIGINAL_NOT_FOUND; } } else { cur_node = ldns_rbtree_search(zone->names, ldns_rr_owner(rr)); } if (!cur_node) { /* add */ cur_name = ldns_dnssec_name_new_frm_rr(rr); if(!cur_name) return LDNS_STATUS_MEM_ERR; cur_node = LDNS_MALLOC(ldns_rbnode_t); if(!cur_node) { ldns_dnssec_name_free(cur_name); return LDNS_STATUS_MEM_ERR; } cur_node->key = ldns_rr_owner(rr); cur_node->data = cur_name; (void)ldns_rbtree_insert(zone->names, cur_node); ldns_dnssec_name_make_hashed_name(zone, cur_name, NULL); } else { cur_name = (ldns_dnssec_name *) cur_node->data; result = ldns_dnssec_name_add_rr(cur_name, rr); } if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_SOA) { zone->soa = cur_name; } return result; }
struct getdns_dict_item * getdns_dict_find_and_add(struct getdns_dict *dict, const char *key) { struct getdns_dict_item *item; item = (struct getdns_dict_item *) ldns_rbtree_search(&(dict->root), key); if (!item) { /* add a node */ item = GETDNS_MALLOC(dict->mf, struct getdns_dict_item); item->node.key = getdns_strdup(&dict->mf, key); item->data.n = 0; ldns_rbtree_insert(&(dict->root), (ldns_rbnode_t *) item); }
static shm_address_t *MV_SHM_lookup_virtaddress_node( ldns_rbtree_t *shm_root, const uint address) { ldns_rbnode_t *search_node; shm_address_t shm_node; shm_node.m_flag = SHM_VIRT_SEARCH; shm_node.m_virtaddress = address; search_node = ldns_rbtree_search(shm_root, &shm_node); if (search_node != NULL) return (shm_address_t *)(search_node->key); else return NULL; }
static ldns_rbnode_t * ldns_dnssec_zone_find_nsec3_original(ldns_dnssec_zone *zone, ldns_rr *rr) { ldns_rdf *hashed_name; hashed_name = ldns_dname_label(ldns_rr_owner(rr), 0); if (hashed_name == NULL) { return NULL; } if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_NSEC3 && ! zone->_nsec3params){ ldns_dnssec_zone_hashed_names_from_nsec3(zone, rr); } if (zone->hashed_names == NULL) { ldns_rdf_deep_free(hashed_name); return NULL; } return ldns_rbtree_search(zone->hashed_names, hashed_name); }
ldns_dnssec_rrsets * ldns_dnssec_zone_find_rrset(ldns_dnssec_zone *zone, ldns_rdf *dname, ldns_rr_type type) { ldns_rbnode_t *node; if (!zone || !dname) { return NULL; } node = ldns_rbtree_search(zone->names, dname); if (node) { return ldns_dnssec_name_find_rrset((ldns_dnssec_name *)node->data, type); } else { return NULL; } }
ods_status schedule_task(schedule_type* schedule, task_type* task) { ldns_rbnode_t *node1, *node2; ods_status status; task_type* task2; if (!task) { ods_log_error("[%s] unable to schedule task: no task", schedule_str); return ODS_STATUS_ERR; } task->flush = 0; if (!schedule || !schedule->tasks) { ods_log_error("[%s] unable to schedule task: no schedule", schedule_str); return ODS_STATUS_ERR; } ods_log_debug("[%s] schedule task [%s] for %s", schedule_str, task_what2str(task->what), task_who2str(task->who)); pthread_mutex_lock(&schedule->schedule_lock); status = ODS_STATUS_ERR; if ((node1 = task2node(task))) { if (ldns_rbtree_insert(schedule->tasks_by_name, node1)) { if ((node2 = task2node(task))) { if(ldns_rbtree_insert(schedule->tasks, node2)) { /* success inserting in two trees */ set_alarm(schedule); status = ODS_STATUS_OK; } else { /* insert in tasks tree failed */ ods_log_error("[%s] unable to schedule task [%s] for %s: " " already present", schedule_str, task_what2str(task->what), task_who2str(task->who)); /* this will free node1 */ free(ldns_rbtree_delete(schedule->tasks_by_name, node1)); free(node2); } } else { /* could not alloc node2 */ /* this will free node1 */ free(ldns_rbtree_delete(schedule->tasks_by_name, node1)); } } else {/* insert in name tree failed */ free(node1); /** * Task is already in tasks_by_name queue, so we must * update it in tasks queue */ /* still in lock guaranteed to succeed. */ node1 = ldns_rbtree_search(schedule->tasks_by_name, task); /* This copy of 'task' is referenced by both trees */ task2 = (task_type*)node1->key; node1 = ldns_rbtree_delete(schedule->tasks, task2); if (task->when < task2->when) task2->when = task->when; if (task2->context && task2->clean_context) { task2->clean_context(task2); } task2->context = task->context; task2->clean_context = task->clean_context; task->context = NULL; task_cleanup(task); (void) ldns_rbtree_insert(schedule->tasks, node1); /* node1 now owned by tree */ node1 = NULL; set_alarm(schedule); status = ODS_STATUS_OK; } } /* else {failure) */ pthread_mutex_unlock(&schedule->schedule_lock); return status; }
/** * private function used to locate a key in a dictionary * @param dict dicitonary to search * @param key key to search for * @param addifnotfnd if TRUE then an item will be added if the key is not found * @return pointer to dictionary item, caller must not free storage associated with item * @return NULL if additnotfnd == FALSE and key is not in dictionary */ struct getdns_dict_item * getdns_dict_find(const struct getdns_dict *dict, const char *key) { return (struct getdns_dict_item *) ldns_rbtree_search((ldns_rbtree_t *)&(dict->root), key); } /* getdns_dict_find */