static addrMapNode* getNode(void* addr)
{
addrMapNode n;
n.chunk.addr = (u8*)addr;
auto p = rbtree_find(&sAddrMap, &n.node);
return p ? getAddrMapNode(p) : nullptr;
}
void
rbtree_insert(struct rbtree *tree, struct rbtree_elem *elem)
{
rbnode_t root;
//rbtree_inorder_check(tree) ;
root = tree->root;
#if 0
if (node = rbtree_find(tree, elem)) {
//rbtree_inorder_check(tree) ;
return false;
}
#endif
//rbtree_inorder_check(tree) ;
elem->left = elem->right = elem->parent = nil;
elem->color = _RED_;
node_insert(&tree->root, elem, tree->less, tree->aux);
//if (node->parent!=nil && node->parent->left==node) ASSERT(node->high<node->parent->low) ;
//if (node->parent!=nil && node->parent->right==node) ASSERT(node->low>node->parent->high) ;
//if (node->right!=nil) ASSERT(node->high<node->right->low) ;
//if (node->left!=nil) ASSERT(node->low>node->left->high) ;
//rbtree_inorder_check(tree);
}
/************ private functions *************/
static SECURID_SESSION *securid_sessionlist_delete(rlm_securid_t *inst, SECURID_SESSION *session)
{
rbnode_t *node;
node = rbtree_find(inst->session_tree, session);
if (!node) return NULL;
session = rbtree_node2data(inst->session_tree, node);
/*
* Delete old session from the tree.
*/
rbtree_delete(inst->session_tree, node);
/*
* And unsplice it from the linked list.
*/
if (session->prev) {
session->prev->next = session->next;
} else {
inst->session_head = session->next;
}
if (session->next) {
session->next->prev = session->prev;
} else {
inst->session_tail = session->prev;
}
session->prev = session->next = NULL;
return session;
}
/*!
* Check whether the tree contains an object [takes O(log n) operations]
*
* \param tree The tree
*
* \param object The query object
*
* \return (true) if an equal object is found in the tree, otherwise (false)
*/
BOOL rbtree_contains
(
rbtree_t * tree,
void * object
)
{
return (rbtree_find(tree, object) != NULL);
}
static inline vres_event_t *vres_event_lookup(vres_event_group_t *group, vres_event_desc_t *desc)
{
rbtree_node_t *node = NULL;
if (!rbtree_find(&group->tree, desc, &node))
return tree_entry(node, vres_event_t, node);
else
return NULL;
}
/** Find the user data.
*
*/
void *rbtree_finddata(rbtree_t *tree, void const *data)
{
rbnode_t *x;
x = rbtree_find(tree, data);
if (!x) return NULL;
return x->data;
}
player_t find_player_by_actname(const char* actname)
{
string_t key = new_string(actname);
struct rbnode *node = rbtree_find(g_player_tree,(void*)key);
player_t ply = NULL;
if(node) ply = (player_t)(((char*)node)-sizeof(struct refbase));
release_string(key);
return ply;
}
/*
* Find the user data.
*/
void *rbtree_finddata(rbtree_t *tree, const void *Data)
{
rbnode_t *X;
X = rbtree_find(tree, Data);
if (!X) return NULL;
return X->Data;
}
//map_find返回一个pair
void *map_find(map *m, const void *key) {
rbnode *n = rbtree_find(m->_t, key);
if (n == NULL) {
return NULL;
} else {
return RBNODE_VAL(n);
}
return NULL;
}
/** Delete a node from the tree, based on given data, which MUST have come from rbtree_finddata().
*
*
*/
bool rbtree_deletebydata(rbtree_t *tree, void const *data)
{
rbnode_t *node = rbtree_find(tree, data);
if (!node) return false;
rbtree_delete(tree, node);
return true;
}
/*
* Delete a node from the tree, based on given data, which MUST
* have come from rbtree_finddata().
*/
int rbtree_deletebydata(rbtree_t *tree, const void *data)
{
rbnode_t *node = rbtree_find(tree, data);
if (!node) return 0; /* false */
rbtree_delete(tree, node);
return 1;
}
struct rbnode* rbtree_remove(rbtree_t rb,void *key)
{
struct rbnode *n = rbtree_find(rb,key);
if(n)
{
rbtree_erase(n);
return n;
}
return NULL;
}
/*************************************************************************
* Read a motif database
*************************************************************************/
static MOTIF_DB_T* read_motifs(int id, char* motif_source, char* bg_source,
ARRAY_T** bg, double pseudocount, RBTREE_T *selected, ALPH_T alph) {
// vars
int read_motifs;
MOTIF_DB_T* motifdb;
MREAD_T *mread;
MOTIF_T *motif;
ARRAYLST_T *motifs;
// open the motif file for reading
mread = mread_create(motif_source, OPEN_MFILE);
mread_set_pseudocount(mread, pseudocount);
// determine background to use
if (*bg != NULL) mread_set_background(mread, *bg);
else mread_set_bg_source(mread, bg_source);
// load motifs
read_motifs = 0;
if (rbtree_size(selected) > 0) {
motifs = arraylst_create();
while(mread_has_motif(mread)) {
motif = mread_next_motif(mread);
read_motifs++;
if (rbtree_find(selected, get_motif_id(motif))) {
arraylst_add(motif, motifs);
} else {
DEBUG_FMT(NORMAL_VERBOSE, "Discarding motif %s in %s.\n",
get_motif_id(motif), motif_source);
destroy_motif(motif);
}
}
} else {
motifs = mread_load(mread, NULL);
read_motifs = arraylst_size(motifs);
}
arraylst_fit(motifs);
if (read_motifs > 0) {
// check the alphabet
if (mread_get_alphabet(mread) != alph) {
die("Expected %s alphabet motifs\n", alph_name(alph));
}
// get the background
if (*bg == NULL) *bg = mread_get_background(mread);
} else {
fprintf(stderr, "Warning: Motif file %s contains no motifs.\n", motif_source);
}
// clean up motif reader
mread_destroy(mread);
// create motif db
motifdb = mm_malloc(sizeof(MOTIF_DB_T));
memset(motifdb, 0, sizeof(MOTIF_DB_T));
motifdb->id = id;
motifdb->source = strdup(motif_source);
motifdb->motifs = motifs;
return motifdb;
}
static inline vres_file_t *vres_file_lookup_file(const char *path)
{
vres_file_t *file = NULL;
rbtree_node_t *node = NULL;
pthread_rwlock_rdlock(&vres_file_flock);
if (!rbtree_find(&vres_file_ftree, path, &node))
file = tree_entry(node, vres_file_t, f_node);
pthread_rwlock_unlock(&vres_file_flock);
return file;
}
bool fr_packet_list_yank(fr_packet_list_t *pl, RADIUS_PACKET *request)
{
rbnode_t *node;
if (!pl || !request) return false;
node = rbtree_find(pl->tree, &request);
if (!node) return false;
rbtree_delete(pl->tree, node);
return true;
}
/*!
* Remove an object from the tree [takes O(log n) operations]
*
* \param tree The tree
*
* \param object The object to be removed
*
* \pre The object should be contained in the tree
*/
void rbtree_remove
(
rbtree_t * tree,
void * object
)
{
/* find the node */
rbnode_t * node = rbtree_find(tree, object);
/* remove the node */
if (node)
rbtree_remove_node(tree, node);
}
int search(float alt, float vis, TransformInput *ti)
{
struct RBitem search_ti = set_alt_vis(alt, vis);
struct RBitem *found_ti;
found_ti = (struct RBitem *)rbtree_find(RBTree, &search_ti);
if (found_ti) {
*ti = found_ti->ti;
return 1;
}
else
return 0;
}
static void eaplist_expire(rlm_eap_t *inst, REQUEST *request, time_t timestamp)
{
int i;
eap_handler_t *handler;
/*
* Check the first few handlers in the list, and delete
* them if they're too old. We don't need to check them
* all, as incoming requests will quickly cause older
* handlers to be deleted.
*
*/
for (i = 0; i < 3; i++) {
handler = inst->session_head;
if (!handler) break;
RDEBUG("Expiring EAP session with state "
"0x%02x%02x%02x%02x%02x%02x%02x%02x",
handler->state[0], handler->state[1],
handler->state[2], handler->state[3],
handler->state[4], handler->state[5],
handler->state[6], handler->state[7]);
/*
* Expire entries from the start of the list.
* They should be the oldest ones.
*/
if ((timestamp - handler->timestamp) > inst->timer_limit) {
rbnode_t *node;
node = rbtree_find(inst->session_tree, handler);
rad_assert(node != NULL);
rbtree_delete(inst->session_tree, node);
/*
* handler == inst->session_head
*/
inst->session_head = handler->next;
if (handler->next) {
handler->next->prev = NULL;
} else {
inst->session_head = NULL;
inst->session_tail = NULL;
}
eap_handler_free(inst, handler);
} else {
break;
}
}
}
static inline void vres_file_delete_file(const char *path)
{
vres_file_t *file = NULL;
rbtree_node_t *node = NULL;
pthread_rwlock_wrlock(&vres_file_flock);
if (!rbtree_find(&vres_file_ftree, path, &node)) {
file = tree_entry(node, vres_file_t, f_node);
rbtree_remove_node(&vres_file_ftree, node);
}
pthread_rwlock_unlock(&vres_file_flock);
if (file)
free(file);
log_file_delete_file(path);
}
void
rbtree_delete(struct rbtree *tree, struct rbtree_elem *elem)
{
#if 0
struct rbtree_elem *parent, *succ, *pred, *node;
//rbtree_inorder_check(tree) ;
if (!(node = rbtree_find(tree, elem))) {
//rbtree_inorder_check(tree) ;
return false;
}
#endif
node_delete(tree, elem) ;
//rbtree_inorder_check(tree) ;
}
int router_add(struct router_t* router, const uint8_t id[N_NODEID], const struct sockaddr_storage* addr, struct node_t** node)
{
int r;
struct rbitem_t* item;
struct rbtree_node_t **link;
struct rbtree_node_t *parent;
if (node) *node = NULL;
item = calloc(1, sizeof(*item));
if (!item)
return ENOMEM;
item->node = node_create2(id, addr);
if (!item->node)
{
free(item->node);
return ENOMEM;
}
locker_lock(&router->locker);
r = rbtree_find(&router->rbtree, id, &parent);
if (0 == r)
{
if (node)
{
*node = (rbtree_entry(parent, struct rbitem_t, link))->node;
node_addref(*node);
}
locker_unlock(&router->locker);
node_release(item->node);
free(item);
return EEXIST;
}
link = parent ? (r > 0 ? &parent->left : &parent->right) : NULL;
assert(!link || !*link);
rbtree_insert(&router->rbtree, parent, link, &item->link);
router->count += 1;
if (node)
{
node_addref(item->node);
*node = item->node;
}
locker_unlock(&router->locker);
return 0;
}
/**
* @brief Unregister an xlat function.
*
* We can only have one function to call per name, so the
* passing of "func" here is extraneous.
*
* @param module xlat to unregister
* @param func Unused
* @return Void.
*/
void xlat_unregister(const char *module, RAD_XLAT_FUNC func)
{
rbnode_t *node;
xlat_t my_xlat;
func = func; /* -Wunused */
if (!module) return;
strlcpy(my_xlat.module, module, sizeof(my_xlat.module));
my_xlat.length = strlen(my_xlat.module);
node = rbtree_find(xlat_root, &my_xlat);
if (!node) return;
rbtree_delete(xlat_root, node);
}
void *
jumptable2_find(struct rbtree *rb, target_ulong eip_virt)
{
struct tb_t tb;
struct rbtree_elem *found;
tb.eip_virt = eip_virt;
tb.end_eip = eip_virt;
if ((found = rbtree_find(rb, &tb.jumptable2_elem))) {
struct tb_t *ret;
/*The entries in v->jumptable2 should always be unique. */
/*ASSERT( rbtree_next(found) == rbtree_end(&v->jumptable2)
|| tb_less(found, rbtree_next(found), NULL));*/
ret = rbtree_entry(found, struct tb_t, jumptable2_elem);
return ret;
}
return NULL;
}
tb_t *
tb_find(struct rbtree *rb, const void *tc_ptr)
{
struct tb_t tb;
uint16_t tc_boundaries[1] = {1};
struct rbtree_elem *found;
struct tb_t *ret;
tb.num_insns = 0;
tb.tc_boundaries = tc_boundaries;
tb.tc_ptr = (void *)tc_ptr;
if (!(found = rbtree_find(rb, &tb.tc_elem))) {
return NULL;
}
ASSERT( rbtree_next(found) == rbtree_end(rb)
|| tc_less(found, rbtree_next(found), NULL));
ret = rbtree_entry(found, struct tb_t, tc_elem);
return ret;
}
/*
* Look up a particular request, using:
*
* Request Id, request code, source IP, source port,
*
* Note that we do NOT use the request vector to look up requests.
*
* We MUST NOT have two requests with identical (id/code/IP/port), and
* different vectors. This is a serious error!
*/
REQUEST *rl_find_proxy(RADIUS_PACKET *packet)
{
rbnode_t *node;
REQUEST myrequest, *maybe = NULL;
RADIUS_PACKET myproxy;
/*
* If we use the socket FD as an indicator,
* then that implicitely contains information
* as to our src ipaddr/port, so we don't need
* to use that in the comparisons.
*/
myproxy.sockfd = packet->sockfd;
myproxy.id = packet->id;
myproxy.dst_ipaddr = packet->src_ipaddr;
myproxy.dst_port = packet->src_port;
#ifndef NDEBUG
myrequest.magic = REQUEST_MAGIC;
#endif
myrequest.proxy = &myproxy;
pthread_mutex_lock(&proxy_mutex);
node = rbtree_find(proxy_tree, &myrequest);
if (node) {
maybe = rbtree_node2data(proxy_tree, node);
rad_assert(maybe->proxy_outstanding > 0);
maybe->proxy_outstanding--;
/*
* Received all of the replies we expect.
* delete it from both trees.
*/
if (maybe->proxy_outstanding == 0) {
rl_delete_proxy(&myrequest, node);
}
}
pthread_mutex_unlock(&proxy_mutex);
return maybe;
}
static struct ffsb_file *choose_file(struct benchfiles *b, randdata_t *rd)
{
rb_node *cur = NULL;
int chosen = 0;
struct ffsb_file temp;
temp.num = chosen;
if (b->listsize == 0) {
fprintf(stderr, "No more files to operate on,"
" try making more initial files "
"or fewer delete operations\n");
exit(0);
}
while (cur == NULL) {
chosen = getrandom(rd, b->listsize);
temp.num = chosen;
cur = rbtree_find(b->files, &temp);
}
return cur->object;
}
static void securid_sessionlist_clean_expired(rlm_securid_t *inst, REQUEST *request, time_t timestamp)
{
int num_sessions;
SECURID_SESSION *session;
num_sessions = rbtree_num_elements(inst->session_tree);
RDEBUG2("There are %d sessions in the tree\n",num_sessions);
/*
* Delete old sessions from the list
*
*/
while((session = inst->session_head)) {
if ((timestamp - session->timestamp) > inst->timer_limit) {
rbnode_t *node;
node = rbtree_find(inst->session_tree, session);
rad_assert(node != NULL);
rbtree_delete(inst->session_tree, node);
/*
* session == inst->session_head
*/
inst->session_head = session->next;
if (session->next) {
session->next->prev = NULL;
} else {
inst->session_head = NULL;
inst->session_tail = NULL;
}
RDEBUG2("Cleaning expired session: identity='%s' state='%s'\n",
SAFE_STR(session->identity),session->state);
securid_session_free(inst,request,session);
} else {
/* no need to check all sessions since they are sorted by age */
break;
}
}
}
int router_remove(struct router_t* router, const uint8_t id[N_NODEID])
{
int r;
struct rbitem_t* item;
struct rbtree_node_t* node;
locker_lock(&router->locker);
r = rbtree_find(&router->rbtree, id, &node);
if (0 != r)
{
locker_unlock(&router->locker);
return ENOENT;
}
router->count -= 1;
item = rbtree_entry(node, struct rbitem_t, link);
rbtree_delete(&router->rbtree, node);
locker_unlock(&router->locker);
node_release(item->node);
free(item);
return 0;
}
static eap_handler_t *eaplist_delete(rlm_eap_t *inst, REQUEST *request,
eap_handler_t *handler)
{
rbnode_t *node;
node = rbtree_find(inst->session_tree, handler);
if (!node) return NULL;
handler = rbtree_node2data(inst->session_tree, node);
RDEBUG("Finished EAP session with state "
"0x%02x%02x%02x%02x%02x%02x%02x%02x",
handler->state[0], handler->state[1],
handler->state[2], handler->state[3],
handler->state[4], handler->state[5],
handler->state[6], handler->state[7]);
/*
* Delete old handler from the tree.
*/
rbtree_delete(inst->session_tree, node);
/*
* And unsplice it from the linked list.
*/
if (handler->prev) {
handler->prev->next = handler->next;
} else {
inst->session_head = handler->next;
}
if (handler->next) {
handler->next->prev = handler->prev;
} else {
inst->session_tail = handler->prev;
}
handler->prev = handler->next = NULL;
return handler;
}
static inline int vres_file_pop(char *path)
{
size_t len;
char *filename;
char dirname[FILE_PATH_MAX];
if (vres_file_dirname(path, dirname)) {
log_err("invalid path, path=%s", path);
return -1;
}
filename = path + strlen(dirname);
len = strlen(filename);
if ((len > 0) && (len + filename - path < FILE_PATH_MAX)) {
vres_file_dir_t *dir = vres_file_lookup_dir(dirname);
if (!dir)
return -1;
pthread_rwlock_wrlock(&dir->d_lock);
if (dir->d_count > 0) {
rbtree_node_t *node = NULL;
if (!rbtree_find(&dir->d_tree, filename, &node)) {
vres_file_name_t *name = tree_entry(node, vres_file_name_t, node);
rbtree_remove_node(&dir->d_tree, node);
dir->d_count--;
free(name);
}
}
pthread_rwlock_unlock(&dir->d_lock);
} else {
log_err("invalid path, path=%s", path);
return -1;
}
return 0;
}
