int
mib_fetch_route(void)
{
	u_char *rtab, *next;
	size_t len;
	struct sroute *r, *r1;
	struct rt_msghdr *rtm;
	struct sockaddr *addrs[RTAX_MAX];

	if (route_tick != 0 && route_tick + ROUTE_UPDATE_INTERVAL > this_tick)
		return (0);

	/*
	 * Remove all routes
	 */
	r = RB_MIN(sroutes, &sroutes);
	while (r != NULL) {
		r1 = RB_NEXT(sroutes, &sroutes, r);
		RB_REMOVE(sroutes, &sroutes, r);
		free(r);
		r = r1;
	}
	route_total = 0;

	if ((rtab = mib_fetch_rtab(AF_INET, NET_RT_DUMP, 0, &len)) == NULL)
		return (-1);

	next = rtab;
	for (next = rtab; next < rtab + len; next += rtm->rtm_msglen) {
		rtm = (struct rt_msghdr *)(void *)next;
		if (rtm->rtm_type != RTM_GET ||
		    !(rtm->rtm_flags & RTF_UP))
			continue;
		mib_extract_addrs(rtm->rtm_addrs, (u_char *)(rtm + 1), addrs);


		mib_sroute_process(rtm, addrs[RTAX_GATEWAY], addrs[RTAX_DST],
		    addrs[RTAX_NETMASK]);
	}

#if 0
	u_int n = 0;
	r = RB_MIN(sroutes, &sroutes);
	while (r != NULL) {
		printf("%u: ", n++);
		sroute_print(r);
		printf("\n");
		r = RB_NEXT(sroutes, &sroutes, r);
	}
#endif
	free(rtab);
	route_tick = get_ticks();

	return (0);
}

/* Free an environment. */
void
environ_free(struct environ *env)
{
	struct environ_entry	*envent, *envent1;

	RB_FOREACH_SAFE(envent, environ, env, envent1) {
		RB_REMOVE(environ, env, envent);
		free(envent->name);
		free(envent->value);
		free(envent);
	}

static void lang_code_free( lang_code_lookup_t *l )
{
  lang_code_lookup_element_t *element;
  if (l == NULL)
    return;
  while ((element = RB_FIRST(l)) != NULL) {
    RB_REMOVE(l, element, link);
    free(element);
  }
  free(l);
}

void	vm_map_store_entry_unlink_rb( struct vm_map_header *mapHdr, vm_map_entry_t entry)
{
	struct rb_head *rbh = &(mapHdr->rb_head_store);
	struct vm_map_store *rb_entry;
	struct vm_map_store *store = &(entry->store);
	
	rb_entry = RB_FIND( rb_head, rbh, store);	
	if(rb_entry == NULL)
		panic("NO ENTRY TO DELETE");
	RB_REMOVE( rb_head, rbh, store );
}

void
ct_rb_unwind(struct ct_match_tree *head)
{
	struct ct_match_node	*n;

	while ((n = RB_ROOT(head)) != NULL) {
		RB_REMOVE(ct_match_tree, head, n);
		e_free(&n->cmn_string);
		e_free(&n);
	}
}

/* Destroy a job tree. */
void
job_tree_free(struct jobs *jobs)
{
	struct job	*job;

	while (!RB_EMPTY(jobs)) {
		job = RB_ROOT(jobs);
		RB_REMOVE(jobs, jobs, job);
		job_free(job);
	}
}

/* Destroy (free memory) */
void lang_str_destroy ( lang_str_t *ls )
{ 
  lang_str_ele_t *e;
  if (ls == NULL)
    return;
  while ((e = RB_FIRST(ls))) {
    if (e->str)  free(e->str);
    RB_REMOVE(ls, e, link);
    free(e);
  }
  free(ls);
}

void
idnode_done(void)
{
  idclass_link_t *il;

  pthread_cond_signal(&idnode_cond);
  pthread_join(idnode_tid, NULL);
  pthread_mutex_lock(&idnode_mutex);
  htsmsg_destroy(idnode_queue);
  idnode_queue = NULL;
  pthread_mutex_unlock(&idnode_mutex);  
  while ((il = RB_FIRST(&idclasses)) != NULL) {
    RB_REMOVE(&idclasses, il, link);
    free(il);
  }
  while ((il = RB_FIRST(&idrootclasses)) != NULL) {
    RB_REMOVE(&idrootclasses, il, link);
    free(il);
  }
  SKEL_FREE(idclasses_skel);
}

/* Unset an environment variable. */
void
environ_unset(struct environ *env, const char *name)
{
	struct environ_entry	*envent;

	if ((envent = environ_find(env, name)) == NULL)
		return;
	RB_REMOVE(environ, env, envent);
	free(envent->name);
	free(envent->value);
	free(envent);
}

/* Free an environment. */
void
environ_free(struct environ *env)
{
	struct environ_entry	*envent;

	while (!RB_EMPTY(env)) {
		envent = RB_ROOT(env);
		RB_REMOVE(environ, env, envent);
		free(envent->name);
		free(envent->value);
		free(envent);
	}
}

void *tato_tree_int_remove(TatoTreeInt *thiss, unsigned int key) {
	TatoTreeIntNode node_scanned;
	node_scanned.key = key;

	TatoTreeIntNode *node = RB_FIND(TatoTreeInt_, thiss, &node_scanned);
	if (!node)
		return NULL;

	RB_REMOVE(TatoTreeInt_, thiss, node);
	void *result = node->value;
	free(node);
	return result;
}

mpls_return_enum mpls_tree_remove(mpls_tree_handle tree, uint32_t key, int length, void **info)
{
	struct mpls_tree_node *node;

	node = mpls_tree_find(tree, key, length);
	if(!node)
		return MPLS_FAILURE;
	*info = node->info;
	RB_REMOVE(mpls_tree, tree, node);
	mpls_free(node);
	
	return MPLS_SUCCESS;
}

void
intlconv_done( void )
{
  intlconv_cache_t *ic;

  pthread_mutex_lock(&intlconv_lock);
  intlconv_last_ic = NULL;
  while ((ic = RB_FIRST(&intlconv_all)) != NULL) {
    iconv_close(ic->ic_handle);
    free(ic->ic_charset_id);
    RB_REMOVE(&intlconv_all, ic, ic_link);
    free(ic);
  }
  intlconv_last_src_ic = NULL;
  while ((ic = RB_FIRST(&intlconv_src_all)) != NULL) {
    iconv_close(ic->ic_handle);
    free(ic->ic_charset_id);
    RB_REMOVE(&intlconv_src_all, ic, ic_link);
    free(ic);
  }
  pthread_mutex_unlock(&intlconv_lock);
}

/*
 * Free tags tree.
 */
void
unloadtags(void)
{
	struct ctag *var, *nxt;
	
	for (var = RB_MIN(tagtree, &tags); var != NULL; var = nxt) {
		nxt = RB_NEXT(tagtree, &tags, var);
		RB_REMOVE(tagtree, &tags, var);
		/* line parsed with fparseln needs to be freed */
		free(var->tag);
		free(var);
	}
}

/* Free 32-bit file number generation structures. */
void
msdosfs_fileno_free(struct mount *mp)
{
	struct msdosfsmount *pmp = VFSTOMSDOSFS(mp);
	struct msdosfs_fileno *mf, *next;

	for (mf = RB_MIN(msdosfs_filenotree, &pmp->pm_filenos); mf != NULL;
	    mf = next) {
		next = RB_NEXT(msdosfs_filenotree, &pmp->pm_filenos, mf);
		RB_REMOVE(msdosfs_filenotree, &pmp->pm_filenos, mf);
		free(mf, M_MSDOSFSFILENO);
	}
}

void
ct_extract_free_entry(struct ct_pending_files *head,
    struct ct_pending_file *file)
{
	struct fnode	*fnode;

	RB_REMOVE(ct_pending_files, head, file);
	while ((fnode = TAILQ_FIRST(&file->cpf_links)) != NULL) {
		TAILQ_REMOVE(&file->cpf_links, fnode, fn_list);
		ct_free_fnode(fnode);
	}
	e_free(&file->cpf_name);
	e_free(&file);
}

void Remove_Node(struct FlowNode *node) {

#ifdef DEVEL
	if ( NumFlows == 0 ) {
		LogError("Remove_Node() Fatal Tried to remove a Node from empty tree");
		return;
	}
#endif

	RB_REMOVE(FlowTree, FlowTree, node);
	Free_Node(node);
	NumFlows--;

} // End of Lookup_FlowTree

/* Must hold the kqtree_mtx when calling this */
static void
kqueue_free(struct kqueue *kq)
{
    RB_REMOVE(kqt, &kqtree, kq);
    filter_unregister_all(kq);
#if defined(__sun__)
    port_event_t *pe = (port_event_t *) pthread_getspecific(kq->kq_port_event);

    if (kq->kq_port > 0) 
        close(kq->kq_port);
    free(pe);
#endif
    free(kq);
}

void
options_remove(struct options *oo, const char *name)
{
	struct options_entry	*o;

	if ((o = options_find1(oo, name)) == NULL)
		return;

	RB_REMOVE(options_tree, &oo->tree, o);
	free(o->name);
	if (o->type == OPTIONS_STRING)
		free(o->str);
	free(o);
}

void
expand_free(struct expand *expand)
{
	struct expandnode *xn;

	if (expand->queue)
		while ((xn = TAILQ_FIRST(expand->queue)))
			TAILQ_REMOVE(expand->queue, xn, tq_entry);

	while ((xn = RB_ROOT(&expand->tree)) != NULL) {
		RB_REMOVE(expandtree, &expand->tree, xn);
		free(xn);
	}
}