/** read lock entry */
static void read_lock(rbtree_t* all, FILE* in, int val)
{
struct order_id prev_id, now_id;
struct lock_ref* ref;
struct order_lock* prev, *now;
ref = (struct lock_ref*)calloc(1, sizeof(struct lock_ref));
if(!ref) fatal_exit("malloc failure");
prev_id.thr = val;
if(fread(&prev_id.instance, sizeof(int), 1, in) != 1 ||
fread(&now_id.thr, sizeof(int), 1, in) != 1 ||
fread(&now_id.instance, sizeof(int), 1, in) != 1 ||
!readup_str(&ref->file, in) ||
fread(&ref->line, sizeof(int), 1, in) != 1)
fatal_exit("fread failed");
if(verb) printf("read lock %u %u %u %u %s %d\n",
(unsigned)prev_id.thr, (unsigned)prev_id.instance,
(unsigned)now_id.thr, (unsigned)now_id.instance,
ref->file, ref->line);
/* find the two locks involved */
prev = (struct order_lock*)rbtree_search(all, &prev_id);
now = (struct order_lock*)rbtree_search(all, &now_id);
/* if not there - insert 'em */
if(!prev) prev = insert_lock(all, &prev_id);
if(!now) now = insert_lock(all, &now_id);
ref->lock = prev;
ref->node.key = &prev->id;
if(!rbtree_insert(now->smaller, &ref->node)) {
free(ref->file);
free(ref);
}
}
RB_NODE *
rbtree_search(RB_TREE *T, RB_NODE *x, int k)
{
if (x == T->nil || k == x->key)
return(x);
if (k < x->key)
return(rbtree_search(T, x->left, k));
else
return(rbtree_search(T, x->right, k));
}
static struct diff_xfrpart*
diff_read_find_part(struct diff_zone* zp, uint32_t seq_nr)
{
struct diff_xfrpart* xp = (struct diff_xfrpart*)
rbtree_search(zp->parts, &seq_nr);
return xp;
}
unsigned getzonestatid(nsd_options_t* opt, zone_options_t* zopt)
{
#ifdef USE_ZONE_STATS
const char* statname;
struct zonestatname* n;
rbnode_t* res;
/* try to find the instantiated zonestat name */
if(!zopt->pattern->zonestats || zopt->pattern->zonestats[0]==0)
return 0; /* no zone stats */
statname = config_cook_string(zopt, zopt->pattern->zonestats);
res = rbtree_search(opt->zonestatnames, statname);
if(res)
return ((struct zonestatname*)res)->id;
/* create it */
n = (struct zonestatname*)xalloc(sizeof(*n));
memset(n, 0, sizeof(*n));
n->node.key = strdup(statname);
if(!n->node.key) {
log_msg(LOG_ERR, "malloc failed: %s", strerror(errno));
exit(1);
}
n->id = (unsigned)(opt->zonestatnames->count);
rbtree_insert(opt->zonestatnames, (rbnode_t*)n);
return n->id;
#else /* USE_ZONE_STATS */
(void)opt; (void)zopt;
return 0;
#endif /* USE_ZONE_STATS */
}
static struct list* wd_lookup(int wd) {
struct watch n, *np = &n;
struct list s = { (void**)&np, 1 };
n.wd = wd;
return rbtree_search(&tree_wd_paths, &s);
}
void
anchors_delete_insecure(struct val_anchors* anchors, uint16_t c,
uint8_t* nm)
{
struct trust_anchor key;
struct trust_anchor* ta;
key.node.key = &key;
key.name = nm;
key.namelabs = dname_count_size_labels(nm, &key.namelen);
key.dclass = c;
lock_basic_lock(&anchors->lock);
if(!(ta=(struct trust_anchor*)rbtree_search(anchors->tree, &key))) {
lock_basic_unlock(&anchors->lock);
/* nothing there */
return;
}
/* lock it to drive away other threads that use it */
lock_basic_lock(&ta->lock);
/* see if its really an insecure point */
if(ta->keylist || ta->autr || ta->numDS || ta->numDNSKEY) {
lock_basic_unlock(&anchors->lock);
lock_basic_unlock(&ta->lock);
/* its not an insecure point, do not remove it */
return;
}
/* remove from tree */
(void)rbtree_delete(anchors->tree, &ta->node);
anchors_init_parents_locked(anchors);
lock_basic_unlock(&anchors->lock);
/* actual free of data */
lock_basic_unlock(&ta->lock);
anchors_delfunc(&ta->node, NULL);
}
bool
rbtree_delete(struct rbtree *tree, ipaddr_t IP)
{
struct rbtree_elem *parent, *succ, *pred, *node;
if (!rbtree_search(tree, IP, &node)) {
return false;
}
if (node->low == IP) {
if (node->high == IP) {
node_delete(&tree->root, node) ;
} else {
node->low++ ;
}
} else if (node->high == IP) {
node->high--;
} else {
rbnode_t new_node;
new_node = malloc(sizeof(struct rbtree_elem)) ;
ASSERT(new_node);
ASSERT(node->low < IP && node->high > IP) ;
new_node->low=IP+1 ; new_node->high=node->high ;
new_node->left=new_node->right=new_node->parent=nil ;
new_node->color = _RED_ ;
node->high = IP - 1;
node_insert_at(&tree->root, node, new_node);
}
return true;
}
/** read creation entry */
static void read_create(rbtree_t* all, FILE* in)
{
struct order_lock* o = calloc(1, sizeof(struct order_lock));
if(!o) fatal_exit("malloc failure");
if(fread(&o->id.thr, sizeof(int), 1, in) != 1 ||
fread(&o->id.instance, sizeof(int), 1, in) != 1 ||
!readup_str(&o->create_file, in) ||
fread(&o->create_line, sizeof(int), 1, in) != 1)
fatal_exit("fread failed");
o->smaller = rbtree_create(order_lock_cmp);
o->node.key = &o->id;
if(!rbtree_insert(all, &o->node)) {
/* already inserted */
struct order_lock* a = (struct order_lock*)rbtree_search(all,
&o->id);
log_assert(a);
a->create_file = o->create_file;
a->create_line = o->create_line;
free(o->smaller);
free(o);
o = a;
}
if(verb) printf("read create %u %u %s %d\n",
(unsigned)o->id.thr, (unsigned)o->id.instance,
o->create_file, o->create_line);
}
int
main(void)
{
//int i;
RB_TREE *T;
T = tree_init();
node_insert(T, 23);
node_insert(T, 94);
node_insert(T, 32);
node_insert(T, 84);
node_insert(T, 12);
node_insert(T, 8);
node_insert(T, 82);
node_insert(T, 31);
node_insert(T, 59);
node_insert(T, 41);
node_insert(T, 73);
//for ( i = 0 ; i < 1000 ; i++ ) {
// key = rand() % 1000;
// node_insert(T, key);
//}
inorder_tree_walk(T, T->root);
printf("\n");
node_delete(T, 32);
node_delete(T, 8);
node_delete(T, 4);
printf("after delete 32, 8, 4:\n");
inorder_tree_walk(T, T->root);
printf("\n");
printf("sucessor of 23 is %d\n", rbtree_successor(T, rbtree_search(T, T->root, 23))->key);
printf("predecessor of 84 is %d\n", rbtree_predecessor(T, rbtree_search(T, T->root, 84))->key);
printf("the maximun is %d\n", rbtree_maximum(T, T->root)->key);
printf("the minimum is %d\n", rbtree_minimum(T, T->root)->key);
node_destory(T, T->root);
tree_destory(T);
exit(0);
}
static struct diff_zone*
diff_read_find_zone(struct diff_read_data* data, const char* name)
{
const dname_type* dname = dname_parse(data->region, name);
struct diff_zone* zp = (struct diff_zone*)
rbtree_search(data->zones, dname);
return zp;
}
/** see if zone needs to have a hole inserted */
static int
need_hole_insert(rbtree_t* tree, struct iter_forward_zone* zone)
{
struct iter_forward_zone k;
if(rbtree_search(tree, zone))
return 0; /* exact match exists */
k = *zone;
k.node.key = &k;
/* search up the tree */
do {
dname_remove_label(&k.name, &k.namelen);
k.namelabs --;
if(rbtree_search(tree, &k))
return 1; /* found an upper forward zone, need hole */
} while(k.namelabs > 1);
return 0; /* no forwards above, no holes needed */
}
/** get var from store */
static struct replay_var*
macro_getvar(rbtree_t* store, char* name)
{
struct replay_var k;
k.node.key = &k;
k.name = name;
return (struct replay_var*)rbtree_search(store, &k);
}
void
xfrd_handle_passed_packet(buffer_type* packet, int acl_num)
{
uint8_t qnamebuf[MAXDOMAINLEN];
uint16_t qtype, qclass;
const dname_type* dname;
region_type* tempregion = region_create(xalloc, free);
xfrd_zone_t* zone;
buffer_skip(packet, QHEADERSZ);
if(!packet_read_query_section(packet, qnamebuf, &qtype, &qclass)) {
region_destroy(tempregion);
return; /* drop bad packet */
}
dname = dname_make(tempregion, qnamebuf, 1);
DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: got passed packet for %s, acl "
"%d", dname_to_string(dname,0), acl_num));
/* find the zone */
zone = (xfrd_zone_t*)rbtree_search(xfrd->zones, dname);
if(!zone) {
log_msg(LOG_INFO, "xfrd: incoming packet for unknown zone %s",
dname_to_string(dname,0));
region_destroy(tempregion);
return; /* drop packet for unknown zone */
}
region_destroy(tempregion);
/* handle */
if(OPCODE(packet) == OPCODE_NOTIFY) {
xfrd_soa_t soa;
int have_soa = 0;
int next;
/* get serial from a SOA */
if(ANCOUNT(packet) == 1 && packet_skip_dname(packet) &&
xfrd_parse_soa_info(packet, &soa)) {
have_soa = 1;
}
if(xfrd_handle_incoming_notify(zone, have_soa?&soa:NULL)) {
if(zone->zone_handler.fd == -1
&& zone->tcp_conn == -1 &&
!zone->tcp_waiting && !zone->udp_waiting) {
xfrd_set_refresh_now(zone);
}
}
next = find_same_master_notify(zone, acl_num);
if(next != -1) {
zone->next_master = next;
DEBUG(DEBUG_XFRD,1, (LOG_INFO,
"xfrd: notify set next master to query %d",
next));
}
}
else {
/* TODO handle incoming IXFR udp reply via port 53 */
}
}
static struct iter_forward_zone*
fwd_zone_find(struct iter_forwards* fwd, uint16_t c, uint8_t* nm)
{
struct iter_forward_zone key;
key.node.key = &key;
key.dclass = c;
key.name = nm;
key.namelabs = dname_count_size_labels(nm, &key.namelen);
return (struct iter_forward_zone*)rbtree_search(fwd->tree, &key);
}
int inotify_map_get_wd(const char *path) {
struct watch s, *n;
s.path = path;
n = rbtree_search(&tree_path_wd, &s);
if (n)
return n->wd;
return 0;
}
/** find a data node by exact name */
static struct local_data*
lz_find_node(struct local_zone* z, uint8_t* nm, size_t nmlen, int nmlabs)
{
struct local_data key;
key.node.key = &key;
key.name = nm;
key.namelen = nmlen;
key.namelabs = nmlabs;
return (struct local_data*)rbtree_search(&z->data, &key.node);
}
struct ctx_query* context_deserialize_cancel(struct ub_ctx* ctx,
uint8_t* p, uint32_t len)
{
struct ctx_query* q;
int id;
if(len != 2*sizeof(uint32_t)) return NULL;
log_assert( ldns_read_uint32(p) == UB_LIBCMD_CANCEL);
id = (int)ldns_read_uint32(p+sizeof(uint32_t));
q = (struct ctx_query*)rbtree_search(&ctx->queries, &id);
return q;
}
/* 删除任意值 */
int rbtree_delete(rbtree tree,int key){
int *val = rbtree_search(tree,key);
if(val==NULL) return 0;
rbtree_node root = tree->root;
if( !is_red(root->left) && !is_red(root->right) ){
root->color = RED;
}
root = _rbtree_delete(root,key);
if(root != NULL) root->color = BLACK;
return 1;
}
void
xfrd_send_notify(rbtree_t* tree, const dname_type* apex, struct xfrd_soa* new_soa)
{
/* lookup the zone */
struct notify_zone_t* zone = (struct notify_zone_t*)
rbtree_search(tree, apex);
assert(zone);
if(zone->notify_send_enable)
notify_disable(zone);
notify_enable(zone, new_soa);
}
void
node_delete(RB_TREE *T, int key)
{
RB_NODE *node;
if ((node = rbtree_search(T, T->root, key)) != T->nil) {
rb_delete(T, node);
free(node);
}
else
fprintf(stderr, "can't find %d\n", key);
}
void vint_sender_add_permission(UB sender_id, UB receiver_id, UHW irq_id){
UW key = ((UW)receiver_id) << 16 | irq_id;
node_t *node = rbtree_search(tree, (void *)key);
if(node){
UW mask = (UW)node->val | (1 << sender_id);
rbtree_insert(tree, (void *)key, (void *)mask);
}
else {
rbtree_insert(tree, (void *)key, (void *)(1 << sender_id));
}
}
void inotify_map(int wd, const char *path) {
struct watch s, *n;
s.path = path;
n = rbtree_search(&tree_path_wd, &s);
if (!n) {
n = new_node(wd, path);
map_path(n);
map_wd(n);
}
}
static void map_wd(struct watch *w) {
struct list s = { (void**)&w, 1 };
struct list *l = rbtree_search(&tree_wd_paths, &s);
if (l) {
list_insert(l, w);
} else {
l = list_create();
list_insert(l, w);
rbtree_insert(&tree_wd_paths, l);
}
}
/** find next useful id number of 0 on error */
static int
find_id(struct ub_ctx* ctx, int* id)
{
size_t tries = 0;
ctx->next_querynum++;
while(rbtree_search(&ctx->queries, &ctx->next_querynum)) {
ctx->next_querynum++; /* numerical wraparound is fine */
if(tries++ > NUM_ID_TRIES)
return 0;
}
*id = ctx->next_querynum;
return 1;
}
net_interface_t *net_interface_lookup_index(const int ifindex)
{
tree_node_t temp;
net_interface_t itemp;
rbtree_node_t *retval;
itemp.ifindex = ifindex;
temp.ni = &itemp;
retval = rbtree_search(interface_tree, &temp.header, cmpfnif);
return ((retval) ? (((tree_node_t *) retval)->ni) : NULL);
}
struct local_zone*
local_zones_find(struct local_zones* zones,
uint8_t* name, size_t len, int labs, uint16_t dclass)
{
struct local_zone key;
key.node.key = &key;
key.dclass = dclass;
key.name = name;
key.namelen = len;
key.namelabs = labs;
/* exact */
return (struct local_zone*)rbtree_search(&zones->ztree, &key);
}
struct mesh_state* mesh_area_find(struct mesh_area* mesh,
struct query_info* qinfo, uint16_t qflags, int prime)
{
struct mesh_state key;
struct mesh_state* result;
key.node.key = &key;
key.s.is_priming = prime;
key.s.qinfo = *qinfo;
key.s.query_flags = qflags;
result = (struct mesh_state*)rbtree_search(&mesh->all, &key);
return result;
}
int inotify_unmap_path(const char *path) {
int ret = 0;
struct watch *w, s;
s.path = path;
w = rbtree_search(&tree_path_wd, &s);
if (w) {
ret = unmap_wd(w);
unmap_path(w);
inotify_watch_destroy(w, unmap);
}
return ret;
}
GPrivate Int32_t urbt_search(RBTreeP_t pTree, Int32_t data)
{
Int32P_t pData = &data;
Int32P_t pResult = NULL;
pResult = (Int32P_t)rbtree_search(pTree, pData);
if (pResult != NULL)
{
return *pResult;
}
return 0;
}
/**
* Find the given data
* @param zone: negative zone
* @param nm: what to look for.
* @param len: length of nm
* @param labs: labels in nm
* @return data or NULL if not found.
*/
static struct val_neg_data* neg_find_data(struct val_neg_zone* zone,
uint8_t* nm, size_t len, int labs)
{
struct val_neg_data lookfor;
struct val_neg_data* result;
lookfor.node.key = &lookfor;
lookfor.name = nm;
lookfor.len = len;
lookfor.labs = labs;
result = (struct val_neg_data*)
rbtree_search(&zone->tree, lookfor.node.key);
return result;
}
