rc_request_t *this;
int force_af = AF_UNSPEC;
TALLOC_CTX *autofree;
- rbtree_t *filename_tree = NULL;
+ fr_rb_tree_t *filename_tree = NULL;
/*
* It's easier having two sets of flags to set the
talloc_set_log_stderr();
- filename_tree = rbtree_talloc_alloc(NULL, rc_file_pair_t, node, filename_cmp, NULL, 0);
+ filename_tree = fr_rb_tree_talloc_alloc(NULL, rc_file_pair_t, node, filename_cmp, NULL, 0);
if (!filename_tree) {
oom:
ERROR("Out of memory");
files->packets = optarg;
files->filters = NULL;
}
- rbtree_insert(filename_tree, (void *) files);
+ fr_rb_insert(filename_tree, (void *) files);
}
break;
/*
* If no '-f' is specified, we're reading from stdin.
*/
- if (rbtree_num_elements(filename_tree) == 0) {
+ if (fr_rb_num_elements(filename_tree) == 0) {
rc_file_pair_t *files;
files = talloc_zero(talloc_autofree_context(), rc_file_pair_t);
* Walk over the list of filenames, creating the requests.
*/
{
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
rc_file_pair_t *files;
- for (files = rbtree_iter_init_inorder(&iter, filename_tree);
+ for (files = fr_rb_iter_init_inorder(&iter, filename_tree);
files;
- files = rbtree_iter_next_inorder(&iter)) {
+ files = fr_rb_iter_next_inorder(&iter)) {
if (radclient_init(files, files)) {
ERROR("Failed parsing input files");
fr_exit_now(1);
static struct timeval start_pcap = {0, 0};
static char timestr[50];
-static rbtree_t *request_tree = NULL;
-static rbtree_t *link_tree = NULL;
+static fr_rb_tree_t *request_tree = NULL;
+static fr_rb_tree_t *link_tree = NULL;
static fr_event_list_t *events;
static bool cleanup;
* something has gone very badly wrong.
*/
if (request->in_request_tree) {
- ret = rbtree_delete(request_tree, request);
+ ret = fr_rb_delete(request_tree, request);
RS_ASSERT(ret);
}
if (request->in_link_tree) {
- ret = rbtree_delete(link_tree, request);
+ ret = fr_rb_delete(link_tree, request);
RS_ASSERT(ret);
}
{
/* look for a matching request and use it for decoding */
search.expect = packet;
- original = rbtree_find(request_tree, &search);
+ original = fr_rb_find(request_tree, &search);
/*
* Verify this code is allowed
if (!fr_pair_list_empty(&search.link_vps)) {
rs_request_t *tuple;
- original = rbtree_find(link_tree, &search);
- tuple = rbtree_find(request_tree, &search);
+ original = fr_rb_find(link_tree, &search);
+ tuple = fr_rb_find(request_tree, &search);
/*
* If the packet we matched using attributes is not the same
* Detect duplicates using the normal 5-tuple of src/dst ips/ports id
*/
} else {
- original = rbtree_find(request_tree, &search);
+ original = fr_rb_find(request_tree, &search);
if (original && (memcmp(original->expect->vector, packet->vector,
sizeof(original->expect->vector)) != 0)) {
/*
/* Request may need to be reinserted as the 5 tuple of the response may of changed */
if (rs_packet_cmp(original, &search) != 0) {
- rbtree_delete(request_tree, original);
+ fr_rb_delete(request_tree, original);
}
/* replace expected packets and vps */
fr_pair_list_move(&original->link_vps, &search.link_vps);
/* We should never have conflicts */
- ret = rbtree_insert(link_tree, original);
+ ret = fr_rb_insert(link_tree, original);
RS_ASSERT(ret);
original->in_link_tree = true;
}
bool ret;
/* We should never have conflicts */
- ret = rbtree_insert(request_tree, original);
+ ret = fr_rb_insert(request_tree, original);
RS_ASSERT(ret);
original->in_request_tree = true;
}
usage(64);
}
- link_tree = rbtree_talloc_alloc(conf, rs_request_t, link_node, rs_rtx_cmp, _unmark_link, 0);
+ link_tree = fr_rb_tree_talloc_alloc(conf, rs_request_t, link_node, rs_rtx_cmp, _unmark_link, 0);
if (!link_tree) {
ERROR("Failed creating RTX tree");
goto finish;
/*
* Setup the request tree
*/
- request_tree = rbtree_talloc_alloc(conf, rs_request_t, request_node, rs_packet_cmp, _unmark_request, 0);
+ request_tree = fr_rb_tree_talloc_alloc(conf, rs_request_t, request_node, rs_packet_cmp, _unmark_request, 0);
if (!request_tree) {
ERROR("Failed creating request tree");
goto finish;
fr_io_instance_t const *inst; //!< parent instance for master IO handler
fr_io_thread_t *thread;
fr_event_timer_t const *ev; //!< when we clean up the client
- rbtree_t *table; //!< tracking table for packets
+ fr_rb_tree_t *table; //!< tracking table for packets
fr_heap_t *pending; //!< pending packets for this client
fr_hash_table_t *addresses; //!< list of src/dst addresses used by this client
static int track_dedup_free(fr_io_track_t *track)
{
fr_assert(track->client->table != NULL);
- fr_assert(rbtree_find(track->client->table, track) != NULL);
+ fr_assert(fr_rb_find(track->client->table, track) != NULL);
- if (!rbtree_delete(track->client->table, track)) {
+ if (!fr_rb_delete(track->client->table, track)) {
fr_assert(0);
}
* #todo - unify the code with static clients?
*/
if (inst->app_io->track_duplicates) {
- MEM(connection->client->table = rbtree_talloc_alloc(client, fr_io_track_t, node,
- track_connected_cmp, NULL, RBTREE_FLAG_NONE));
+ MEM(connection->client->table = fr_rb_tree_talloc_alloc(client, fr_io_track_t, node,
+ track_connected_cmp, NULL, RB_FLAG_NONE));
}
/*
/*
* No existing duplicate. Return the new tracking entry.
*/
- old = rbtree_find(client->table, track);
+ old = fr_rb_find(client->table, track);
if (!old) goto do_insert;
fr_assert(old->client == client);
} else {
fr_assert(client == old->client);
- if (!rbtree_delete(client->table, old)) {
+ if (!fr_rb_delete(client->table, old)) {
fr_assert(0);
}
if (old->ev) (void) fr_event_timer_delete(&old->ev);
}
do_insert:
- if (!rbtree_insert(client->table, track)) {
+ if (!fr_rb_insert(client->table, track)) {
fr_assert(0);
}
*/
if (inst->app_io->track_duplicates) {
fr_assert(inst->app_io->compare != NULL);
- MEM(client->table = rbtree_talloc_alloc(client, fr_io_track_t, node, track_cmp,
- NULL, RBTREE_FLAG_NONE));
+ MEM(client->table = fr_rb_tree_talloc_alloc(client, fr_io_track_t, node, track_cmp,
+ NULL, RB_FLAG_NONE));
}
/*
#include <freeradius-devel/util/event.h>
#include <freeradius-devel/util/misc.h>
#include <freeradius-devel/util/rand.h>
-#include <freeradius-devel/util/rbtree.h>
+#include <freeradius-devel/util/rb.h>
#include <freeradius-devel/util/syserror.h>
#include <freeradius-devel/util/atexit.h>
#include <freeradius-devel/util/talloc.h>
fr_io_stats_t stats;
- rbtree_t *sockets; //!< list of sockets we're managing, ordered by the listener
- rbtree_t *sockets_by_num; //!< ordered by number;
+ fr_rb_tree_t *sockets; //!< list of sockets we're managing, ordered by the listener
+ fr_rb_tree_t *sockets_by_num; //!< ordered by number;
int num_workers; //!< number of active workers
int num_blocked; //!< number of blocked workers
{
fr_network_socket_t *s;
- s = rbtree_find(nr->sockets, &(fr_network_socket_t){ .listen = li });
+ s = fr_rb_find(nr->sockets, &(fr_network_socket_t){ .listen = li });
if (!s) return -1;
fr_network_socket_dead(nr, s);
(void) talloc_get_type_abort(nr, fr_network_t);
(void) talloc_get_type_abort_const(li, fr_listen_t);
- s = rbtree_find(nr->sockets, &(fr_network_socket_t){ .listen = li });
+ s = fr_rb_find(nr->sockets, &(fr_network_socket_t){ .listen = li });
if (!s) return;
/*
FR_EVENT_SUSPEND(fr_event_io_func_t, read),
{ 0 }
};
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
fr_network_socket_t *socket;
if (nr->suspended) return;
- for (socket = rbtree_iter_init_inorder(&iter, nr->sockets);
+ for (socket = fr_rb_iter_init_inorder(&iter, nr->sockets);
socket;
- socket = rbtree_iter_next_inorder(&iter)) {
+ socket = fr_rb_iter_next_inorder(&iter)) {
fr_event_filter_update(socket->nr->el, socket->listen->fd, FR_EVENT_FILTER_IO, pause_read);
}
nr->suspended = true;
FR_EVENT_RESUME(fr_event_io_func_t, read),
{ 0 }
};
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
fr_network_socket_t *socket;
if (!nr->suspended) return;
- for (socket = rbtree_iter_init_inorder(&iter, nr->sockets);
+ for (socket = fr_rb_iter_init_inorder(&iter, nr->sockets);
socket;
- socket = rbtree_iter_next_inorder(&iter)) {
+ socket = fr_rb_iter_next_inorder(&iter)) {
fr_event_filter_update(socket->nr->el, socket->listen->fd, FR_EVENT_FILTER_IO, resume_read);
}
nr->suspended = false;
fr_network_t *nr = s->nr;
fr_channel_data_t *cd;
- rbtree_delete(nr->sockets, s);
- rbtree_delete(nr->sockets_by_num, s);
+ fr_rb_delete(nr->sockets, s);
+ fr_rb_delete(nr->sockets_by_num, s);
fr_event_fd_delete(nr->el, s->listen->fd, s->filter);
if (app_io->event_list_set) app_io->event_list_set(s->listen, nr->el, nr);
- (void) rbtree_insert(nr->sockets, s);
- (void) rbtree_insert(nr->sockets_by_num, s);
+ (void) fr_rb_insert(nr->sockets, s);
+ (void) fr_rb_insert(nr->sockets_by_num, s);
/*
* We use fr_log() here to avoid the "Network - " prefix.
return;
}
- (void) rbtree_insert(nr->sockets, s);
- (void) rbtree_insert(nr->sockets_by_num, s);
+ (void) fr_rb_insert(nr->sockets, s);
+ (void) fr_rb_insert(nr->sockets_by_num, s);
DEBUG3("Using new socket with FD %d", s->listen->fd);
}
fr_assert(data_size == sizeof(my_inject));
memcpy(&my_inject, data, data_size);
- s = rbtree_find(nr->sockets, &(fr_network_socket_t){ .listen = my_inject.listen });
+ s = fr_rb_find(nr->sockets, &(fr_network_socket_t){ .listen = my_inject.listen });
if (!s) {
talloc_free(my_inject.packet); /* MUST be it's own TALLOC_CTX */
return;
* @todo - cache this somewhere so we don't need
* to do an rbtree lookup for every packet.
*/
- s = rbtree_find(nr->sockets, &(fr_network_socket_t){ .listen = li });
+ s = fr_rb_find(nr->sockets, &(fr_network_socket_t){ .listen = li });
/*
* This shouldn't happen, but be safe...
size_t len;
size_t i;
- if (rbtree_flatten_inorder(nr, (void ***)&sockets, nr->sockets) < 0) return -1;
+ if (fr_rb_flatten_inorder(nr, (void ***)&sockets, nr->sockets) < 0) return -1;
len = talloc_array_length(sockets);
for (i = 0; i < len; i++) talloc_free(sockets[i]);
fr_network_t *nr;
#ifndef NDEBUG
- int rbflags = RBTREE_FLAG_LOCK; /* Produces deadlocks when iterators conflict with other operations */
+ int rbflags = RB_FLAG_LOCK; /* Produces deadlocks when iterators conflict with other operations */
#else
- int rbflags = RBTREE_FLAG_NONE;
+ int rbflags = RB_FLAG_NONE;
#endif
nr = talloc_zero(ctx, fr_network_t);
/*
* Create the various heaps.
*/
- nr->sockets = rbtree_talloc_alloc(nr, fr_network_socket_t, listen_node, socket_listen_cmp, NULL, rbflags);
+ nr->sockets = fr_rb_tree_talloc_alloc(nr, fr_network_socket_t, listen_node, socket_listen_cmp, NULL, rbflags);
if (!nr->sockets) {
fr_strerror_const_push("Failed creating listen tree for sockets");
goto fail2;
}
- nr->sockets_by_num = rbtree_talloc_alloc(nr, fr_network_socket_t, num_node, socket_num_cmp, NULL, rbflags);
+ nr->sockets_by_num = fr_rb_tree_talloc_alloc(nr, fr_network_socket_t, num_node, socket_num_cmp, NULL, rbflags);
if (!nr->sockets_by_num) {
fr_strerror_const_push("Failed creating number tree for sockets");
goto fail2;
fprintf(fp, "count.out\t%" PRIu64 "\n", nr->stats.out);
fprintf(fp, "count.dup\t%" PRIu64 "\n", nr->stats.dup);
fprintf(fp, "count.dropped\t%" PRIu64 "\n", nr->stats.dropped);
- fprintf(fp, "count.sockets\t%"PRIu64"\n", rbtree_num_elements(nr->sockets));
+ fprintf(fp, "count.sockets\t%"PRIu64"\n", fr_rb_num_elements(nr->sockets));
return 0;
}
static int cmd_socket_list(FILE *fp, UNUSED FILE *fp_err, void *ctx, UNUSED fr_cmd_info_t const *info)
{
fr_network_t const *nr = ctx;
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
fr_network_socket_t *socket;
// @todo - note that this isn't thread-safe!
- for (socket = rbtree_iter_init_inorder(&iter, nr->sockets);
+ for (socket = fr_rb_iter_init_inorder(&iter, nr->sockets);
socket;
- socket = rbtree_iter_next_inorder(&iter)) {
+ socket = fr_rb_iter_next_inorder(&iter)) {
if (!socket->listen->app_io->get_name) {
fprintf(fp, "%s\n", socket->listen->app_io->name);
} else {
fr_network_t const *nr = ctx;
fr_network_socket_t *s;
- s = rbtree_find(nr->sockets_by_num, &(fr_network_socket_t){ .number = info->box[0]->vb_uint32 });
+ s = fr_rb_find(nr->sockets_by_num, &(fr_network_socket_t){ .number = info->box[0]->vb_uint32 });
if (!s) {
fprintf(fp_err, "No such socket number '%s'.\n", info->argv[0]);
return -1;
#include <freeradius-devel/io/schedule.h>
#include <freeradius-devel/util/dlist.h>
-#include <freeradius-devel/util/rbtree.h>
+#include <freeradius-devel/util/rb.h>
#include <freeradius-devel/util/syserror.h>
#include <freeradius-devel/server/trigger.h>
fr_heap_t *runnable; //!< current runnable requests which we've spent time processing
fr_heap_t *time_order; //!< time ordered heap of requests
- rbtree_t *dedup; //!< de-dup tree
+ fr_rb_tree_t *dedup; //!< de-dup tree
fr_io_stats_t stats; //!< input / output stats
fr_time_elapsed_t cpu_time; //!< histogram of total CPU time per request
if (request->async->listen->track_duplicates) {
request_t *old;
- old = rbtree_find(worker->dedup, request);
+ old = fr_rb_find(worker->dedup, request);
if (!old) {
/*
* Ignore duplicate packets where we've
worker->stats.dropped++;
insert_new:
- (void) rbtree_insert(worker->dedup, request);
+ (void) fr_rb_insert(worker->dedup, request);
}
worker_request_time_tracking_start(worker, request, now);
* then, only some of the time.
*/
if (request->async->listen->track_duplicates) {
- (void) rbtree_delete(worker->dedup, request);
+ (void) fr_rb_delete(worker->dedup, request);
}
/*
fr_worker_t *worker;
#ifndef NDEBUG
- int rbflags = RBTREE_FLAG_LOCK; /* Produces deadlocks when iterators conflict with other operations */
+ int rbflags = RB_FLAG_LOCK; /* Produces deadlocks when iterators conflict with other operations */
#else
- int rbflags = RBTREE_FLAG_NONE;
+ int rbflags = RB_FLAG_NONE;
#endif
worker = talloc_zero(ctx, fr_worker_t);
goto fail;
}
- worker->dedup = rbtree_talloc_alloc(worker, request_t, dedup_node, worker_dedup_cmp, NULL, rbflags);
+ worker->dedup = fr_rb_tree_talloc_alloc(worker, request_t, dedup_node, worker_dedup_cmp, NULL, rbflags);
if (!worker->dedup) {
fr_strerror_const("Failed creating de_dup tree");
goto fail;
(void) talloc_get_type_abort(worker->runnable, fr_heap_t);
fr_assert(worker->dedup != NULL);
- (void) talloc_get_type_abort(worker->dedup, rbtree_t);
+ (void) talloc_get_type_abort(worker->dedup, fr_rb_tree_t);
for (i = 0; i < worker->config.max_channels; i++) {
if (!worker->channel[i]) continue;
* - An array of #fr_redis_cluster_node_t. These are pre-allocated on startup and are
* never added to, or removed from.
* - An #fr_fifo_t. This contains the queue of nodes that may be re-used.
- * - An #rbtree_t. This contains a tree of nodes which are active. The tree is built on IP
+ * - An #fr_rb_tree_t. This contains a tree of nodes which are active. The tree is built on IP
* address and port.
*
* Each #fr_redis_cluster_node_t contains a master ID, and an array of slave IDs. The IDs are array
* 2. Validating the result of this command. We need to do extensive validation to
* avoid SEGV on invalid data, due to the way libhiredis presents the result.
* 3. Determining the intersection between nodes described in the result, and those already
- * in our #rbtree_t.
+ * in our #fr_rb_tree_t.
* 4. Connecting to nodes that were in the result, but not in the tree.
* Note: If we can't connect to any of the masters, we count the map as invalid, roll
* back any newly connected nodes, and error out. Slave failure is OK.
//!< a pool of its connections.
fr_fifo_t *free_nodes; //!< Queue of free nodes (or nodes waiting to be reused).
- rbtree_t *used_nodes; //!< Tree of used nodes.
+ fr_rb_tree_t *used_nodes; //!< Tree of used nodes.
fr_redis_cluster_key_slot_t key_slot[KEY_SLOTS]; //!< Lookup table of slots to pools.
fr_redis_cluster_key_slot_t key_slot_pending[KEY_SLOTS]; //!< Pending key slot table.
do { \
(_node)->is_active = false; \
(_node)->is_master = false; \
- rbtree_delete(cluster->used_nodes, _node); \
+ fr_rb_delete(cluster->used_nodes, _node); \
fr_fifo_push(cluster->free_nodes, _node); \
} while (0)
#define SET_ACTIVE(_node) \
do { \
(_node)->is_active = true; \
- rbtree_insert(cluster->used_nodes, _node); \
+ fr_rb_insert(cluster->used_nodes, _node); \
fr_fifo_pop(cluster->free_nodes); \
active[(_node)->id] = true; \
rollback[r++] = (_node)->id; \
memset(&tmpl_slot, 0, sizeof(tmpl_slot));
SET_ADDR(find.addr, map->element[2]);
- found = rbtree_find(cluster->used_nodes, &find);
+ found = fr_rb_find(cluster->used_nodes, &find);
if (found) {
active[found->id] = true;
goto reuse_master_node;
*/
for (j = 3; (j < map->elements); j++) {
SET_ADDR(find.addr, map->element[j]);
- found = rbtree_find(cluster->used_nodes, &find);
+ found = fr_rb_find(cluster->used_nodes, &find);
if (found) {
active[found->id] = true;
goto next;
if (cluster->node[i].is_active) {
/* Sanity check for duplicates that are active */
- found = rbtree_find(cluster->used_nodes, &cluster->node[i]);
+ found = fr_rb_find(cluster->used_nodes, &cluster->node[i]);
fr_assert(found);
fr_assert(found->is_active);
fr_assert(found->id == i);
/*
* Sanity checks
*/
- fr_assert(((talloc_array_length(cluster->node) - 1) - rbtree_num_elements(cluster->used_nodes)) ==
+ fr_assert(((talloc_array_length(cluster->node) - 1) - fr_rb_num_elements(cluster->used_nodes)) ==
fr_fifo_num_elements(cluster->free_nodes));
return FR_REDIS_CLUSTER_RCODE_SUCCESS;
* If we have already have a pool for the
* host we were redirected to, use that.
*/
- found = rbtree_find(cluster->used_nodes, &find);
+ found = fr_rb_find(cluster->used_nodes, &find);
if (found) {
/* We have the new pool, don't need to hold the lock */
pthread_mutex_unlock(&cluster->mutex);
pthread_mutex_unlock(&cluster->mutex);
return FR_REDIS_CLUSTER_RCODE_NO_CONNECTION;
}
- rbtree_insert(cluster->used_nodes, spare);
+ fr_rb_insert(cluster->used_nodes, spare);
fr_fifo_pop(cluster->free_nodes);
found = spare;
cluster_nodes_live_t *live;
fr_time_t now;
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
fr_redis_cluster_node_t *node;
ROPTIONAL(RDEBUG2, DEBUG2, "Searching for live cluster nodes");
- if (rbtree_num_elements(cluster->used_nodes) == 1) {
+ if (fr_rb_num_elements(cluster->used_nodes) == 1) {
no_alts:
ROPTIONAL(RERROR, ERROR, "No alternative nodes available");
return -1;
live->skip = skip->id;
pthread_mutex_lock(&cluster->mutex);
- for (node = rbtree_iter_init_inorder(&iter, cluster->used_nodes);
+ for (node = fr_rb_iter_init_inorder(&iter, cluster->used_nodes);
node;
- node = rbtree_iter_next_inorder(&iter)) {
+ node = fr_rb_iter_next_inorder(&iter)) {
fr_assert(node->pool);
if (live->skip == node->id) continue; /* Skip dead nodes */
* Avoid CRC16 if we're operating with one cluster node or
* without clustering.
*/
- if (rbtree_num_elements(cluster->used_nodes) > 1) {
+ if (fr_rb_num_elements(cluster->used_nodes) > 1) {
key_slot = &cluster->key_slot[cluster_key_hash(key, key_len)];
ROPTIONAL(RDEBUG2, DEBUG2, "Key \"%pV\" -> slot %zu",
fr_box_strvalue_len((char const *)key, key_len), key_slot - cluster->key_slot);
memset(state, 0, sizeof(*state));
*conn = NULL; /* Better safe than exploding */
- used_nodes = rbtree_num_elements(cluster->used_nodes);
+ used_nodes = fr_rb_num_elements(cluster->used_nodes);
if (used_nodes == 0) {
ROPTIONAL(REDEBUG, ERROR, "No nodes in cluster");
return REDIS_RCODE_RECONNECT;
find.addr.inet.dst_port = node_addr->inet.dst_port;
pthread_mutex_lock(&cluster->mutex);
- found = rbtree_find(cluster->used_nodes, &find);
+ found = fr_rb_find(cluster->used_nodes, &find);
if (!found) {
fr_redis_cluster_node_t *spare;
char buffer[INET6_ADDRSTRLEN];
pthread_mutex_unlock(&cluster->mutex);
return -1;
}
- rbtree_insert(cluster->used_nodes, spare);
+ fr_rb_insert(cluster->used_nodes, spare);
fr_fifo_pop(cluster->free_nodes);
found = spare;
}
/*
* Sanity checks
*/
- fr_assert(((talloc_array_length(cluster->node) - 1) - rbtree_num_elements(cluster->used_nodes)) ==
+ fr_assert(((talloc_array_length(cluster->node) - 1) - fr_rb_num_elements(cluster->used_nodes)) ==
fr_fifo_num_elements(cluster->free_nodes));
pthread_mutex_unlock(&cluster->mutex);
ssize_t fr_redis_cluster_node_addr_by_role(TALLOC_CTX *ctx, fr_socket_t *out[],
fr_redis_cluster_t *cluster, bool is_master, bool is_slave)
{
- uint64_t in_use = rbtree_num_elements(cluster->used_nodes);
- fr_rb_tree_iter_inorder_t iter;
+ uint64_t in_use = fr_rb_num_elements(cluster->used_nodes);
+ fr_rb_iter_inorder_t iter;
fr_redis_cluster_node_t *node;
uint8_t count;
fr_socket_t *found;
pthread_mutex_lock(&cluster->mutex);
- for (node = rbtree_iter_init_inorder(&iter, cluster->used_nodes);
+ for (node = fr_rb_iter_init_inorder(&iter, cluster->used_nodes);
node;
- node = rbtree_iter_next_inorder(&iter)) {
+ node = fr_rb_iter_next_inorder(&iter)) {
if ((is_master && node->is_master) || (is_slave && !node->is_master)) found[count++] = node->addr;
}
bool fr_redis_cluster_min_version(fr_redis_cluster_t *cluster, char const *min_version)
{
fr_redis_cluster_node_t *node;
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
fr_redis_conn_t *conn;
int ret;
char buffer[40];
pthread_mutex_lock(&cluster->mutex);
- for (node = rbtree_iter_init_inorder(&iter, cluster->used_nodes);
+ for (node = fr_rb_iter_init_inorder(&iter, cluster->used_nodes);
node;
- node = rbtree_iter_next_inorder(&iter)) {
+ node = fr_rb_iter_next_inorder(&iter)) {
conn = fr_pool_connection_get(node->pool, NULL);
if (!conn) continue;
fr_strerror_printf("Redis node %s:%i (currently v%s) needs update to >= v%s",
node->name, node->addr.inet.dst_port, buffer, min_version);
all_above = false;
- rbtree_iter_done(&iter);
+ fr_rb_iter_done(&iter);
break;
}
}
cluster->node = talloc_zero_array(cluster, fr_redis_cluster_node_t, conf->max_nodes + 1);
if (!cluster->node) goto oom;
- cluster->used_nodes = rbtree_alloc(cluster, fr_redis_cluster_node_t, rbnode, _cluster_node_cmp, NULL, 0);
+ cluster->used_nodes = fr_rb_alloc(cluster, fr_redis_cluster_node_t, rbnode, _cluster_node_cmp, NULL, 0);
if (!cluster->used_nodes) goto oom;
cluster->free_nodes = fr_fifo_create(cluster, conf->max_nodes, NULL);
continue;
}
- if (!rbtree_insert(cluster->used_nodes, node)) {
+ if (!fr_rb_insert(cluster->used_nodes, node)) {
WARN("%s - Skipping duplicate bootstrap server \"%s\"", cluster->log_prefix, server);
continue;
}
/*
* Catch pool.start != 0
*/
- num_nodes = rbtree_num_elements(cluster->used_nodes);
+ num_nodes = fr_rb_num_elements(cluster->used_nodes);
if (!num_nodes) {
ERROR("%s - Can't contact any bootstrap servers", cluster->log_prefix);
goto error;
{
cf_file_t *file;
CONF_SECTION *top;
- rbtree_t *tree;
+ fr_rb_tree_t *tree;
int fd;
FILE *fp;
top = cf_root(cs);
- tree = cf_data_value(cf_data_find(top, rbtree_t, "filename"));
+ tree = cf_data_value(cf_data_find(top, fr_rb_tree_t, "filename"));
fr_assert(tree);
/*
if (stat(filename, &my_file.buf) < 0) goto error;
- file = rbtree_find(tree, &my_file);
+ file = fr_rb_find(tree, &my_file);
/*
* The file was previously read by including it
*
* Though the admin should really use templates for that.
*/
- if (!rbtree_insert(tree, file)) talloc_free(file);
+ if (!fr_rb_insert(tree, file)) talloc_free(file);
*fp_p = fp;
return 0;
{
cf_file_t *file;
CONF_SECTION *top;
- rbtree_t *tree;
+ fr_rb_tree_t *tree;
int fd = -1;
top = cf_root(cs);
- tree = cf_data_value(cf_data_find(top, rbtree_t, "filename"));
+ tree = cf_data_value(cf_data_find(top, fr_rb_tree_t, "filename"));
if (!tree) return false;
file = talloc(tree, cf_file_t);
/*
* It's OK to include the same file twice...
*/
- if (!rbtree_insert(tree, file)) talloc_free(file);
+ if (!fr_rb_insert(tree, file)) talloc_free(file);
return true;
}
int i;
char *p;
CONF_PAIR *cp;
- rbtree_t *tree;
+ fr_rb_tree_t *tree;
cf_stack_t stack;
cf_stack_frame_t *frame;
p = strrchr(cp->value, FR_DIR_SEP);
if (p) *p = '\0';
- MEM(tree = rbtree_talloc_alloc(cs, cf_file_t, node, _inode_cmp, NULL, 0));
+ MEM(tree = fr_rb_tree_talloc_alloc(cs, cf_file_t, node, _inode_cmp, NULL, 0));
cf_data_add(cs, tree, "filename", false);
#include <freeradius-devel/server/cf_util.h>
-#include <freeradius-devel/util/rbtree.h>
+#include <freeradius-devel/util/rb.h>
#include <freeradius-devel/util/syserror.h>
#include <freeradius-devel/util/table.h>
#include <freeradius-devel/util/print.h>
#include <unistd.h>
#include <sys/time.h>
#include <freeradius-devel/util/table.h>
-#include <freeradius-devel/util/rbtree.h>
+#include <freeradius-devel/util/rb.h>
#include <freeradius-devel/server/cf_util.h>
#ifdef __cplusplus
#include <sys/stat.h>
#include <freeradius-devel/server/cf_parse.h>
-#include <freeradius-devel/util/rbtree.h>
+#include <freeradius-devel/util/rb.h>
#include <freeradius-devel/util/dlist.h>
typedef enum conf_type {
fr_dlist_head_t children; //!< The head of the ordered list of children.
- rbtree_t *ident1; //!< Tree to store the first identifier (name1 || type || attr).
- rbtree_t *ident2; //!< Tree to store the second identifier (name2 || name).
+ fr_rb_tree_t *ident1; //!< Tree to store the first identifier (name1 || type || attr).
+ fr_rb_tree_t *ident2; //!< Tree to store the second identifier (name2 || name).
int lineno; //!< The line number the config item began on.
char const *filename; //!< The file the config item was parsed from.
/*
* No ident2, use the ident1 tree.
*/
- if (IS_WILDCARD(ident2)) return rbtree_find(parent->ident1, find);
+ if (IS_WILDCARD(ident2)) return fr_rb_find(parent->ident1, find);
/*
* Both ident1 and ident2 use the ident2 tree.
*/
- return rbtree_find(parent->ident2, find);
+ return fr_rb_find(parent->ident2, find);
}
/** Return the next child that's of the specified type with the specified identifiers
/*
* New child, add child trees.
*/
- if (!parent->ident1) parent->ident1 = rbtree_alloc(parent, CONF_ITEM, ident1_node,
- _cf_ident1_cmp, NULL, RBTREE_FLAG_NONE);
- if (!parent->ident2) parent->ident2 = rbtree_alloc(parent, CONF_ITEM, ident2_node,
- _cf_ident2_cmp, NULL, RBTREE_FLAG_NONE);
+ if (!parent->ident1) parent->ident1 = fr_rb_alloc(parent, CONF_ITEM, ident1_node,
+ _cf_ident1_cmp, NULL, RB_FLAG_NONE);
+ if (!parent->ident2) parent->ident2 = fr_rb_alloc(parent, CONF_ITEM, ident2_node,
+ _cf_ident2_cmp, NULL, RB_FLAG_NONE);
- rbtree_insert(parent->ident1, child);
- rbtree_insert(parent->ident2, child); /* NULL ident2 is still a value */
+ fr_rb_insert(parent->ident1, child);
+ fr_rb_insert(parent->ident2, child); /* NULL ident2 is still a value */
fr_dlist_insert_tail(&parent->children, child); /* Append to the list of children */
}
fr_dlist_remove(&parent->children, found);
if (!fr_cond_assert(found == child)) return NULL;
- in_ident1 = (rbtree_find(parent->ident1, child) == child);
- if (in_ident1 && (!rbtree_delete(parent->ident1, child))) {
+ in_ident1 = (fr_rb_find(parent->ident1, child) == child);
+ if (in_ident1 && (!fr_rb_delete(parent->ident1, child))) {
fr_assert(0);
return NULL;
}
- in_ident2 = (rbtree_find(parent->ident2, child) == child);
- if (in_ident2 && (!rbtree_delete(parent->ident2, child))) {
+ in_ident2 = (fr_rb_find(parent->ident2, child) == child);
+ if (in_ident2 && (!fr_rb_delete(parent->ident2, child))) {
fr_assert(0);
return NULL;
}
found && (in_ident1 || in_ident2);
found = fr_dlist_next(&parent->children, found)) {
if (in_ident1 && (_cf_ident1_cmp(found, child) == 0)) {
- rbtree_insert(parent->ident1, child);
+ fr_rb_insert(parent->ident1, child);
in_ident1 = false;
}
if (in_ident2 && (_cf_ident2_cmp(found, child) == 0)) {
- rbtree_insert(parent->ident2, child);
+ fr_rb_insert(parent->ident2, child);
in_ident2 = false;
}
}
int _cf_data_walk(CONF_ITEM *ci, char const *type, cf_walker_t cb, void *ctx)
{
CONF_DATA *cd;
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
int ret = 0;
if (!ci->ident2) return 0;
- for (ci = rbtree_iter_init_inorder(&iter, ci->ident2);
+ for (ci = fr_rb_iter_init_inorder(&iter, ci->ident2);
ci;
- ci = rbtree_iter_next_inorder(&iter)) {
+ ci = fr_rb_iter_next_inorder(&iter)) {
/*
* We're walking ident2, not all of the items will be data
*/
ret = cb(UNCONST(void *, cd->data), ctx);
if (ret) {
- rbtree_iter_done(&iter);
+ fr_rb_iter_done(&iter);
break;
}
}
DEBUG(" next : %p", fr_dlist_next(&ci->parent->children, ci));
DEBUG(" parent : %p", ci->parent);
DEBUG(" children : %s", !fr_dlist_empty(&ci->children) ? "yes" : "no");
- DEBUG(" ident1 tree : %p (%" PRIu64 "entries)", ci->ident1, ci->ident1 ? rbtree_num_elements(ci->ident1) : 0);
- DEBUG(" ident2 tree : %p (%" PRIu64 "entries)", ci->ident2, ci->ident2 ? rbtree_num_elements(ci->ident2) : 0);
+ DEBUG(" ident1 tree : %p (%" PRIu64 "entries)", ci->ident1, ci->ident1 ? fr_rb_num_elements(ci->ident1) : 0);
+ DEBUG(" ident2 tree : %p (%" PRIu64 "entries)", ci->ident2, ci->ident2 ? fr_rb_num_elements(ci->ident2) : 0);
if (fr_dlist_empty(&ci->children)) return;
while ((child = fr_dlist_next(&ci->children, child))) {
char const *in_ident1, *in_ident2;
- in_ident1 = rbtree_find(ci->ident1, child) == child? "in ident1 " : "";
- in_ident2 = rbtree_find(ci->ident2, child) == child? "in ident2 " : "";
+ in_ident1 = fr_rb_find(ci->ident1, child) == child? "in ident1 " : "";
+ in_ident2 = fr_rb_find(ci->ident2, child) == child? "in ident2 " : "";
switch (child->type) {
case CONF_ITEM_SECTION:
#include <unistd.h>
#include <sys/time.h>
-#include <freeradius-devel/util/rbtree.h>
+#include <freeradius-devel/util/rb.h>
#include <freeradius-devel/util/table.h>
#include <freeradius-devel/util/token.h>
#include <freeradius-devel/util/log.h>
fr_trie_t *v4_tcp;
fr_trie_t *v6_tcp;
#else
- rbtree_t *tree[129];
+ fr_rb_tree_t *tree[129];
#endif
};
#else /* WITH_TRIE */
if (!clients->tree[client->ipaddr.prefix]) {
- clients->tree[client->ipaddr.prefix] = rbtree_talloc_alloc(clients, RADCLIENT, node, client_cmp,
- NULL, RBTREE_FLAG_NONE);
+ clients->tree[client->ipaddr.prefix] = fr_rb_tree_talloc_alloc(clients, RADCLIENT, node, client_cmp,
+ NULL, RB_FLAG_NONE);
if (!clients->tree[client->ipaddr.prefix]) {
return false;
}
}
- old = rbtree_find(clients->tree[client->ipaddr.prefix], client);
+ old = fr_rb_find(clients->tree[client->ipaddr.prefix], client);
#endif
if (old) {
/*
return false;
}
#else
- if (!rbtree_insert(clients->tree[client->ipaddr.prefix], client)) {
+ if (!fr_rb_insert(clients->tree[client->ipaddr.prefix], client)) {
client_free(client);
return false;
}
if (!clients->tree[client->ipaddr.prefix]) return;
- (void) rbtree_delete(clients->tree[client->ipaddr.prefix], client);
+ (void) fr_rb_delete(clients->tree[client->ipaddr.prefix], client);
#endif
}
my_client.ipaddr = *ipaddr;
fr_ipaddr_mask(&my_client.ipaddr, i);
- client = rbtree_find(clients->tree[i], &my_client);
+ client = fr_rb_find(clients->tree[i], &my_client);
if (client) {
return client;
}
* Provides space to store instance data.
*/
struct dl_module_loader_s {
- rbtree_t *module_tree;
- rbtree_t *inst_data_tree;
+ fr_rb_tree_t *module_tree;
+ fr_rb_tree_t *inst_data_tree;
dl_loader_t *dl_loader;
};
if (dl_inst_cache.data == data) return dl_inst_cache.inst;
- return rbtree_find(dl_module_loader->inst_data_tree, &(dl_module_inst_t){ .data = UNCONST(void *, data) });
+ return fr_rb_find(dl_module_loader->inst_data_tree, &(dl_module_inst_t){ .data = UNCONST(void *, data) });
}
/** Lookup instance name via instance data
* with the data.
*/
fr_assert(dl_module_loader != NULL);
- rbtree_insert(dl_module_loader->inst_data_tree, dl_inst); /* Duplicates not possible */
+ fr_rb_insert(dl_module_loader->inst_data_tree, dl_inst); /* Duplicates not possible */
talloc_set_destructor(data, _dl_module_instance_data_free);
}
}
if (dl_module->in_tree) {
- rbtree_delete(dl_module_loader->module_tree, dl_module);
+ fr_rb_delete(dl_module_loader->module_tree, dl_module);
dl_module->in_tree = false;
}
/*
* If the module's already been loaded, increment the reference count.
*/
- dl_module = rbtree_find(dl_module_loader->module_tree,
+ dl_module = fr_rb_find(dl_module_loader->module_tree,
&(dl_module_t){ .dl = &(dl_t){ .name = module_name }});
if (dl_module) {
talloc_free(module_name);
/*
* Add the module to the dl cache
*/
- dl_module->in_tree = rbtree_insert(dl_module_loader->module_tree, dl_module);
+ dl_module->in_tree = fr_rb_insert(dl_module_loader->module_tree, dl_module);
if (!dl_module->in_tree) {
cf_log_err(conf, "Failed caching module \"%s\"", module_name);
goto error;
* Remove this instance from the tracking tree.
*/
fr_assert(dl_module_loader != NULL);
- rbtree_delete(dl_module_loader->inst_data_tree, dl_inst);
+ fr_rb_delete(dl_module_loader->inst_data_tree, dl_inst);
/*
* Decrements the reference count. The module object
{
int ret = 0;
- if (rbtree_num_elements(dl_module_l->inst_data_tree) > 0) {
+ if (fr_rb_num_elements(dl_module_l->inst_data_tree) > 0) {
#ifndef NDEBUG
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
void *data;
WARN("Refusing to cleanup dl loader, the following module instances are still in use:");
- for (data = rbtree_iter_init_inorder(&iter, dl_module_l->inst_data_tree);
+ for (data = fr_rb_iter_init_inorder(&iter, dl_module_l->inst_data_tree);
data;
- data = rbtree_iter_next_inorder(&iter)) {
+ data = fr_rb_iter_next_inorder(&iter)) {
dl_module_inst_t *dl_inst = talloc_get_type_abort(data, dl_module_inst_t);
WARN(" %s (%s)", dl_inst->module->dl->name, dl_inst->name);
}
dl_search_path_prepend(dl_module_loader->dl_loader, lib_dir);
- dl_module_loader->inst_data_tree = rbtree_talloc_alloc(dl_module_loader,
+ dl_module_loader->inst_data_tree = fr_rb_tree_talloc_alloc(dl_module_loader,
dl_module_inst_t, node,
dl_module_inst_data_cmp, NULL, 0);
if (!dl_module_loader->inst_data_tree) {
goto error;
}
- dl_module_loader->module_tree = rbtree_talloc_alloc(dl_module_loader,
+ dl_module_loader->module_tree = fr_rb_tree_talloc_alloc(dl_module_loader,
dl_module_t, node,
dl_module_cmp, NULL, 0);
if (!dl_module_loader->inst_data_tree) {
#include <freeradius-devel/server/cf_parse.h>
#include <freeradius-devel/util/dl.h>
-#include <freeradius-devel/util/rbtree.h>
+#include <freeradius-devel/util/rb.h>
#include <freeradius-devel/util/version.h>
#ifdef __cplusplus
int count;
bool dual;
- rbtree_t *children;
+ fr_rb_tree_t *children;
rad_listen_t *parent;
bool nodup;
#include <freeradius-devel/server/map_proc_priv.h>
#include <freeradius-devel/util/debug.h>
-static rbtree_t *map_proc_root = NULL;
+static fr_rb_tree_t *map_proc_root = NULL;
/** Compare two map_proc_t structs, based ONLY on the name
*
strlcpy(find.name, proc->name, sizeof(find.name));
find.length = strlen(find.name);
- found = rbtree_find(map_proc_root, &find);
+ found = fr_rb_find(map_proc_root, &find);
if (!found) return 0;
- rbtree_delete(map_proc_root, found);
+ fr_rb_delete(map_proc_root, found);
return 0;
}
strlcpy(find.name, name, sizeof(find.name));
find.length = strlen(find.name);
- return rbtree_find(map_proc_root, &find);
+ return fr_rb_find(map_proc_root, &find);
}
/** Register a map processor
fr_assert(name && name[0]);
if (!map_proc_root) {
- map_proc_root = rbtree_talloc_alloc(NULL, map_proc_t, node,
- map_proc_cmp, _map_proc_tree_free, RBTREE_FLAG_REPLACE);
+ map_proc_root = fr_rb_tree_talloc_alloc(NULL, map_proc_t, node,
+ map_proc_cmp, _map_proc_tree_free, RB_FLAG_REPLACE);
if (!map_proc_root) {
DEBUG("map_proc: Failed to create tree");
return -1;
strlcpy(proc->name, name, sizeof(proc->name));
proc->length = strlen(proc->name);
- if (!rbtree_insert(map_proc_root, proc)) {
+ if (!fr_rb_insert(map_proc_root, proc)) {
talloc_free(proc);
return -1;
}
*/
void map_proc_free(void)
{
- rbtree_t *mpr = map_proc_root;
+ fr_rb_tree_t *mpr = map_proc_root;
map_proc_root = NULL;
talloc_free(mpr);
module_method_set_t *set;
MEM(set = talloc_zero(ctx, module_method_set_t));
- MEM(set->tree = rbtree_talloc_alloc(set, module_method_entry_t, node, module_method_cmp, NULL, 0));
+ MEM(set->tree = fr_rb_tree_talloc_alloc(set, module_method_entry_t, node, module_method_cmp, NULL, 0));
fr_dlist_talloc_init(&set->list, module_method_entry_t, entry);
return set;
{
module_method_entry_t *found, find = { .id = id, .method = method };
- found = rbtree_find(set->tree, &find);
+ found = fr_rb_find(set->tree, &find);
if (found) {
if (unlikely(found->method != method)) {
fr_strerror_printf("Conflict for method id %u (old %p vs new %p)",
MEM(found = talloc(set, module_method_entry_t));
*found = find;
- if (!rbtree_insert(set->tree, found)) {
+ if (!fr_rb_insert(set->tree, found)) {
fr_strerror_printf("Failed inserting method id %u", id);
return -1;
}
{
module_method_entry_t *found;
- found = rbtree_find(set->tree, &(module_method_entry_t){ .id = id });
+ found = fr_rb_find(set->tree, &(module_method_entry_t){ .id = id });
if (!found) return NULL;
return found->method;
RCSIDH(methods_h, "$Id$")
#include <freeradius-devel/server/module.h>
-#include <freeradius-devel/util/rbtree.h>
+#include <freeradius-devel/util/rb.h>
/** Unique identifier for an abstract method
*
*
*/
typedef struct {
- rbtree_t *tree; //!< Index of methods.
+ fr_rb_tree_t *tree; //!< Index of methods.
///< Helps with efficient lookups.
fr_dlist_head_t list; //!< Ordered list of methods.
/** Lookup module instances by name and lineage
*/
-static rbtree_t *module_instance_name_tree;
+static fr_rb_tree_t *module_instance_name_tree;
/** Lookup module by instance data
*/
-static rbtree_t *module_instance_data_tree;
+static fr_rb_tree_t *module_instance_data_tree;
/** Module command table
*/
static int module_name_tab_expand(UNUSED TALLOC_CTX *talloc_ctx, UNUSED void *uctx, fr_cmd_info_t *info, int max_expansions, char const **expansions)
{
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
void *instance;
char const *text;
int count;
text = info->argv[info->argc - 1];
count = 0;
- for (instance = rbtree_iter_init_inorder(&iter, module_instance_name_tree);
+ for (instance = fr_rb_iter_init_inorder(&iter, module_instance_name_tree);
instance;
- instance = rbtree_iter_next_inorder(&iter)) {
+ instance = fr_rb_iter_next_inorder(&iter)) {
module_instance_t *mi = talloc_get_type_abort(instance, module_instance_t);
if (count >= max_expansions) {
- rbtree_iter_done(&iter);
+ fr_rb_iter_done(&iter);
break;
}
if (fr_command_strncmp(text, mi->name)) {
static int cmd_show_module_list(FILE *fp, UNUSED FILE *fp_err, UNUSED void *uctx, UNUSED fr_cmd_info_t const *info)
{
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
void *instance;
- for (instance = rbtree_iter_init_inorder(&iter, module_instance_name_tree);
+ for (instance = fr_rb_iter_init_inorder(&iter, module_instance_name_tree);
instance;
- instance = rbtree_iter_next_inorder(&iter)) {
+ instance = fr_rb_iter_next_inorder(&iter)) {
module_instance_t *mi = talloc_get_type_abort(instance, module_instance_t);
fprintf(fp, "\t%s\n", mi->name);
inst_name = asked_name;
if (inst_name[0] == '-') inst_name++;
- inst = rbtree_find(module_instance_name_tree,
+ inst = fr_rb_find(module_instance_name_tree,
&(module_instance_t){
.dl_inst = &(dl_module_inst_t){ .parent = parent ? parent->dl_inst : NULL },
.name = inst_name
{
module_instance_t *mi;
- mi = rbtree_find(module_instance_data_tree,
+ mi = fr_rb_find(module_instance_data_tree,
&(module_instance_t){
.dl_inst = &(dl_module_inst_t){ .data = UNCONST(void *, data) },
});
void modules_free(void)
{
if (module_instance_name_tree) {
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
module_instance_t *mi;
- for (mi = rbtree_iter_init_inorder(&iter, module_instance_name_tree);
+ for (mi = fr_rb_iter_init_inorder(&iter, module_instance_name_tree);
mi;
- mi = rbtree_iter_next_inorder(&iter)) {
+ mi = fr_rb_iter_next_inorder(&iter)) {
mi->in_name_tree = false; /* about to be deleted */
talloc_free(mi);
- rbtree_iter_delete_inorder(&iter);
+ fr_rb_iter_delete_inorder(&iter);
}
TALLOC_FREE(module_instance_name_tree);
}
int modules_init(void)
{
- MEM(module_instance_name_tree = rbtree_alloc(NULL, module_instance_t, name_node,
- module_instance_name_cmp, NULL, RBTREE_FLAG_NONE));
- MEM(module_instance_data_tree = rbtree_alloc(NULL, module_instance_t, data_node,
- module_instance_data_cmp, NULL, RBTREE_FLAG_NONE));
+ MEM(module_instance_name_tree = fr_rb_alloc(NULL, module_instance_t, name_node,
+ module_instance_name_cmp, NULL, RB_FLAG_NONE));
+ MEM(module_instance_data_tree = fr_rb_alloc(NULL, module_instance_t, data_node,
+ module_instance_data_cmp, NULL, RB_FLAG_NONE));
instance_ctx = talloc_init("module instance context");
return 0;
int modules_thread_instantiate(TALLOC_CTX *ctx, fr_event_list_t *el)
{
void *instance;
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
/*
* Initialise the thread specific tree if this is the first time through
*/
MEM(module_thread_inst_array[0] = talloc_zero(module_thread_inst_array, module_thread_instance_t));
- for (instance = rbtree_iter_init_inorder(&iter, module_instance_name_tree);
+ for (instance = fr_rb_iter_init_inorder(&iter, module_instance_name_tree);
instance;
- instance = rbtree_iter_next_inorder(&iter)) {
+ instance = fr_rb_iter_next_inorder(&iter)) {
module_instance_t *mi = talloc_get_type_abort(instance, module_instance_t);
module_thread_instance_t *ti;
if (mi->module->thread_instantiate) {
if (mi->module->thread_instantiate(mi->dl_inst->conf, mi->dl_inst->data, el, ti->data) < 0) {
PERROR("Thread instantiation failed for module \"%s\"", mi->name);
- rbtree_iter_done(&iter);
+ fr_rb_iter_done(&iter);
TALLOC_FREE(module_thread_inst_array);
return -1;
}
int modules_instantiate(void)
{
void *instance;
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
DEBUG2("#### Instantiating modules ####");
- for (instance = rbtree_iter_init_inorder(&iter, module_instance_name_tree);
+ for (instance = fr_rb_iter_init_inorder(&iter, module_instance_name_tree);
instance;
- instance = rbtree_iter_next_inorder(&iter)) {
+ instance = fr_rb_iter_next_inorder(&iter)) {
if (_module_instantiate(instance) < 0) {
- rbtree_iter_done(&iter);
+ fr_rb_iter_done(&iter);
return -1;
}
}
{
DEBUG3("Freeing %s (%p)", mi->name, mi);
- if (mi->in_name_tree) if (!fr_cond_assert(rbtree_delete(module_instance_name_tree, mi))) return 1;
- if (mi->in_data_tree) if (!fr_cond_assert(rbtree_delete(module_instance_data_tree, mi))) return 1;
+ if (mi->in_name_tree) if (!fr_cond_assert(fr_rb_delete(module_instance_name_tree, mi))) return 1;
+ if (mi->in_data_tree) if (!fr_cond_assert(fr_rb_delete(module_instance_data_tree, mi))) return 1;
if (mi->mutex) {
/*
* FIXME
/*
* Remember the module for later.
*/
- if (!fr_cond_assert(rbtree_insert(module_instance_name_tree, mi))) goto error;
+ if (!fr_cond_assert(fr_rb_insert(module_instance_name_tree, mi))) goto error;
mi->in_name_tree = true;
/*
* and for bootstrapping submodules.
*/
if (mi->dl_inst->data) {
- if (!fr_cond_assert(rbtree_insert(module_instance_data_tree, mi))) goto error;
+ if (!fr_cond_assert(fr_rb_insert(module_instance_data_tree, mi))) goto error;
mi->in_data_tree = true;
}
uint64_t timed_out; //!< Number of states that were cleaned up due to
//!< timeout.
uint32_t max_sessions; //!< Maximum number of sessions we track.
- rbtree_t *tree; //!< rbtree used to lookup state value.
+ fr_rb_tree_t *tree; //!< rbtree used to lookup state value.
fr_dlist_head_t to_expire; //!< Linked list of entries to free.
fr_time_delta_t timeout; //!< How long to wait before cleaning up state entires.
* are freed before it's destroyed. Hence
* it being parented from the NULL ctx.
*/
- state->tree = rbtree_talloc_alloc(NULL, fr_state_entry_t, node, state_entry_cmp, NULL, 0);
+ state->tree = fr_rb_tree_talloc_alloc(NULL, fr_state_entry_t, node, state_entry_cmp, NULL, 0);
if (!state->tree) {
talloc_free(state);
return NULL;
fr_dlist_remove(&state->to_expire, entry);
- rbtree_delete(state->tree, entry);
+ fr_rb_delete(state->tree, entry);
DEBUG4("State ID %" PRIu64 " unlinked", entry->id);
}
state->timed_out += timed_out;
- if (!old && (rbtree_num_elements(state->tree) >= (uint32_t) state->max_sessions)) too_many = true;
+ if (!old && (fr_rb_num_elements(state->tree) >= (uint32_t) state->max_sessions)) too_many = true;
/*
* Record the information from the old state, we may base the
*/
*((uint32_t *)(&entry->state_comp.context_id)) ^= state->context_id;
- if (!rbtree_insert(state->tree, entry)) {
+ if (!fr_rb_insert(state->tree, entry)) {
RERROR("Failed inserting state entry - Insertion into state tree failed");
fr_pair_delete_by_da(reply_list, state->da);
talloc_free(entry);
*/
my_entry.state_comp.context_id ^= state->context_id;
- entry = rbtree_find(state->tree, &my_entry);
+ entry = fr_rb_find(state->tree, &my_entry);
if (entry) (void) talloc_get_type_abort(entry, fr_state_entry_t);
*/
uint64_t fr_state_entries_tracked(fr_state_tree_t *state)
{
- return rbtree_num_elements(state->tree);
+ return fr_rb_num_elements(state->tree);
}
*/
static bool triggers_init;
static CONF_SECTION const *trigger_exec_main, *trigger_exec_subcs;
-static rbtree_t *trigger_last_fired_tree;
+static fr_rb_tree_t *trigger_last_fired_tree;
static pthread_mutex_t *trigger_mutex;
#define REQUEST_INDEX_TRIGGER_NAME 1
return 0;
}
- MEM(trigger_last_fired_tree = rbtree_talloc_alloc(talloc_null_ctx(),
+ MEM(trigger_last_fired_tree = fr_rb_tree_talloc_alloc(talloc_null_ctx(),
trigger_last_fired_t, node,
_trigger_last_fired_cmp, _trigger_last_fired_free, 0));
pthread_mutex_lock(trigger_mutex);
- found = rbtree_find(trigger_last_fired_tree, &find);
+ found = fr_rb_find(trigger_last_fired_tree, &find);
if (!found) {
MEM(found = talloc(NULL, trigger_last_fired_t));
found->ci = ci;
found->last_fired = 0;
- rbtree_insert(trigger_last_fired_tree, found);
+ fr_rb_insert(trigger_last_fired_tree, found);
}
pthread_mutex_unlock(trigger_mutex);
*/
static CONF_SECTION *virtual_server_root;
-static rbtree_t *listen_addr_root = NULL;
+static fr_rb_tree_t *listen_addr_root = NULL;
/** Lookup allowed section names for modules
*/
-static rbtree_t *server_section_name_tree = NULL;
+static fr_rb_tree_t *server_section_name_tree = NULL;
static int8_t server_section_name_cmp(void const *one, void const *two);
{
if (!listen_addr_root) return false;
- return rbtree_find(listen_addr_root, li);
+ return fr_rb_find(listen_addr_root, li);
}
if (listen_find_any(li) != NULL) return false;
- return rbtree_insert(listen_addr_root, li);
+ return fr_rb_insert(listen_addr_root, li);
}
static int process_instantiate(CONF_SECTION *server_cs, dl_module_inst_t *dl_inst, fr_dict_t const *dict)
int virtual_servers_instantiate(void)
{
size_t i, server_cnt = virtual_servers ? talloc_array_length(virtual_servers) : 0;
- rbtree_t *vns_tree = cf_data_value(cf_data_find(virtual_server_root, rbtree_t, "vns_tree"));
+ fr_rb_tree_t *vns_tree = cf_data_value(cf_data_find(virtual_server_root, fr_rb_tree_t, "vns_tree"));
fr_assert(virtual_servers);
fr_virtual_namespace_t find = { .namespace = virtual_servers[i]->namespace };
fr_virtual_namespace_t *found;
- found = rbtree_find(vns_tree, &find);
+ found = fr_rb_find(vns_tree, &find);
if (found) {
fr_assert(dict && (dict->dict == found->dict));
int virtual_namespace_register(char const *namespace, fr_dict_t const *dict,
fr_virtual_server_compile_t func)
{
- rbtree_t *vns_tree;
+ fr_rb_tree_t *vns_tree;
fr_virtual_namespace_t *vns;
fr_assert(virtual_server_root); /* Virtual server bootstrap must be called first */
vns->dict = dict;
vns->func = func;
- vns_tree = cf_data_value(cf_data_find(virtual_server_root, rbtree_t, "vns_tree"));
+ vns_tree = cf_data_value(cf_data_find(virtual_server_root, fr_rb_tree_t, "vns_tree"));
if (!vns_tree) {
/*
* Tree will be freed when the cf_data is freed
* so it shouldn't be parented from
* virtual_server_root.
*/
- MEM(vns_tree = rbtree_talloc_alloc(NULL,
+ MEM(vns_tree = fr_rb_tree_talloc_alloc(NULL,
fr_virtual_namespace_t, node,
_virtual_namespace_cmp,
- _virtual_namespace_free, RBTREE_FLAG_REPLACE));
+ _virtual_namespace_free, RB_FLAG_REPLACE));
if (!cf_data_add(virtual_server_root, vns_tree, "vns_tree", true)) {
ERROR("Failed adding namespace tree data to config");
}
}
- if (!rbtree_insert(vns_tree, vns)) {
+ if (!fr_rb_insert(vns_tree, vns)) {
ERROR("Failed inserting namespace into tree");
return -1;
}
int virtual_servers_init(CONF_SECTION *config)
{
#ifndef NDEBUG
- int rbflags = RBTREE_FLAG_LOCK; /* Produces deadlocks when iterators conflict with other operations */
+ int rbflags = RB_FLAG_LOCK; /* Produces deadlocks when iterators conflict with other operations */
#else
- int rbflags = RBTREE_FLAG_NONE;
+ int rbflags = RB_FLAG_NONE;
#endif
virtual_server_root = config;
return -1;
}
- MEM(listen_addr_root = rbtree_alloc(NULL, fr_listen_t, virtual_server_node,
+ MEM(listen_addr_root = fr_rb_alloc(NULL, fr_listen_t, virtual_server_node,
listen_addr_cmp, NULL, rbflags));
- MEM(server_section_name_tree = rbtree_alloc(NULL, virtual_server_compile_t, node,
+ MEM(server_section_name_tree = fr_rb_alloc(NULL, virtual_server_compile_t, node,
server_section_name_cmp, NULL, rbflags));
return 0;
fr_assert(server_section_name_tree != NULL);
- old = rbtree_find(server_section_name_tree, entry);
+ old = fr_rb_find(server_section_name_tree, entry);
if (old) return 0;
#ifndef NDEBUG
}
#endif
- if (!rbtree_insert(server_section_name_tree, entry)) {
+ if (!fr_rb_insert(server_section_name_tree, entry)) {
fr_strerror_const("Failed inserting entry into internal tree");
return -1;
}
* define both "accounting on", and "accounting *".
*/
if (name2 != CF_IDENT_ANY) {
- entry = rbtree_find(server_section_name_tree,
+ entry = fr_rb_find(server_section_name_tree,
&(virtual_server_compile_t) {
.name = name1,
.name2 = name2,
/*
* Then look up the wildcard, if we didn't find any matching name2.
*/
- entry = rbtree_find(server_section_name_tree,
+ entry = fr_rb_find(server_section_name_tree,
&(virtual_server_compile_t) {
.name = name1,
.name2 = CF_IDENT_ANY,
#include <freeradius-devel/tls/engine.h>
#include <freeradius-devel/tls/log.h>
#include <freeradius-devel/util/dlist.h>
-#include <freeradius-devel/util/rbtree.h>
+#include <freeradius-devel/util/rb.h>
#include <freeradius-devel/util/strerror.h>
#include <freeradius-devel/util/value.h>
* work well for dynamically loaded engines, where we may want one
* instance of the engine per thread.
*/
-static rbtree_t *tls_engines;
+static fr_rb_tree_t *tls_engines;
/** Compares two engines
*
fr_tls_engine_ctrl_t *ctrl = NULL, *n;
if (!tls_engines) {
- tls_engines = rbtree_alloc(NULL, tls_engine_t, node, tls_engine_cmp, rbtree_node_talloc_free, 0);
+ tls_engines = fr_rb_alloc(NULL, tls_engine_t, node, tls_engine_cmp, fr_rb_node_talloc_free, 0);
if (unlikely(!tls_engines)) {
oom:
fr_strerror_const("Out of memory");
} else {
tls_engine_t *found = NULL;
- found = rbtree_find(tls_engines, &(tls_engine_t){ .id = id, .instance = instance });
+ found = fr_rb_find(tls_engines, &(tls_engine_t){ .id = id, .instance = instance });
if (found) {
fr_strerror_printf("engine %s%s%s%salready initialised", id,
instance ? " (" : "",
}
- found = rbtree_find(tls_engines, &(tls_engine_t){ .id = id, .instance = instance });
+ found = fr_rb_find(tls_engines, &(tls_engine_t){ .id = id, .instance = instance });
if (!found) {
if (!auto_init) goto not_init;
goto do_init;
/*
* Mitigate against CrossTalk (CVE-2020-0543)
*/
- if (!tls_engines || !rbtree_find(tls_engines, &(tls_engine_t){ .id = "rdrand" })) {
+ if (!tls_engines || !fr_rb_find(tls_engines, &(tls_engine_t){ .id = "rdrand" })) {
ENGINE *rand_engine;
ENGINE_register_all_RAND(); /* Give rand engines a chance to register */
#include <ctype.h>
-static rbtree_t *xlat_root = NULL;
+static fr_rb_tree_t *xlat_root = NULL;
static char const hextab[] = "0123456789abcdef";
if (!xlat_root) return NULL;
if (inlen < 0) {
- return rbtree_find(xlat_root, &(xlat_t){ .name = in });
+ return fr_rb_find(xlat_root, &(xlat_t){ .name = in });
}
if ((size_t) inlen >= sizeof(buffer)) return NULL;
memcpy(buffer, in, inlen);
buffer[inlen] = '\0';
- return rbtree_find(xlat_root, &(xlat_t){ .name = buffer });
+ return fr_rb_find(xlat_root, &(xlat_t){ .name = buffer });
}
{
if (!xlat_root) return 0;
- rbtree_delete(xlat_root, xlat);
- if (rbtree_num_elements(xlat_root) == 0) TALLOC_FREE(xlat_root);
+ fr_rb_delete(xlat_root, xlat);
+ if (fr_rb_num_elements(xlat_root) == 0) TALLOC_FREE(xlat_root);
return 0;
}
/*
* If it already exists, replace the instance.
*/
- c = rbtree_find(xlat_root, &(xlat_t){ .name = name });
+ c = fr_rb_find(xlat_root, &(xlat_t){ .name = name });
if (c) {
if (c->internal) {
ERROR("%s: Cannot re-define internal expansion %s", __FUNCTION__, name);
DEBUG3("%s: %s", __FUNCTION__, c->name);
- if (is_new && !rbtree_insert(xlat_root, c)) {
+ if (is_new && !fr_rb_insert(xlat_root, c)) {
ERROR("Failed inserting xlat registration for %s",
c->name);
talloc_free(c);
/*
* If it already exists, replace the instance.
*/
- c = rbtree_find(xlat_root, &(xlat_t){ .name = name });
+ c = fr_rb_find(xlat_root, &(xlat_t){ .name = name });
if (c) {
if (c->internal) {
ERROR("%s: Cannot re-define internal expansion %s", __FUNCTION__, name);
talloc_set_destructor(c, _xlat_func_talloc_free);
DEBUG3("%s: %s", __FUNCTION__, c->name);
- if (!rbtree_insert(xlat_root, c)) {
+ if (!fr_rb_insert(xlat_root, c)) {
ERROR("%s: Failed inserting xlat registration for %s", __FUNCTION__, c->name);
talloc_free(c);
return NULL;
if (!name || !xlat_root) return;
- c = rbtree_find(xlat_root, &(xlat_t){ .name = name });
+ c = fr_rb_find(xlat_root, &(xlat_t){ .name = name });
if (!c) return;
(void) talloc_get_type_abort(c, xlat_t);
void xlat_unregister_module(void *instance)
{
xlat_t *c;
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
if (!xlat_root) return; /* All xlats have already been freed */
- for (c = rbtree_iter_init_inorder(&iter, xlat_root);
+ for (c = fr_rb_iter_init_inorder(&iter, xlat_root);
c;
- c = rbtree_iter_next_inorder(&iter)) {
+ c = fr_rb_iter_next_inorder(&iter)) {
if (c->mod_inst != instance) continue;
- rbtree_iter_delete_inorder(&iter);
+ fr_rb_iter_delete_inorder(&iter);
}
}
/*
* Create the function tree
*/
- xlat_root = rbtree_talloc_alloc(NULL, xlat_t, node, xlat_cmp, _xlat_func_tree_free, RBTREE_FLAG_REPLACE);
+ xlat_root = fr_rb_tree_talloc_alloc(NULL, xlat_t, node, xlat_cmp, _xlat_func_tree_free, RB_FLAG_REPLACE);
if (!xlat_root) {
ERROR("%s: Failed to create tree", __FUNCTION__);
return -1;
*/
void xlat_free(void)
{
- rbtree_t *xr = xlat_root; /* Make sure the tree can't be freed multiple times */
+ fr_rb_tree_t *xr = xlat_root; /* Make sure the tree can't be freed multiple times */
if (!xr) return;
/** Holds instance data created by xlat_instantiate
*/
-static rbtree_t *xlat_inst_tree;
+static fr_rb_tree_t *xlat_inst_tree;
/** Holds thread specific instance data created by xlat_instantiate
*/
-static _Thread_local rbtree_t *xlat_thread_inst_tree;
+static _Thread_local fr_rb_tree_t *xlat_thread_inst_tree;
/** Compare two xlat instances based on node pointer
*
* Remove permanent data from the instance tree.
*/
if (!inst->node->call.ephemeral) {
- rbtree_delete(xlat_inst_tree, inst);
- if (rbtree_num_elements(xlat_inst_tree) == 0) TALLOC_FREE(xlat_inst_tree);
+ fr_rb_delete(xlat_inst_tree, inst);
+ if (fr_rb_num_elements(xlat_inst_tree) == 0) TALLOC_FREE(xlat_inst_tree);
}
if (inst->node->call.func->detach) (void) inst->node->call.func->detach(inst->data, inst->node->call.func->uctx);
}
}
- rbtree_insert(xlat_thread_inst_tree, thread_inst);
+ fr_rb_insert(xlat_thread_inst_tree, thread_inst);
return 0;
}
if (node->call.ephemeral) return node->call.thread_inst;
- found = rbtree_find(xlat_thread_inst_tree, &(xlat_thread_inst_t){ .node = node });
+ found = fr_rb_find(xlat_thread_inst_tree, &(xlat_thread_inst_t){ .node = node });
fr_assert(found);
return found;
*/
int xlat_thread_instantiate(TALLOC_CTX *ctx)
{
- fr_rb_tree_iter_preorder_t iter;
+ fr_rb_iter_preorder_t iter;
void *data;
if (!xlat_inst_tree) return 0;
if (!xlat_thread_inst_tree) {
- MEM(xlat_thread_inst_tree = rbtree_talloc_alloc(ctx, xlat_thread_inst_t, inst_node,
+ MEM(xlat_thread_inst_tree = fr_rb_tree_talloc_alloc(ctx, xlat_thread_inst_t, inst_node,
_xlat_thread_inst_cmp, _xlat_thread_inst_free, 0));
}
/*
* Walk the inst tree, creating thread specific instances.
*/
- for (data = rbtree_iter_init_preorder(&iter, xlat_inst_tree);
+ for (data = fr_rb_iter_init_preorder(&iter, xlat_inst_tree);
data;
- data = rbtree_iter_next_preorder(&iter)) {
+ data = fr_rb_iter_next_preorder(&iter)) {
if (_xlat_thread_instantiate(data, xlat_thread_inst_tree) < 0) {
TALLOC_FREE(xlat_thread_inst_tree);
- rbtree_iter_done(&iter);
+ fr_rb_iter_done(&iter);
return -1;
}
}
{
if (xlat_inst_tree) return 0;
- xlat_inst_tree = rbtree_talloc_alloc(NULL, xlat_inst_t, inst_node,
- _xlat_inst_cmp, _xlat_inst_free, RBTREE_FLAG_NONE);
+ xlat_inst_tree = fr_rb_tree_talloc_alloc(NULL, xlat_inst_t, inst_node,
+ _xlat_inst_cmp, _xlat_inst_free, RB_FLAG_NONE);
if (!xlat_inst_tree) return -1;
return 0;
*/
int xlat_instantiate(void)
{
- fr_rb_tree_iter_preorder_t iter;
+ fr_rb_iter_preorder_t iter;
void *data;
if (!xlat_inst_tree) xlat_instantiate_init();
- for (data = rbtree_iter_init_preorder(&iter, xlat_inst_tree);
+ for (data = fr_rb_iter_init_preorder(&iter, xlat_inst_tree);
data;
- data = rbtree_iter_next_preorder(&iter)) {
+ data = fr_rb_iter_next_preorder(&iter)) {
xlat_inst_t *inst = talloc_get_type_abort(data, xlat_inst_t);
if (inst->node->call.func->instantiate &&
(inst->node->call.func->instantiate(inst->data, inst->node, inst->node->call.func->uctx) < 0)) {
- rbtree_iter_done(&iter);
+ fr_rb_iter_done(&iter);
return -1;
}
}
DEBUG3("Instantiating xlat \"%s\" node %p, new instance %p", node->call.func->name, node, node->call.inst);
- ret = rbtree_insert(xlat_inst_tree, node->call.inst);
+ ret = fr_rb_insert(xlat_inst_tree, node->call.inst);
if (!fr_cond_assert(ret)) {
TALLOC_FREE(node->call.inst);
return -1;
libfreeradius-util.mk \
pair_legacy_tests.mk \
pair_tests.mk \
- rbtree_tests.mk \
+ rb_tests.mk \
sbuff_tests.mk \
strerror_tests.mk
#include <freeradius-devel/util/print.h>
#include <freeradius-devel/util/proto.h>
#include <freeradius-devel/util/rand.h>
-#include <freeradius-devel/util/rbtree.h>
+#include <freeradius-devel/util/rb.h>
#include <freeradius-devel/util/regex.h>
#include <freeradius-devel/util/sha1.h>
#include <freeradius-devel/util/snprintf.h>
#include <freeradius-devel/missing.h>
#include <freeradius-devel/util/dl.h>
#include <freeradius-devel/util/ext.h>
-#include <freeradius-devel/util/rbtree.h>
+#include <freeradius-devel/util/rb.h>
#include <freeradius-devel/util/sbuff.h>
#include <freeradius-devel/util/table.h>
#include <freeradius-devel/util/talloc.h>
fr_dict_attr_t **fixups; //!< Attributes that need fixing up.
- rbtree_t *dependents; //!< Which files are using this dictionary.
+ fr_rb_tree_t *dependents; //!< Which files are using this dictionary.
};
struct fr_dict_gctx_s {
{
fr_dict_dependent_t *found;
- found = rbtree_find(dict->dependents, &(fr_dict_dependent_t){ .dependent = dependent } );
+ found = fr_rb_find(dict->dependents, &(fr_dict_dependent_t){ .dependent = dependent } );
if (!found) {
fr_dict_dependent_t *new;
* a dictionary.
*/
new->dependent = talloc_typed_strdup(new, dependent);
- rbtree_insert(dict->dependents, new);
+ fr_rb_insert(dict->dependents, new);
new->count = 1;
{
fr_dict_dependent_t *found;
- found = rbtree_find(dict->dependents, &(fr_dict_dependent_t){ .dependent = dependent } );
+ found = fr_rb_find(dict->dependents, &(fr_dict_dependent_t){ .dependent = dependent } );
if (!found) {
fr_strerror_printf("Dependent \"%s\" not found in dictionary \"%s\"", dependent, dict->root->name);
return -1;
}
if (--found->count == 0) {
- rbtree_delete(dict->dependents, found);
+ fr_rb_delete(dict->dependents, found);
talloc_free(found);
return 0;
}
*/
bool dict_has_dependents(fr_dict_t *dict)
{
- return (rbtree_num_elements(dict->dependents) > 0);
+ return (fr_rb_num_elements(dict->dependents) > 0);
}
static int _dict_free(fr_dict_t *dict)
dict->in_protocol_by_num = false;
if (dict_has_dependents(dict)) {
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
fr_dict_dependent_t *dep;
fr_strerror_printf("Refusing to free dictionary \"%s\", still has dependents", dict->root->name);
- for (dep = rbtree_iter_init_inorder(&iter, dict->dependents);
+ for (dep = fr_rb_iter_init_inorder(&iter, dict->dependents);
dep;
- dep = rbtree_iter_next_inorder(&iter)) {
+ dep = fr_rb_iter_next_inorder(&iter)) {
fr_strerror_printf_push("%s (%u)", dep->dependent, dep->count);
}
return -1;
/*
* Who/what depends on this dictionary
*/
- dict->dependents = rbtree_alloc(dict, fr_dict_dependent_t, node, _dict_dependent_cmp, NULL, 0);
+ dict->dependents = fr_rb_alloc(dict, fr_dict_dependent_t, node, _dict_dependent_cmp, NULL, 0);
/*
* Set default type size and length.
{
fr_hash_iter_t dict_iter;
fr_dict_t *dict;
- fr_rb_tree_iter_inorder_t dep_iter;
+ fr_rb_iter_inorder_t dep_iter;
fr_dict_dependent_t *dep;
if (!dict_gctx) {
for (dict = fr_hash_table_iter_init(dict_gctx->protocol_by_num, &dict_iter);
dict;
dict = fr_hash_table_iter_next(dict_gctx->protocol_by_num, &dict_iter)) {
- for (dep = rbtree_iter_init_inorder(&dep_iter, dict->dependents);
+ for (dep = fr_rb_iter_init_inorder(&dep_iter, dict->dependents);
dep;
- dep = rbtree_iter_next_inorder(&dep_iter)) {
+ dep = fr_rb_iter_next_inorder(&dep_iter)) {
FR_FAULT_LOG("\t%s refs %s (%u)", dict->root->name, dep->dependent, dep->count);
}
}
if (dict_gctx->internal) {
- for (dep = rbtree_iter_init_inorder(&dep_iter, dict_gctx->internal->dependents);
+ for (dep = fr_rb_iter_init_inorder(&dep_iter, dict_gctx->internal->dependents);
dep;
- dep = rbtree_iter_next_inorder(&dep_iter)) {
+ dep = fr_rb_iter_next_inorder(&dep_iter)) {
FR_FAULT_LOG("\t%s refs %s (%u)", dict_gctx->internal->root->name, dep->dependent, dep->count);
}
}
bool do_dlclose; //!< dlclose modules when we're done with them.
- rbtree_t *tree; //!< Tree of shared objects loaded.
+ fr_rb_tree_t *tree; //!< Tree of shared objects loaded.
void *uctx; //!< dl private extension data.
dl->handle = NULL;
- if (dl->in_tree) rbtree_delete(dl->loader->tree, dl);
+ if (dl->in_tree) fr_rb_delete(dl->loader->tree, dl);
return 0;
}
* There's already something in the tree,
* just return that instead.
*/
- dl = rbtree_find(dl_loader->tree, &(dl_t){ .name = name });
+ dl = fr_rb_find(dl_loader->tree, &(dl_t){ .name = name });
if (dl) {
talloc_increase_ref_count(dl);
return dl;
};
talloc_set_destructor(dl, _dl_free);
- dl->in_tree = rbtree_insert(dl_loader->tree, dl);
+ dl->in_tree = fr_rb_insert(dl_loader->tree, dl);
if (!dl->in_tree) {
talloc_free(dl);
return NULL;
* We do reference counting, we know exactly what
* should still be active.
*/
- if (rbtree_num_elements(dl_loader->tree) > 0) {
+ if (fr_rb_num_elements(dl_loader->tree) > 0) {
#ifndef NDEBUG
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
void *data;
/*
* Yes, this is the correct call order
*/
- for (data = rbtree_iter_init_inorder(&iter, dl_loader->tree);
+ for (data = fr_rb_iter_init_inorder(&iter, dl_loader->tree);
data;
- data = rbtree_iter_next_inorder(&iter)) {
+ data = fr_rb_iter_next_inorder(&iter)) {
dl_t *dl = talloc_get_type_abort(data, dl_t);
fr_strerror_printf_push(" %s (%zu)", dl->name, talloc_reference_count(dl));
return NULL;
}
- dl_loader->tree = rbtree_talloc_alloc(dl_loader, dl_t, node, dl_handle_cmp, NULL, 0);
+ dl_loader->tree = fr_rb_tree_talloc_alloc(dl_loader, dl_t, node, dl_handle_cmp, NULL, 0);
if (!dl_loader->tree) {
fr_strerror_const("Failed initialising dl->tree");
error:
# include <dlfcn.h>
#endif
#include <freeradius-devel/util/dlist.h>
-#include <freeradius-devel/util/rbtree.h>
+#include <freeradius-devel/util/rb.h>
#include <freeradius-devel/util/talloc.h>
#include <freeradius-devel/util/version.h>
#include <freeradius-devel/util/event.h>
#include <freeradius-devel/util/heap.h>
#include <freeradius-devel/util/misc.h>
-#include <freeradius-devel/util/rbtree.h>
+#include <freeradius-devel/util/rb.h>
#include <freeradius-devel/util/strerror.h>
#include <freeradius-devel/util/syserror.h>
#include <freeradius-devel/util/table.h>
*/
struct fr_event_list {
fr_heap_t *times; //!< of timer events to be executed.
- rbtree_t *fds; //!< Tree used to track FDs with filters in kqueue.
+ fr_rb_tree_t *fds; //!< Tree used to track FDs with filters in kqueue.
#ifdef LOCAL_PID
fr_heap_t *pids; //!< PIDs to wait for
#endif
{
if (unlikely(!el)) return -1;
- return rbtree_num_elements(el->fds);
+ return fr_rb_num_elements(el->fds);
}
/** Return the number of timer events currently scheduled
}
}
- rbtree_delete(el->fds, ef);
+ fr_rb_delete(el->fds, ef);
ef->is_registered = false;
}
/*
* Ensure this exists
*/
- ef = rbtree_find(src->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+ ef = fr_rb_find(src->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
if (unlikely(!ef)) {
fr_strerror_printf("No events are registered for fd %i", fd);
return -1;
struct kevent evset[10];
int count = 0;
- ef = rbtree_find(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+ ef = fr_rb_find(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
if (unlikely(!ef)) {
fr_strerror_printf("No events are registered for fd %i", fd);
return -1;
}
if (!ef_out || !*ef_out) {
- ef = rbtree_find(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+ ef = fr_rb_find(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
} else {
ef = *ef_out;
fr_assert((fd < 0) || (ef->fd == fd));
}
ef->filter = filter;
- rbtree_insert(el->fds, ef);
+ fr_rb_insert(el->fds, ef);
ef->is_registered = true;
/*
{
fr_event_fd_t *ef;
- ef = rbtree_find(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+ ef = fr_rb_find(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
if (unlikely(!ef)) {
fr_strerror_printf("No events are registered for fd %i", fd);
return -1;
{
fr_event_fd_t *ef;
- ef = rbtree_find(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+ ef = fr_rb_find(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
if (unlikely(!ef)) {
fr_strerror_printf("No events are registered for fd %i", fd);
return -1;
{
fr_event_fd_t *ef;
- ef = rbtree_find(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+ ef = fr_rb_find(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
if (unlikely(!ef)) {
fr_strerror_printf("No events are registered for fd %i", fd);
return -1;
return NULL;
}
- el->fds = rbtree_talloc_alloc(el, fr_event_fd_t, node, fr_event_fd_cmp, NULL, 0);
+ el->fds = fr_rb_tree_talloc_alloc(el, fr_event_fd_t, node, fr_event_fd_cmp, NULL, 0);
if (!el->fds) {
fr_strerror_const("Failed allocating FD tree");
goto error;
*/
bool fr_event_list_empty(fr_event_list_t *el)
{
- return !fr_heap_num_elements(el->times) && !rbtree_num_elements(el->fds);
+ return !fr_heap_num_elements(el->times) && !fr_rb_num_elements(el->fds);
}
#ifdef WITH_EVENT_DEBUG
size_t i;
size_t array[NUM_ELEMENTS(decades)] = { 0 };
- rbtree_t *locations[NUM_ELEMENTS(decades)];
+ fr_rb_tree_t *locations[NUM_ELEMENTS(decades)];
TALLOC_CTX *tmp_ctx;
static pthread_mutex_t print_lock = PTHREAD_MUTEX_INITIALIZER;
}
for (i = 0; i < NUM_ELEMENTS(decades); i++) {
- locations[i] = rbtree_alloc(tmp_ctx, fr_event_counter_t, node, event_timer_location_cmp, NULL, 0);
+ locations[i] = fr_rb_alloc(tmp_ctx, fr_event_counter_t, node, event_timer_location_cmp, NULL, 0);
if (!locations[i]) goto oom;
}
fr_event_counter_t find = { .file = ev->file, .line = ev->line };
fr_event_counter_t *counter;
- counter = rbtree_find(locations[i], &find);
+ counter = fr_rb_find(locations[i], &find);
if (!counter) {
counter = talloc(locations[i], fr_event_counter_t);
if (!counter) goto oom;
counter->file = ev->file;
counter->line = ev->line;
counter->count = 1;
- rbtree_insert(locations[i], counter);
+ fr_rb_insert(locations[i], counter);
} else {
counter->count++;
}
EVENT_DEBUG(" num timer events : %u", fr_event_list_num_timers(el));
for (i = 0; i < NUM_ELEMENTS(decades); i++) {
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
void *node;
if (!array[i]) continue;
EVENT_DEBUG(" events %5s - %5s : %zu", decade_names[i - 1], decade_names[i], array[i]);
}
- for (node = rbtree_iter_init_inorder(&iter, locations[i]);
+ for (node = fr_rb_iter_init_inorder(&iter, locations[i]);
node;
- node = rbtree_iter_next_inorder(&iter)) {
+ node = fr_rb_iter_next_inorder(&iter)) {
fr_event_counter_t *counter = talloc_get_type_abort(node, fr_event_counter_t);
EVENT_DEBUG(" : %u allocd at %s[%u]",
#ifdef TESTING
/*
- * cc -g -I .. -c rbtree.c -o rbtree.o && cc -g -I .. -c isaac.c -o isaac.o && cc -DTESTING -I .. -c event.c -o event_mine.o && cc event_mine.o rbtree.o isaac.o -o event
+ * cc -g -I .. -c rb.c -o rbtree.o && cc -g -I .. -c isaac.c -o isaac.o && cc -DTESTING -I .. -c event.c -o event_mine.o && cc event_mine.o rbtree.o isaac.o -o event
*
* ./event
*
print.c \
proto.c \
rand.c \
- rbtree.c \
+ rb.c \
regex.c \
retry.c \
sbuff.c \
#include <freeradius-devel/missing.h>
#include <freeradius-devel/util/inet.h>
#include <freeradius-devel/util/pair.h>
-#include <freeradius-devel/util/rbtree.h>
+#include <freeradius-devel/util/rb.h>
#include <freeradius-devel/util/socket.h>
#include <freeradius-devel/util/talloc.h>
#include <freeradius-devel/util/time.h>
/** Red/black tree implementation
*
- * @file src/lib/util/rbtree.c
+ * @file src/lib/util/rb.c
*
* @copyright 2004,2006 The FreeRADIUS server project
*/
RCSID("$Id$")
#include <freeradius-devel/util/log.h>
-#include <freeradius-devel/util/rbtree.h>
+#include <freeradius-devel/util/rb.h>
#include <freeradius-devel/util/strerror.h>
#include <pthread.h>
#define NIL &sentinel /* all leafs are sentinels */
static fr_rb_node_t sentinel = { NIL, NIL, NULL, BLACK, NULL};
-struct rbtree_s {
+struct fr_rb_s {
#ifndef NDEBUG
uint32_t magic;
#endif
};
#ifndef NDEBUG
-# define RBTREE_MAGIC (0x5ad09c42)
+# define RB_MAGIC (0x5ad09c42)
#endif
-static fr_rb_node_t *rbtree_insert_node(rbtree_t *tree, void *data) CC_HINT(nonnull);
+static fr_rb_node_t *fr_rb_insert_node(fr_rb_tree_t *tree, void *data) CC_HINT(nonnull);
-static inline void rbtree_free_data(rbtree_t *tree, fr_rb_node_t *node)
+static inline void fr_rb_free_data(fr_rb_tree_t *tree, fr_rb_node_t *node)
{
if (!tree->free || unlikely(node->being_freed)) return;
node->being_freed = true;
/** Walks the tree to delete all nodes Does NOT re-balance it!
*
*/
-static void free_walker(rbtree_t *tree, fr_rb_node_t *x)
+static void free_walker(fr_rb_tree_t *tree, fr_rb_node_t *x)
{
(void) talloc_get_type_abort(x, fr_rb_node_t);
if (x->left != NIL) free_walker(tree, x->left);
if (x->right != NIL) free_walker(tree, x->right);
- rbtree_free_data(tree, x);
+ fr_rb_free_data(tree, x);
talloc_free(x);
}
-/** Wrapper function for rbtree_alloc to allow talloc node data to be freed
+/** Wrapper function for fr_rb_alloc to allow talloc node data to be freed
*
* @param[in] data Talloced data to free.
*/
-void rbtree_node_talloc_free(void *data)
+void fr_rb_node_talloc_free(void *data)
{
talloc_free(data);
}
* - 0 if tree was freed.
* - -1 if tree is already being freed.
*/
-static int _tree_free(rbtree_t *tree)
+static int _tree_free(fr_rb_tree_t *tree)
{
/*
* Prevent duplicate frees
* @param[in] compare Comparator function for ordering data in the tree.
* @param[in] node_free Free function to call whenever data is deleted or replaced.
* @param[in] flags A bitfield of flags.
- * - RBTREE_FLAG_REPLACE - replace nodes if a duplicate is found.
- * - RBTREE_FLAG_LOCK - use a mutex to prevent concurrent access
+ * - RB_FLAG_REPLACE - replace nodes if a duplicate is found.
+ * - RB_FLAG_LOCK - use a mutex to prevent concurrent access
* to the tree.
* @return
* - A new tree on success.
* - NULL on failure.
*/
-rbtree_t *_rbtree_alloc(TALLOC_CTX *ctx,
+fr_rb_tree_t *_fr_rb_alloc(TALLOC_CTX *ctx,
size_t offset, char const *type,
fr_cmp_t compare, fr_free_t node_free,
int flags)
{
- rbtree_t *tree;
+ fr_rb_tree_t *tree;
- tree = talloc(ctx, rbtree_t);
+ tree = talloc(ctx, fr_rb_tree_t);
if (!tree) return NULL;
- *tree = (rbtree_t) {
+ *tree = (fr_rb_tree_t) {
#ifndef NDEBUG
- .magic = RBTREE_MAGIC,
+ .magic = RB_MAGIC,
#endif
.root = NIL,
.offset = offset,
.type = type,
.compare = compare,
- .replace = ((flags & RBTREE_FLAG_REPLACE) != 0),
- .lock = ((flags & RBTREE_FLAG_LOCK) != 0),
+ .replace = ((flags & RB_FLAG_REPLACE) != 0),
+ .lock = ((flags & RB_FLAG_LOCK) != 0),
.free = node_free
};
if (tree->lock) pthread_mutex_init(&tree->mutex, NULL);
/** Explicitly unlock an rbtree locked with an interator
*
*/
-void rbtree_unlock(rbtree_t *tree)
+void fr_rb_unlock(fr_rb_tree_t *tree)
{
if (!tree->lock) return;
/** Rotate Node x to left
*
*/
-static void rotate_left(rbtree_t *tree, fr_rb_node_t *x)
+static void rotate_left(fr_rb_tree_t *tree, fr_rb_node_t *x)
{
fr_rb_node_t *y = x->right;
/** Rotate Node x to right
*
*/
-static void rotate_right(rbtree_t *tree, fr_rb_node_t *x)
+static void rotate_right(fr_rb_tree_t *tree, fr_rb_node_t *x)
{
fr_rb_node_t *y = x->left;
/** Maintain red-black tree balance after inserting node x
*
*/
-static void insert_fixup(rbtree_t *tree, fr_rb_node_t *x)
+static void insert_fixup(fr_rb_tree_t *tree, fr_rb_node_t *x)
{
/* check RED-BLACK properties */
while ((x != tree->root) && (x->parent->colour == RED)) {
/** Insert an element into the tree
*
*/
-static fr_rb_node_t *rbtree_insert_node(rbtree_t *tree, void *data)
+static fr_rb_node_t *fr_rb_insert_node(fr_rb_tree_t *tree, void *data)
{
fr_rb_node_t *current, *parent, *x;
/*
* Do replace the entry.
*/
- rbtree_free_data(tree, current->data);
+ fr_rb_free_data(tree, current->data);
x = talloc_zero(tree, fr_rb_node_t);
if (!x) {
return x;
}
-bool rbtree_insert(rbtree_t *tree, void const *data)
+bool fr_rb_insert(fr_rb_tree_t *tree, void const *data)
{
- if (rbtree_insert_node(tree, UNCONST(void *, data))) return true;
+ if (fr_rb_insert_node(tree, UNCONST(void *, data))) return true;
return false;
}
/** Maintain RED-BLACK tree balance after deleting node x
*
*/
-static void delete_fixup(rbtree_t *tree, fr_rb_node_t *x, fr_rb_node_t *parent)
+static void delete_fixup(fr_rb_tree_t *tree, fr_rb_node_t *x, fr_rb_node_t *parent)
{
while (x != tree->root && x->colour == BLACK) {
/** Delete an element (z) from the tree
*
*/
-static void rbtree_delete_internal(rbtree_t *tree, fr_rb_node_t *z, bool skiplock)
+static void fr_rb_delete_internal(fr_rb_tree_t *tree, fr_rb_node_t *z, bool skiplock)
{
fr_rb_node_t *x, *y;
fr_rb_node_t *parent;
if (y->left->parent == z) y->left->parent = y;
if (y->right->parent == z) y->right->parent = y;
- rbtree_free_data(tree, z);
+ fr_rb_free_data(tree, z);
talloc_free(z);
} else {
if (y->colour == BLACK) delete_fixup(tree, x, parent);
- rbtree_free_data(tree, y);
+ fr_rb_free_data(tree, y);
talloc_free(y);
}
/* Find user data, returning the node
*
*/
-static fr_rb_node_t *rbtree_find_node(rbtree_t *tree, void const *data)
+static fr_rb_node_t *fr_rb_find_node(fr_rb_tree_t *tree, void const *data)
{
fr_rb_node_t *current;
*
* @hidecallergraph
*/
-void *rbtree_find(rbtree_t *tree, void const *data)
+void *fr_rb_find(fr_rb_tree_t *tree, void const *data)
{
fr_rb_node_t *x;
if (unlikely(tree->being_freed)) return NULL;
- x = rbtree_find_node(tree, data);
+ x = fr_rb_find_node(tree, data);
if (!x) return NULL;
return x->data;
*
*
*/
-bool rbtree_delete(rbtree_t *tree, void const *data)
+bool fr_rb_delete(fr_rb_tree_t *tree, void const *data)
{
fr_rb_node_t *node;
if (unlikely(tree->being_freed)) return false;
- node = rbtree_find_node(tree, data);
+ node = fr_rb_find_node(tree, data);
if (!node) return false;
if (unlikely(tree->being_freed) || unlikely(node->being_freed)) return true;
- rbtree_delete_internal(tree, node, false);
+ fr_rb_delete_internal(tree, node, false);
return true;
}
*
* @param[in] tree to return node count for.
*/
-uint64_t rbtree_num_elements(rbtree_t *tree)
+uint64_t fr_rb_num_elements(fr_rb_tree_t *tree)
{
return tree->num_elements;
}
/** Initialise an in-order iterator
*
- * @note If iteration ends early because of a loop condition #rbtree_iter_done must be called.
+ * @note If iteration ends early because of a loop condition #fr_rb_iter_done must be called.
*
* @param[out] iter to initialise.
* @param[in] tree to iterate over.
* - The first node. Mutex will be held.
* - NULL if the tree is empty.
*/
-void *rbtree_iter_init_inorder(fr_rb_tree_iter_inorder_t *iter, rbtree_t *tree)
+void *fr_rb_iter_init_inorder(fr_rb_iter_inorder_t *iter, fr_rb_tree_t *tree)
{
fr_rb_node_t *x = tree->root;
*/
while (x->left != NIL) x = x->left;
- *iter = (fr_rb_tree_iter_inorder_t){
+ *iter = (fr_rb_iter_inorder_t){
.tree = tree,
.node = x
};
*
* @note Will unlock the tree if no more elements remain.
*
- * @param[in] iter previously initialised with #rbtree_iter_init
+ * @param[in] iter previously initialised with #fr_rb_iter_init
* @return
* - The next node.
* - NULL if no more nodes remain.
*/
-void *rbtree_iter_next_inorder(fr_rb_tree_iter_inorder_t *iter)
+void *fr_rb_iter_next_inorder(fr_rb_iter_inorder_t *iter)
{
fr_rb_node_t *x = iter->node, *y;
if (unlikely(iter->node == NIL)) return NULL;
/*
- * rbtree_iter_delete() has already deleted this node,
+ * fr_rb_iter_delete() has already deleted this node,
* and saved the next one for us. (We check for NULL;
* NIL just means we're at the end.)
*/
*
* @note Only makes sense for in-order traversals.
*
- * @param[in] iter previously initialised with #rbtree_iter_inorder_init
+ * @param[in] iter previously initialised with #fr_rb_iter_inorder_init
*/
-void rbtree_iter_delete_inorder(fr_rb_tree_iter_inorder_t *iter)
+void fr_rb_iter_delete_inorder(fr_rb_iter_inorder_t *iter)
{
fr_rb_node_t *x = iter->node;
if (unlikely(x == NIL)) return;
- (void) rbtree_iter_next_inorder(iter);
+ (void) fr_rb_iter_next_inorder(iter);
iter->next = iter->node;
iter->node = NULL;
- rbtree_delete_internal(iter->tree, x, true);
+ fr_rb_delete_internal(iter->tree, x, true);
}
/** Initialise a pre-order iterator
*
- * @note If iteration ends early because of a loop condition #rbtree_iter_done must be called.
+ * @note If iteration ends early because of a loop condition #fr_rb_iter_done must be called.
*
* @param[out] iter to initialise.
* @param[in] tree to iterate over.
* - The first node. Mutex will be held.
* - NULL if the tree is empty.
*/
-void *rbtree_iter_init_preorder(fr_rb_tree_iter_preorder_t *iter, rbtree_t *tree)
+void *fr_rb_iter_init_preorder(fr_rb_iter_preorder_t *iter, fr_rb_tree_t *tree)
{
fr_rb_node_t *x = tree->root;
/*
* First, the root.
*/
- *iter = (fr_rb_tree_iter_preorder_t){
+ *iter = (fr_rb_iter_preorder_t){
.tree = tree,
.node = x
};
*
* @note Will unlock the tree if no more elements remain.
*
- * @param[in] iter previously initialised with #rbtree_iter_init
+ * @param[in] iter previously initialised with #fr_rb_iter_init
* @return
* - The next node.
* - NULL if no more nodes remain.
*/
-void *rbtree_iter_next_preorder(fr_rb_tree_iter_preorder_t *iter)
+void *fr_rb_iter_next_preorder(fr_rb_iter_preorder_t *iter)
{
fr_rb_node_t *x = iter->node, *y;
/** Initialise a post-order iterator
*
- * @note If iteration ends early because of a loop condition #rbtree_iter_done must be called.
+ * @note If iteration ends early because of a loop condition #fr_rb_iter_done must be called.
*
* @param[out] iter to initialise.
* @param[in] tree to iterate over.
* - The first node. Mutex will be held.
* - NULL if the tree is empty.
*/
-void *rbtree_iter_init_postorder(fr_rb_tree_iter_postorder_t *iter, rbtree_t *tree)
+void *fr_rb_iter_init_postorder(fr_rb_iter_postorder_t *iter, fr_rb_tree_t *tree)
{
fr_rb_node_t *x = tree->root;
x = x->right;
}
- *iter = (fr_rb_tree_iter_postorder_t){
+ *iter = (fr_rb_iter_postorder_t){
.tree = tree,
.node = x
};
*
* @note Will unlock the tree if no more elements remain.
*
- * @param[in] iter previously initialised with #rbtree_iter_init
+ * @param[in] iter previously initialised with #fr_rb_iter_init
* @return
* - The next node.
* - NULL if no more nodes remain.
*/
-void *rbtree_iter_next_postorder(fr_rb_tree_iter_postorder_t *iter)
+void *fr_rb_iter_next_postorder(fr_rb_iter_postorder_t *iter)
{
fr_rb_node_t *x = iter->node, *y;
return x->data;
}
-#define DEF_RBTREE_FLATTEN_FUNC(_order) \
-int rbtree_flatten_##_order(TALLOC_CTX *ctx, void **out[], rbtree_t *tree) \
+#define DEF_RB_FLATTEN_FUNC(_order) \
+int fr_rb_flatten_##_order(TALLOC_CTX *ctx, void **out[], fr_rb_tree_t *tree) \
{ \
- uint64_t num = rbtree_num_elements(tree), i; \
- fr_rb_tree_iter_##_order##_t iter; \
+ uint64_t num = fr_rb_num_elements(tree), i; \
+ fr_rb_iter_##_order##_t iter; \
void *item, **list; \
if (unlikely(!(list = talloc_array(ctx, void *, num)))) return -1; \
- for (item = rbtree_iter_init_##_order(&iter, tree), i = 0; \
+ for (item = fr_rb_iter_init_##_order(&iter, tree), i = 0; \
item; \
- item = rbtree_iter_next_##_order(&iter), i++) list[i] = item; \
+ item = fr_rb_iter_next_##_order(&iter), i++) list[i] = item; \
*out = list; \
return 0; \
}
-DEF_RBTREE_FLATTEN_FUNC(preorder)
-DEF_RBTREE_FLATTEN_FUNC(postorder)
-DEF_RBTREE_FLATTEN_FUNC(inorder)
+DEF_RB_FLATTEN_FUNC(preorder)
+DEF_RB_FLATTEN_FUNC(postorder)
+DEF_RB_FLATTEN_FUNC(inorder)
/** Red/black tree implementation
*
- * @file src/lib/util/rbtree.h
+ * @file src/lib/util/rb.h
*
* @copyright 2016 The FreeRADIUS server project
*/
-RCSIDH(rbtree_h, "$Id$")
+RCSIDH(fr_rb_h, "$Id$")
#ifdef __cplusplus
extern "C" {
#include <stdbool.h>
#include <stdint.h>
-/* rbtree.c */
-typedef struct rbtree_s rbtree_t;
+/* rb.c */
+typedef struct fr_rb_s fr_rb_tree_t;
/* Red-Black tree description */
typedef enum {
void *data; //!< data stored in node
};
-#define RBTREE_FLAG_NONE (0)
-#define RBTREE_FLAG_REPLACE (1 << 0)
-#define RBTREE_FLAG_LOCK (1 << 1)
+#define RB_FLAG_NONE (0)
+#define RB_FLAG_REPLACE (1 << 0)
+#define RB_FLAG_LOCK (1 << 1)
/** Creates a red black that verifies elements are of a specific talloc type
*
* - A new rbtree on success.
* - NULL on failure.
*/
-#define rbtree_talloc_alloc(_ctx, _type, _field, _cmp, _node_free, _flags) \
+#define fr_rb_tree_talloc_alloc(_ctx, _type, _field, _cmp, _node_free, _flags) \
_Generic((((_type *)0)->_field), \
- fr_rb_node_t: _rbtree_alloc(_ctx, offsetof(_type, _field), #_type, _cmp, _node_free, _flags) \
+ fr_rb_node_t: _fr_rb_alloc(_ctx, offsetof(_type, _field), #_type, _cmp, _node_free, _flags) \
)
/** Creates a red black tree
* - A new rbtree on success.
* - NULL on failure.
*/
-#define rbtree_alloc(_ctx, _type, _field, _cmp, _node_free, _flags) \
+#define fr_rb_alloc(_ctx, _type, _field, _cmp, _node_free, _flags) \
_Generic((((_type *)0)->_field), \
- fr_rb_node_t: _rbtree_alloc(_ctx, offsetof(_type, _field), NULL, _cmp, _node_free, _flags) \
+ fr_rb_node_t: _fr_rb_alloc(_ctx, offsetof(_type, _field), NULL, _cmp, _node_free, _flags) \
)
-rbtree_t *_rbtree_alloc(TALLOC_CTX *ctx, size_t offset, char const *type,
+fr_rb_tree_t *_fr_rb_alloc(TALLOC_CTX *ctx, size_t offset, char const *type,
fr_cmp_t compare, fr_free_t node_free, int flags) CC_HINT(warn_unused_result);
-void rbtree_unlock(rbtree_t *tree) CC_HINT(nonnull);
+void fr_rb_unlock(fr_rb_tree_t *tree) CC_HINT(nonnull);
-void rbtree_node_talloc_free(void *data) CC_HINT(nonnull);
+void fr_rb_node_talloc_free(void *data) CC_HINT(nonnull);
-bool rbtree_insert(rbtree_t *tree, void const *data) CC_HINT(nonnull);
+bool fr_rb_insert(fr_rb_tree_t *tree, void const *data) CC_HINT(nonnull);
-bool rbtree_delete(rbtree_t *tree, void const *data) CC_HINT(nonnull);
+bool fr_rb_delete(fr_rb_tree_t *tree, void const *data) CC_HINT(nonnull);
/** @hidecallergraph */
-void *rbtree_find(rbtree_t *tree, void const *data) CC_HINT(nonnull);
+void *fr_rb_find(fr_rb_tree_t *tree, void const *data) CC_HINT(nonnull);
-uint64_t rbtree_num_elements(rbtree_t *tree) CC_HINT(nonnull);
+uint64_t fr_rb_num_elements(fr_rb_tree_t *tree) CC_HINT(nonnull);
/** Given a Node, return the data
*/
-static inline void *rbtree_node_to_data(UNUSED rbtree_t *tree, fr_rb_node_t *node)
+static inline void *fr_rb_node_to_data(UNUSED fr_rb_tree_t *tree, fr_rb_node_t *node)
{
if (!node) return NULL;
/** Iterator structure for in-order traversal of an rbtree
*/
typedef struct {
- rbtree_t *tree; //!< Tree being iterated over.
- fr_rb_node_t *node; ///< current node--set to NULL (not NIL) by rbtree_iter_delete()
- fr_rb_node_t *next; ///< if non-NULL, next node cached by rbtree_iter_delete()
-} fr_rb_tree_iter_inorder_t;
+ fr_rb_tree_t *tree; //!< Tree being iterated over.
+ fr_rb_node_t *node; ///< current node--set to NULL (not NIL) by fr_rb_iter_delete()
+ fr_rb_node_t *next; ///< if non-NULL, next node cached by fr_rb_iter_delete()
+} fr_rb_iter_inorder_t;
-void *rbtree_iter_init_inorder(fr_rb_tree_iter_inorder_t *iter, rbtree_t *tree) CC_HINT(nonnull);
+void *fr_rb_iter_init_inorder(fr_rb_iter_inorder_t *iter, fr_rb_tree_t *tree) CC_HINT(nonnull);
-void *rbtree_iter_next_inorder(fr_rb_tree_iter_inorder_t *iter) CC_HINT(nonnull);
+void *fr_rb_iter_next_inorder(fr_rb_iter_inorder_t *iter) CC_HINT(nonnull);
-void rbtree_iter_delete_inorder(fr_rb_tree_iter_inorder_t *iter) CC_HINT(nonnull);
+void fr_rb_iter_delete_inorder(fr_rb_iter_inorder_t *iter) CC_HINT(nonnull);
/** Iterator structure for pre-order traversal of an rbtree
*/
typedef struct {
- rbtree_t *tree; //!< Tree being iterated over.
+ fr_rb_tree_t *tree; //!< Tree being iterated over.
fr_rb_node_t *node; ///< current node
-} fr_rb_tree_iter_preorder_t;
+} fr_rb_iter_preorder_t;
-void *rbtree_iter_init_preorder(fr_rb_tree_iter_preorder_t *iter, rbtree_t *tree) CC_HINT(nonnull);
+void *fr_rb_iter_init_preorder(fr_rb_iter_preorder_t *iter, fr_rb_tree_t *tree) CC_HINT(nonnull);
-void *rbtree_iter_next_preorder(fr_rb_tree_iter_preorder_t *iter) CC_HINT(nonnull);
+void *fr_rb_iter_next_preorder(fr_rb_iter_preorder_t *iter) CC_HINT(nonnull);
/** Iterator structure for post-order traversal of an rbtree
*/
typedef struct {
- rbtree_t *tree; //!< Tree being iterated over.
+ fr_rb_tree_t *tree; //!< Tree being iterated over.
fr_rb_node_t *node; ///< current node
-} fr_rb_tree_iter_postorder_t;
+} fr_rb_iter_postorder_t;
-void *rbtree_iter_init_postorder(fr_rb_tree_iter_postorder_t *iter, rbtree_t *tree) CC_HINT(nonnull);
+void *fr_rb_iter_init_postorder(fr_rb_iter_postorder_t *iter, fr_rb_tree_t *tree) CC_HINT(nonnull);
-void *rbtree_iter_next_postorder(fr_rb_tree_iter_postorder_t *iter) CC_HINT(nonnull);
+void *fr_rb_iter_next_postorder(fr_rb_iter_postorder_t *iter) CC_HINT(nonnull);
/** Explicitly unlock the tree
*
* @note Must be called if iterating over the tree ends early.
*
- * @param[in] iter previously initialised with #rbtree_iter_init
+ * @param[in] iter previously initialised with #fr_rb_iter_init
*/
-#define rbtree_iter_done(_iter) \
+#define fr_rb_iter_done(_iter) \
(_Generic((_iter), \
- fr_rb_tree_iter_inorder_t * : rbtree_unlock(((fr_rb_tree_iter_inorder_t *)(_iter))->tree), \
- fr_rb_tree_iter_preorder_t * : rbtree_unlock(((fr_rb_tree_iter_preorder_t *)(_iter))->tree), \
- fr_rb_tree_iter_postorder_t * : rbtree_unlock(((fr_rb_tree_iter_postorder_t *)(_iter))->tree) \
+ fr_rb_iter_inorder_t * : fr_rb_unlock(((fr_rb_iter_inorder_t *)(_iter))->tree), \
+ fr_rb_iter_preorder_t * : fr_rb_unlock(((fr_rb_iter_preorder_t *)(_iter))->tree), \
+ fr_rb_iter_postorder_t * : fr_rb_unlock(((fr_rb_iter_postorder_t *)(_iter))->tree) \
))
-int rbtree_flatten_inorder(TALLOC_CTX *ctx, void **out[], rbtree_t *tree);
+int fr_rb_flatten_inorder(TALLOC_CTX *ctx, void **out[], fr_rb_tree_t *tree);
-int rbtree_flatten_preorder(TALLOC_CTX *ctx, void **out[], rbtree_t *tree);
+int fr_rb_flatten_preorder(TALLOC_CTX *ctx, void **out[], fr_rb_tree_t *tree);
-int rbtree_flatten_postorder(TALLOC_CTX *ctx, void **out[], rbtree_t *tree);
+int fr_rb_flatten_postorder(TALLOC_CTX *ctx, void **out[], fr_rb_tree_t *tree);
#ifdef __cplusplus
}
#endif
/** Tests for rbtrees
*
- * @file src/lib/util/rbtree_tests.c
+ * @file src/lib/util/fr_rb_tree_tests.c
*
* @copyright 2021 Arran Cudbard-Bell <a.cudbardb@freeradius.org>
*/
#include <freeradius-devel/util/rand.h>
#include <stdlib.h>
-#include "rbtree.c"
+#include "rb.c"
#define MAXSIZE 128
typedef struct {
uint32_t num;
fr_rb_node_t node;
-} fr_rb_test_node_t;
+} fr_rb_tree_test_node_t;
-static int8_t fr_rb_test_cmp(void const *one, void const *two)
+static int8_t fr_rb_tree_test_cmp(void const *one, void const *two)
{
- fr_rb_test_node_t const *a = one, *b = two;
+ fr_rb_tree_test_node_t const *a = one, *b = two;
return CMP(a->num, b->num);
}
static int fr_rb_qsort_cmp(void const *one, void const *two)
{
- fr_rb_test_node_t const *a = one, *b = two;
+ fr_rb_tree_test_node_t const *a = one, *b = two;
return CMP(a->num, b->num);
}
-static void test_rbtree_iter_inorder(void)
+static void test_fr_rb_iter_inorder(void)
{
- rbtree_t *t;
- fr_rb_test_node_t sorted[MAXSIZE];
- fr_rb_test_node_t *p;
+ fr_rb_tree_t *t;
+ fr_rb_tree_test_node_t sorted[MAXSIZE];
+ fr_rb_tree_test_node_t *p;
size_t n, i;
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
TEST_CASE("in-order iterator");
- t = rbtree_alloc(NULL, fr_rb_test_node_t, node, fr_rb_test_cmp, NULL, RBTREE_FLAG_LOCK);
+ t = fr_rb_alloc(NULL, fr_rb_tree_test_node_t, node, fr_rb_tree_test_cmp, NULL, RB_FLAG_LOCK);
TEST_CHECK(t != NULL);
n = (fr_rand() % MAXSIZE) + 1;
* with random numbers.
*/
for (i = 0; i < n; i++) {
- p = talloc(t, fr_rb_test_node_t);
+ p = talloc(t, fr_rb_tree_test_node_t);
p->num = fr_rand();
sorted[i].num = p->num;
- rbtree_insert(t, p);
+ fr_rb_insert(t, p);
}
- qsort(sorted, n, sizeof(fr_rb_test_node_t), fr_rb_qsort_cmp);
+ qsort(sorted, n, sizeof(fr_rb_tree_test_node_t), fr_rb_qsort_cmp);
- for (p = rbtree_iter_init_inorder(&iter, t), i = 0;
+ for (p = fr_rb_iter_init_inorder(&iter, t), i = 0;
p;
- p = rbtree_iter_next_inorder(&iter), i++) {
+ p = fr_rb_iter_next_inorder(&iter), i++) {
TEST_MSG("Checking sorted[%zu] s = %u vs n = %u", i, sorted[i].num, p->num);
TEST_CHECK(sorted[i].num == p->num);
TEST_CHECK(pthread_mutex_trylock(&t->mutex) != 0); /* Lock still held */
static uint32_t pre_output[] = {15, 3, 0, 4, 256, 49, 144, 8192, 4096, 25194};
static uint32_t post_output[] = {0, 4, 3, 144, 49, 4096, 25194, 8192, 256, 15};
-static void test_rbtree_iter_preorder(void)
+static void test_fr_rb_iter_preorder(void)
{
- rbtree_t *t;
- fr_rb_test_node_t *p;
+ fr_rb_tree_t *t;
+ fr_rb_tree_test_node_t *p;
size_t i;
- fr_rb_tree_iter_preorder_t iter;
+ fr_rb_iter_preorder_t iter;
TEST_CASE("pre-order iterator");
/*
* Build a tree from pre_post_input.
*/
- t = rbtree_alloc(NULL, fr_rb_test_node_t, node, fr_rb_test_cmp, NULL, RBTREE_FLAG_LOCK);
+ t = fr_rb_alloc(NULL, fr_rb_tree_test_node_t, node, fr_rb_tree_test_cmp, NULL, RB_FLAG_LOCK);
TEST_CHECK(t != NULL);
for (i = 0; i < sizeof(pre_post_input) / sizeof(uint32_t); i++) {
- p = talloc(t, fr_rb_test_node_t);
+ p = talloc(t, fr_rb_tree_test_node_t);
p->num = pre_post_input[i];
- rbtree_insert(t, p);
+ fr_rb_insert(t, p);
}
- for (p = rbtree_iter_init_preorder(&iter, t), i = 0;
+ for (p = fr_rb_iter_init_preorder(&iter, t), i = 0;
p;
- p = rbtree_iter_next_preorder(&iter), i++) {
+ p = fr_rb_iter_next_preorder(&iter), i++) {
TEST_MSG("Checking pre_output[%zu] = %u vs n = %u", i, pre_output[i], p->num);
TEST_CHECK(pre_output[i] == p->num);
TEST_CHECK(pthread_mutex_trylock(&t->mutex) != 0); /* Lock still held */
talloc_free(t);
}
-static void test_rbtree_iter_postorder(void)
+static void test_fr_rb_iter_postorder(void)
{
- rbtree_t *t;
- fr_rb_test_node_t *p;
+ fr_rb_tree_t *t;
+ fr_rb_tree_test_node_t *p;
size_t i;
- fr_rb_tree_iter_postorder_t iter;
+ fr_rb_iter_postorder_t iter;
TEST_CASE("post-order iterator");
/*
* Build a tree from pre_post_input.
*/
- t = rbtree_alloc(NULL, fr_rb_test_node_t, node, fr_rb_test_cmp, NULL, RBTREE_FLAG_LOCK);
+ t = fr_rb_alloc(NULL, fr_rb_tree_test_node_t, node, fr_rb_tree_test_cmp, NULL, RB_FLAG_LOCK);
TEST_CHECK(t != NULL);
for (i = 0; i < sizeof(pre_post_input) / sizeof(uint32_t); i++) {
- p = talloc(t, fr_rb_test_node_t);
+ p = talloc(t, fr_rb_tree_test_node_t);
p->num = pre_post_input[i];
- rbtree_insert(t, p);
+ fr_rb_insert(t, p);
}
- for (p = rbtree_iter_init_postorder(&iter, t), i = 0;
+ for (p = fr_rb_iter_init_postorder(&iter, t), i = 0;
p;
- p = rbtree_iter_next_postorder(&iter), i++) {
+ p = fr_rb_iter_next_postorder(&iter), i++) {
TEST_MSG("Checking post_output[%zu] s = %u vs n = %u", i, post_output[i], p->num);
TEST_CHECK(post_output[i] == p->num);
TEST_CHECK(pthread_mutex_trylock(&t->mutex) != 0); /* Lock still held */
}
/*
- * primality test used in rbtree_delete_iter() test.
+ * primality test used in fr_rb_delete_iter() test.
*/
static bool is_prime(uint32_t n)
{
static uint32_t non_primes[] = { 1, 4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22, 24, 25, 26, 27, 28,
30, 32, 33, 34, 35, 36, 38, 39, 40, 42, 44, 45, 46, 48, 49, 50};
-static void test_rbtree_iter_delete(void)
+static void test_fr_rb_iter_delete(void)
{
- rbtree_t *t;
+ fr_rb_tree_t *t;
size_t i;
- fr_rb_test_node_t *p;
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_tree_test_node_t *p;
+ fr_rb_iter_inorder_t iter;
- t = rbtree_alloc(NULL, fr_rb_test_node_t, node, fr_rb_test_cmp, NULL, RBTREE_FLAG_LOCK);
+ t = fr_rb_alloc(NULL, fr_rb_tree_test_node_t, node, fr_rb_tree_test_cmp, NULL, RB_FLAG_LOCK);
TEST_CHECK(t != NULL);
/*
* with integers from 1 to 50.
*/
for (i = 1; i <= 50; i++) {
- p = talloc(t, fr_rb_test_node_t);
+ p = talloc(t, fr_rb_tree_test_node_t);
p->num = i;
- rbtree_insert(t, p);
+ fr_rb_insert(t, p);
}
/*
* Remove the primes.
*/
- for (p = rbtree_iter_init_inorder(&iter, t);
+ for (p = fr_rb_iter_init_inorder(&iter, t);
p;
- p = rbtree_iter_next_inorder(&iter)) {
- if (is_prime(p->num)) rbtree_iter_delete_inorder(&iter);
+ p = fr_rb_iter_next_inorder(&iter)) {
+ if (is_prime(p->num)) fr_rb_iter_delete_inorder(&iter);
}
/*
* Check that all the non-primes are still there.
*/
- for (p = rbtree_iter_init_inorder(&iter, t), i = 0;
+ for (p = fr_rb_iter_init_inorder(&iter, t), i = 0;
p;
- p = rbtree_iter_next_inorder(&iter), i++) {
+ p = fr_rb_iter_next_inorder(&iter), i++) {
TEST_MSG("Checking non_primes[%zu] = %u vs p->num = %u", i, non_primes[i], p->num);
TEST_CHECK(non_primes[i] == p->num);
TEST_CHECK(pthread_mutex_trylock(&t->mutex) != 0); /* Lock still held */
talloc_free(t);
}
-static void test_rbtree_iter_done(void)
+static void test_fr_rb_iter_done(void)
{
- rbtree_t *t;
+ fr_rb_tree_t *t;
size_t i;
- fr_rb_test_node_t *p;
- fr_rb_tree_iter_inorder_t iter_in;
+ fr_rb_tree_test_node_t *p;
+ fr_rb_iter_inorder_t iter_in;
- t = rbtree_alloc(NULL, fr_rb_test_node_t, node, fr_rb_test_cmp, NULL, RBTREE_FLAG_LOCK);
+ t = fr_rb_alloc(NULL, fr_rb_tree_test_node_t, node, fr_rb_tree_test_cmp, NULL, RB_FLAG_LOCK);
TEST_CHECK(t != NULL);
/*
* with integers from 0 to 19.
*/
for (i = 0; i < 20; i++) {
- p = talloc(t, fr_rb_test_node_t);
+ p = talloc(t, fr_rb_tree_test_node_t);
p->num = i;
- rbtree_insert(t, p);
+ fr_rb_insert(t, p);
}
/*
* Iterate inorder and get out early.
*/
- for (p = rbtree_iter_init_inorder(&iter_in, t), i = 0;
+ for (p = fr_rb_iter_init_inorder(&iter_in, t), i = 0;
p;
- p = rbtree_iter_next_inorder(&iter_in), i++) {
+ p = fr_rb_iter_next_inorder(&iter_in), i++) {
if (i > 10) {
- rbtree_iter_done(&iter_in);
+ fr_rb_iter_done(&iter_in);
break;
}
TEST_CHECK(pthread_mutex_trylock(&t->mutex) != 0); /* Lock still held */
TEST_LIST = {
- { "rbtree_iter_inorder", test_rbtree_iter_inorder },
- { "rbtree_iter_preorder", test_rbtree_iter_preorder },
- { "rbtree_iter_postorder", test_rbtree_iter_postorder },
- { "rbtree_iter_delete", test_rbtree_iter_delete },
- { "rbtree_iter_done", test_rbtree_iter_done },
+ { "fr_rb_iter_inorder", test_fr_rb_iter_inorder },
+ { "fr_rb_iter_preorder", test_fr_rb_iter_preorder },
+ { "fr_rb_iter_postorder", test_fr_rb_iter_postorder },
+ { "fr_rb_iter_delete", test_fr_rb_iter_delete },
+ { "fr_rb_iter_done", test_fr_rb_iter_done },
{ NULL }
};
-TARGET := rbtree_tests
-SOURCES := rbtree_tests.c
+TARGET := rb_tests
+SOURCES := rb_tests.c
TGT_PREREQS += libfreeradius-util.a
uint8_t secret[BFD_MAX_SECRET_LENGTH];
size_t secret_len;
- rbtree_t *session_tree;
+ fr_rb_tree_t *session_tree;
} bfd_socket_t;
static fr_dict_t const *dict_bfd;
fr_ipaddr_to_sockaddr(&session->remote_sockaddr, &session->salen,
ipaddr, port);
- if (!rbtree_insert(sock->session_tree, session)) {
+ if (!fr_rb_insert(sock->session_tree, session)) {
ERROR("FAILED creating new session!");
talloc_free(session);
return NULL;
session->pthread_id = pthread_self();
} else {
if (!bfd_pthread_create(session)) {
- rbtree_delete(sock->session_tree, session);
+ fr_rb_delete(sock->session_tree, session);
talloc_free(session);
return NULL;
}
fr_ipaddr_from_sockaddr(&my_session.socket.inet.dst_ipaddr,
&my_session.socket.inet.dst_port, &src, sizeof_src);
- session = rbtree_find(sock->session_tree, &my_session);
+ session = fr_rb_find(sock->session_tree, &my_session);
if (!session) {
DEBUG("BFD unknown peer");
return 0;
my_session.socket.inet.dst_ipaddr = ipaddr;
my_session.socket.inet.dst_port = port;
- if (rbtree_find(sock->session_tree, &my_session) != NULL) {
+ if (fr_rb_find(sock->session_tree, &my_session) != NULL) {
cf_log_err(ci, "Peers must have unique IP addresses");
return -1;
}
}
}
- sock->session_tree = rbtree_talloc_alloc(sock, bfd_state_t, node, bfd_session_cmp, bfd_session_free, 0);
+ sock->session_tree = fr_rb_tree_talloc_alloc(sock, bfd_state_t, node, bfd_session_cmp, bfd_session_free, 0);
if (!sock->session_tree) {
ERROR("Failed creating session tree!");
return -1;
int ret = 0;
fr_ldap_rcode_t rcode;
sync_state_t find = { .msgid = -1 }, *sync = NULL;
- rbtree_t *tree;
+ fr_rb_tree_t *tree;
- tree = talloc_get_type_abort(conn->uctx, rbtree_t);
+ tree = talloc_get_type_abort(conn->uctx, fr_rb_tree_t);
fr_assert(conn);
if (!sync || (sync->msgid != msgid)) {
find.msgid = msgid;
- sync = rbtree_find(tree, &find);
+ sync = fr_rb_find(tree, &find);
if (!sync) {
WARN("Ignoring msgid %i, doesn't match any outstanding syncs",
find.msgid);
{
fr_ldap_connection_t *conn = talloc_get_type_abort(sync->conn, fr_ldap_connection_t); /* check for premature free */
- rbtree_t *tree = talloc_get_type_abort(conn->uctx, rbtree_t);
+ fr_rb_tree_t *tree = talloc_get_type_abort(conn->uctx, fr_rb_tree_t);
sync_state_t find = { .msgid = sync->msgid };
fr_assert(sync->conn->handle);
* Tell the remote server to stop sending results
*/
ldap_abandon_ext(sync->conn->handle, sync->msgid, NULL, NULL);
- rbtree_delete(tree, &find);
+ fr_rb_delete(tree, &find);
return 0;
}
void sync_state_destroy(fr_ldap_connection_t *conn, int msgid)
{
sync_state_t find, *sync;
- rbtree_t *tree;
+ fr_rb_tree_t *tree;
if (!conn->uctx) return;
- tree = talloc_get_type_abort(conn->uctx, rbtree_t);
+ tree = talloc_get_type_abort(conn->uctx, fr_rb_tree_t);
find.msgid = msgid;
- sync = rbtree_find(tree, &find);
+ sync = fr_rb_find(tree, &find);
talloc_free(sync); /* Will inform the server */
}
sync_config_t const *sync_state_config_get(fr_ldap_connection_t *conn, int msgid)
{
sync_state_t find, *sync;
- rbtree_t *tree;
+ fr_rb_tree_t *tree;
if (!conn->uctx) return NULL;
- tree = talloc_get_type_abort(conn->uctx, rbtree_t);
+ tree = talloc_get_type_abort(conn->uctx, fr_rb_tree_t);
find.msgid = msgid;
- sync = rbtree_find(tree, &find);
+ sync = fr_rb_find(tree, &find);
return sync->config;
}
int ret;
int mode;
sync_state_t *sync;
- rbtree_t *tree;
+ fr_rb_tree_t *tree;
fr_assert(conn);
fr_assert(config);
* these are specific to the connection.
*/
if (!conn->uctx) {
- MEM(tree = rbtree_talloc_alloc(conn, sync_state_t, node, _sync_cmp, NULL, RBTREE_FLAG_NONE));
+ MEM(tree = fr_rb_tree_talloc_alloc(conn, sync_state_t, node, _sync_cmp, NULL, RB_FLAG_NONE));
conn->uctx = tree;
} else {
- tree = talloc_get_type_abort(conn->uctx, rbtree_t);
+ tree = talloc_get_type_abort(conn->uctx, fr_rb_tree_t);
}
/*
return -1;
}
- if (!rbtree_insert(tree, sync)) {
+ if (!fr_rb_insert(tree, sync)) {
ERROR("Duplicate sync (msgid %i)", sync->msgid);
return -1;
}
#include "../../rlm_cache.h"
typedef struct {
- rbtree_t *cache; //!< Tree for looking up cache keys.
+ fr_rb_tree_t *cache; //!< Tree for looking up cache keys.
fr_heap_t *heap; //!< For managing entry expiry.
pthread_mutex_t mutex; //!< Protect the tree from multiple readers/writers.
-} rlm_cache_rbtree_t;
+} rlm_cache_rb_t;
typedef struct {
rlm_cache_entry_t fields; //!< Entry data.
fr_rb_node_t node; //!< Entry used for lookups.
int32_t heap_id; //!< Offset used for expiry heap.
-} rlm_cache_rbtree_entry_t;
+} rlm_cache_rb_entry_t;
/** Compare two entries by key
*
*/
static int mod_detach(void *instance)
{
- rlm_cache_rbtree_t *driver = talloc_get_type_abort(instance, rlm_cache_rbtree_t);
+ rlm_cache_rb_t *driver = talloc_get_type_abort(instance, rlm_cache_rb_t);
if (driver->cache) {
- fr_rb_tree_iter_inorder_t iter;
+ fr_rb_iter_inorder_t iter;
void *data;
- for (data = rbtree_iter_init_inorder(&iter, driver->cache);
+ for (data = fr_rb_iter_init_inorder(&iter, driver->cache);
data;
- data = rbtree_iter_next_inorder(&iter)) {
+ data = fr_rb_iter_next_inorder(&iter)) {
talloc_free(data);
- rbtree_iter_delete_inorder(&iter);
+ fr_rb_iter_delete_inorder(&iter);
}
talloc_free(driver->cache);
}
*/
static int mod_instantiate(void *instance, UNUSED CONF_SECTION *conf)
{
- rlm_cache_rbtree_t *driver = talloc_get_type_abort(instance, rlm_cache_rbtree_t);
+ rlm_cache_rb_t *driver = talloc_get_type_abort(instance, rlm_cache_rb_t);
/*
* The cache.
*/
- driver->cache = rbtree_talloc_alloc(NULL, rlm_cache_rbtree_entry_t, node, cache_entry_cmp, NULL, 0);
+ driver->cache = fr_rb_tree_talloc_alloc(NULL, rlm_cache_rb_entry_t, node, cache_entry_cmp, NULL, 0);
if (!driver->cache) {
ERROR("Failed to create cache");
return -1;
/*
* The heap of entries to expire.
*/
- driver->heap = fr_heap_talloc_alloc(driver, cache_heap_cmp, rlm_cache_rbtree_entry_t, heap_id);
+ driver->heap = fr_heap_talloc_alloc(driver, cache_heap_cmp, rlm_cache_rb_entry_t, heap_id);
if (!driver->heap) {
ERROR("Failed to create heap for the cache");
return -1;
static rlm_cache_entry_t *cache_entry_alloc(UNUSED rlm_cache_config_t const *config, UNUSED void *instance,
request_t *request)
{
- rlm_cache_rbtree_entry_t *c;
+ rlm_cache_rb_entry_t *c;
- c = talloc_zero(NULL, rlm_cache_rbtree_entry_t);
+ c = talloc_zero(NULL, rlm_cache_rb_entry_t);
if (!c) {
RERROR("Failed allocating cache entry");
return NULL;
UNUSED rlm_cache_config_t const *config, void *instance,
request_t *request, UNUSED void *handle, uint8_t const *key, size_t key_len)
{
- rlm_cache_rbtree_t *driver = talloc_get_type_abort(instance, rlm_cache_rbtree_t);
+ rlm_cache_rb_t *driver = talloc_get_type_abort(instance, rlm_cache_rb_t);
rlm_cache_entry_t *c;
c = fr_heap_peek(driver->heap);
if (c && (c->expires < fr_time_to_unix_time(request->packet->timestamp))) {
fr_heap_extract(driver->heap, c);
- rbtree_delete(driver->cache, c);
+ fr_rb_delete(driver->cache, c);
talloc_free(c);
}
/*
* Is there an entry for this key?
*/
- c = rbtree_find(driver->cache, &(rlm_cache_entry_t){ .key = key, .key_len = key_len });
+ c = fr_rb_find(driver->cache, &(rlm_cache_entry_t){ .key = key, .key_len = key_len });
if (!c) {
*out = NULL;
return CACHE_MISS;
request_t *request, UNUSED void *handle,
uint8_t const *key, size_t key_len)
{
- rlm_cache_rbtree_t *driver = talloc_get_type_abort(instance, rlm_cache_rbtree_t);
+ rlm_cache_rb_t *driver = talloc_get_type_abort(instance, rlm_cache_rb_t);
rlm_cache_entry_t *c;
if (!request) return CACHE_ERROR;
- c = rbtree_find(driver->cache, &(rlm_cache_entry_t){ .key = key, .key_len = key_len });
+ c = fr_rb_find(driver->cache, &(rlm_cache_entry_t){ .key = key, .key_len = key_len });
if (!c) return CACHE_MISS;
fr_heap_extract(driver->heap, c);
- rbtree_delete(driver->cache, c);
+ fr_rb_delete(driver->cache, c);
talloc_free(c);
return CACHE_OK;
{
cache_status_t status;
- rlm_cache_rbtree_t *driver = talloc_get_type_abort(instance, rlm_cache_rbtree_t);
+ rlm_cache_rb_t *driver = talloc_get_type_abort(instance, rlm_cache_rb_t);
fr_assert(handle == request);
/*
* Allow overwriting
*/
- if (!rbtree_insert(driver->cache, c)) {
+ if (!fr_rb_insert(driver->cache, c)) {
status = cache_entry_expire(config, instance, request, handle, c->key, c->key_len);
if ((status != CACHE_OK) && !fr_cond_assert(0)) return CACHE_ERROR;
- if (!rbtree_insert(driver->cache, c)) {
+ if (!fr_rb_insert(driver->cache, c)) {
RERROR("Failed adding entry");
return CACHE_ERROR;
}
if (fr_heap_insert(driver->heap, UNCONST(rlm_cache_entry_t *, c)) < 0) {
- rbtree_delete(driver->cache, c);
+ fr_rb_delete(driver->cache, c);
RERROR("Failed adding entry to expiry heap");
return CACHE_ERROR;
request_t *request, UNUSED void *handle,
rlm_cache_entry_t *c)
{
- rlm_cache_rbtree_t *driver = talloc_get_type_abort(instance, rlm_cache_rbtree_t);
+ rlm_cache_rb_t *driver = talloc_get_type_abort(instance, rlm_cache_rb_t);
#ifdef NDEBUG
if (!request) return CACHE_ERROR;
}
if (fr_heap_insert(driver->heap, c) < 0) {
- rbtree_delete(driver->cache, c); /* make sure we don't leak entries... */
+ fr_rb_delete(driver->cache, c); /* make sure we don't leak entries... */
RERROR("Failed updating entry TTL. Entry was forcefully expired");
return CACHE_ERROR;
}
static uint64_t cache_entry_count(UNUSED rlm_cache_config_t const *config, void *instance,
request_t *request, UNUSED void *handle)
{
- rlm_cache_rbtree_t *driver = talloc_get_type_abort(instance, rlm_cache_rbtree_t);
+ rlm_cache_rb_t *driver = talloc_get_type_abort(instance, rlm_cache_rb_t);
if (!request) return CACHE_ERROR;
- return rbtree_num_elements(driver->cache);
+ return fr_rb_num_elements(driver->cache);
}
/** Lock the rbtree
static int cache_acquire(void **handle, UNUSED rlm_cache_config_t const *config, void *instance,
request_t *request)
{
- rlm_cache_rbtree_t *driver = talloc_get_type_abort(instance, rlm_cache_rbtree_t);
+ rlm_cache_rb_t *driver = talloc_get_type_abort(instance, rlm_cache_rb_t);
pthread_mutex_lock(&driver->mutex);
static void cache_release(UNUSED rlm_cache_config_t const *config, void *instance, request_t *request,
UNUSED rlm_cache_handle_t *handle)
{
- rlm_cache_rbtree_t *driver = talloc_get_type_abort(instance, rlm_cache_rbtree_t);
+ rlm_cache_rb_t *driver = talloc_get_type_abort(instance, rlm_cache_rb_t);
pthread_mutex_unlock(&driver->mutex);
.magic = RLM_MODULE_INIT,
.instantiate = mod_instantiate,
.detach = mod_detach,
- .inst_size = sizeof(rlm_cache_rbtree_t),
+ .inst_size = sizeof(rlm_cache_rb_t),
.alloc = cache_entry_alloc,
.find = cache_entry_find,
char const **field_names;
int *field_offsets; /* field X from the file maps to array entry Y here */
fr_type_t *field_types;
- rbtree_t *tree;
+ fr_rb_tree_t *tree;
fr_trie_t *trie;
tmpl_t *key;
memcpy(&my_e.key, &key, sizeof(key)); /* const issues */
- return rbtree_find(inst->tree, &my_e);
+ return fr_rb_find(inst->tree, &my_e);
}
static bool insert_entry(CONF_SECTION *conf, rlm_csv_t *inst, rlm_csv_entry_t *e, int lineno)
goto fail;
}
- } else if (!rbtree_insert(inst->tree, e)) {
+ } else if (!fr_rb_insert(inst->tree, e)) {
cf_log_err(conf, "Failed inserting entry for file %s line %d: duplicate entry",
inst->filename, lineno);
goto fail;
(inst->key_data_type == FR_TYPE_IPV6_ADDR) || (inst->key_data_type == FR_TYPE_IPV6_PREFIX)) {
MEM(inst->trie = fr_trie_alloc(inst));
} else {
- MEM(inst->tree = rbtree_talloc_alloc(inst, rlm_csv_entry_t, node, csv_entry_cmp, NULL, 0));
+ MEM(inst->tree = fr_rb_tree_talloc_alloc(inst, rlm_csv_entry_t, node, csv_entry_cmp, NULL, 0));
}
if ((*inst->index_field_name == ',') || (*inst->index_field_name == *inst->delimiter)) {
tmpl_t *key;
char const *filename;
- rbtree_t *common;
+ fr_rb_tree_t *common;
/* autz */
char const *usersfile;
- rbtree_t *users;
+ fr_rb_tree_t *users;
/* authenticate */
char const *auth_usersfile;
- rbtree_t *auth_users;
+ fr_rb_tree_t *auth_users;
/* preacct */
char const *acct_usersfile;
- rbtree_t *acct_users;
+ fr_rb_tree_t *acct_users;
/* post-authenticate */
char const *postauth_usersfile;
- rbtree_t *postauth_users;
+ fr_rb_tree_t *postauth_users;
} rlm_files_t;
static fr_dict_t const *dict_freeradius;
return CMP(ret, 0);
}
-static int getusersfile(TALLOC_CTX *ctx, char const *filename, rbtree_t **ptree)
+static int getusersfile(TALLOC_CTX *ctx, char const *filename, fr_rb_tree_t **ptree)
{
int rcode;
PAIR_LIST_LIST users;
PAIR_LIST_LIST search_list; // Temporary list header used for matching in rbtree
PAIR_LIST *entry, *next;
PAIR_LIST_LIST *user_list, *default_list;
- rbtree_t *tree;
+ fr_rb_tree_t *tree;
if (!filename) {
*ptree = NULL;
}
}
- tree = rbtree_alloc(ctx, PAIR_LIST_LIST, node, pairlist_cmp, NULL, RBTREE_FLAG_NONE);
+ tree = fr_rb_alloc(ctx, PAIR_LIST_LIST, node, pairlist_cmp, NULL, RB_FLAG_NONE);
if (!tree) {
pairlist_free(&users);
return -1;
/*
* Insert the DEFAULT list into the tree.
*/
- if (!rbtree_insert(tree, default_list)) {
+ if (!fr_rb_insert(tree, default_list)) {
error:
pairlist_free(&users);
talloc_free(next);
* for a matching list header already in the tree.
*/
search_list.name = entry->name;
- user_list = rbtree_find(tree, &search_list);
+ user_list = fr_rb_find(tree, &search_list);
if (!user_list) {
user_list = talloc_zero(ctx, PAIR_LIST_LIST);
pairlist_list_init(user_list);
/*
* Insert the new list header.
*/
- if (!rbtree_insert(tree, user_list)) goto error;
+ if (!fr_rb_insert(tree, user_list)) goto error;
}
/*
* Append the entry to the user list
* Common code called by everything below.
*/
static unlang_action_t file_common(rlm_rcode_t *p_result, rlm_files_t const *inst,
- request_t *request, char const *filename, rbtree_t *tree)
+ request_t *request, char const *filename, fr_rb_tree_t *tree)
{
char const *name;
PAIR_LIST_LIST const *user_list, *default_list;
if (!tree) RETURN_MODULE_NOOP;
my_list.name = name;
- user_list = rbtree_find(tree, &my_list);
+ user_list = fr_rb_find(tree, &my_list);
user_pl = (user_list) ? fr_dlist_head(&user_list->head) : NULL;
my_list.name = "DEFAULT";
- default_list = rbtree_find(tree, &my_list);
+ default_list = fr_rb_find(tree, &my_list);
default_pl = (default_list) ? fr_dlist_head(&default_list->head) : NULL;
/*
typedef struct {
rlm_icmp_t *inst;
- rbtree_t *tree;
+ fr_rb_tree_t *tree;
int fd;
fr_event_list_t *el;
MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_BOOL, NULL, false));
vb->vb_bool = echo->replied;
- (void) rbtree_delete(thread->t->tree, echo);
+ (void) fr_rb_delete(thread->t->tree, echo);
talloc_free(echo);
fr_dcursor_insert(out, vb);
RDEBUG2("Cancelling ICMP request for %pV (counter=%d)", echo->ip, echo->counter);
- (void) rbtree_delete(thread->t->tree, echo);
+ (void) fr_rb_delete(thread->t->tree, echo);
talloc_free(echo);
}
* This insert will never fail, because of the unique
* counter above.
*/
- if (!rbtree_insert(thread->t->tree, echo)) {
+ if (!fr_rb_insert(thread->t->tree, echo)) {
RPEDEBUG("Failed inserting IP into tracking table");
talloc_free(echo);
return XLAT_ACTION_FAIL;
if (unlang_xlat_event_timeout_add(request, _xlat_icmp_timeout, echo, fr_time() + inst->timeout) < 0) {
RPEDEBUG("Failed adding timeout");
- (void) rbtree_delete(thread->t->tree, echo);
+ (void) fr_rb_delete(thread->t->tree, echo);
talloc_free(echo);
return XLAT_ACTION_FAIL;
}
rcode = sendto(thread->t->fd, &icmp, sizeof(icmp), 0, (struct sockaddr *) &dst, salen);
if (rcode < 0) {
REDEBUG("Failed sending ICMP request to %pV: %s", echo->ip, fr_syserror(errno));
- (void) rbtree_delete(thread->t->tree, echo);
+ (void) fr_rb_delete(thread->t->tree, echo);
talloc_free(echo);
return XLAT_ACTION_FAIL;
}
if ((size_t) rcode < sizeof(icmp)) {
REDEBUG("Failed sending entire ICMP packet");
- (void) rbtree_delete(thread->t->tree, echo);
+ (void) fr_rb_delete(thread->t->tree, echo);
talloc_free(echo);
return XLAT_ACTION_FAIL;
}
/*
* Ignore packets if we haven't sent any requests.
*/
- if (rbtree_num_elements(t->tree) == 0) {
+ if (fr_rb_num_elements(t->tree) == 0) {
return;
}
* Look up the packet by the fields which determine *our* ICMP packets.
*/
my_echo.counter = icmp->counter;
- echo = rbtree_find(t->tree, &my_echo);
+ echo = fr_rb_find(t->tree, &my_echo);
if (!echo) {
DEBUG("Can't find packet counter=%d in tree", icmp->counter);
return;
}
- (void) rbtree_delete(t->tree, echo);
+ (void) fr_rb_delete(t->tree, echo);
/*
* We have a reply!
rlm_icmp_thread_t *t = talloc_get_type_abort(thread, rlm_icmp_thread_t);
fr_ipaddr_t ipaddr, *src;
- MEM(t->tree = rbtree_alloc(t, rlm_icmp_echo_t, node, echo_cmp, NULL, RBTREE_FLAG_NONE));
+ MEM(t->tree = fr_rb_alloc(t, rlm_icmp_echo_t, node, echo_cmp, NULL, RB_FLAG_NONE));
t->inst = inst;
t->el = el;
RCSID("$Id$")
#include <freeradius-devel/server/base.h>
-#include <freeradius-devel/util/rbtree.h>
+#include <freeradius-devel/util/rb.h>
#include <freeradius-devel/io/application.h>
#include <freeradius-devel/util/dlist.h>
#include <freeradius-devel/util/debug.h>
* If needed, allocate a subtree.
*/
if (!tt->subtree[tt->next_id]) {
- MEM(tt->subtree[tt->next_id] = rbtree_talloc_alloc(tt, radius_track_entry_t, node,
- te_cmp, NULL, RBTREE_FLAG_NONE));
+ MEM(tt->subtree[tt->next_id] = fr_rb_tree_talloc_alloc(tt, radius_track_entry_t, node,
+ te_cmp, NULL, RB_FLAG_NONE));
}
/*
* This entry MAY be in a subtree. If so, delete
* it.
*/
- if (tt->subtree[te->id]) (void) rbtree_delete(tt->subtree[te->id], te);
+ if (tt->subtree[te->id]) (void) fr_rb_delete(tt->subtree[te->id], te);
goto done;
}
* Delete it from the tracking subtree.
*/
fr_assert(tt->subtree[te->id] != NULL);
- (void) rbtree_delete(tt->subtree[te->id], te);
+ (void) fr_rb_delete(tt->subtree[te->id], te);
/*
* Try to free memory if the system gets idle. If the
/*
* The authentication vector may have changed.
*/
- if (tt->subtree[te->id]) (void) rbtree_delete(tt->subtree[te->id], te);
+ if (tt->subtree[te->id]) (void) fr_rb_delete(tt->subtree[te->id], te);
memcpy(te->vector, vector, sizeof(te->vector));
* array. That way if the server responds with
* Original-Request-Authenticator, we can easily find it.
*/
- if (!rbtree_insert(tt->subtree[te->id], te)) return -1;
+ if (!fr_rb_insert(tt->subtree[te->id], te)) return -1;
return 0;
}
*/
memcpy(&my_te.vector, vector, sizeof(my_te.vector));
- te = rbtree_find(tt->subtree[packet_id], &my_te);
+ te = fr_rb_find(tt->subtree[packet_id], &my_te);
/*
* Not found, the packet MAY have been allocated in the
radius_track_entry_t id[UINT8_MAX + 1]; //!< which ID was used
- rbtree_t *subtree[UINT8_MAX + 1]; //!< for Original-Request-Authenticator
+ fr_rb_tree_t *subtree[UINT8_MAX + 1]; //!< for Original-Request-Authenticator
#ifndef NDEBUG
uint64_t operation; //!< Incremented each alloc and de-alloc
/*
* If we have a DoS attack, discard new sessions.
*/
- if (rbtree_num_elements(inst->session_tree) >= inst->max_sessions) {
+ if (fr_rb_num_elements(inst->session_tree) >= inst->max_sessions) {
securid_sessionlist_clean_expired(inst, request, session->timestamp);
goto done;
}
MEM(pair_update_reply(&state, attr_state) >= 0);
fr_pair_value_memdup(state, session->state, sizeof(session->state), true);
- status = rbtree_insert(inst->session_tree, session);
+ status = fr_rb_insert(inst->session_tree, session);
if (status) {
/* tree insert SUCCESS */
/* insert the session to the linked list of sessions */
/************ private functions *************/
static SECURID_SESSION *securid_sessionlist_delete(rlm_securid_t *inst, SECURID_SESSION *session)
{
- fr_assert(rbtree_find(inst->session_tree, session) == session);
+ fr_assert(fr_rb_find(inst->session_tree, session) == session);
/*
* Delete old session from the tree.
*/
- rbtree_delete(inst->session_tree, node);
+ fr_rb_delete(inst->session_tree, node);
/*
* And unsplice it from the linked list.
uint64_t num_sessions;
SECURID_SESSION *session;
- num_sessions = rbtree_num_elements(inst->session_tree);
+ num_sessions = fr_rb_num_elements(inst->session_tree);
RDEBUG2("There are %d sessions in the tree\n",num_sessions);
/*
*/
while((session = inst->session_head)) {
if ((timestamp - session->timestamp) > inst->timer_limit) {
- rbtree_delete(inst->session_tree, session);
+ fr_rb_delete(inst->session_tree, session);
/*
* session == inst->session_head
* Lookup sessions in the tree. We don't free them in
* the tree, as that's taken care of elsewhere...
*/
- inst->session_tree = rbtree_talloc_alloc(NULL, SECURID_SESSION, node, securid_session_cmp, NULL, 0);
+ inst->session_tree = fr_rb_tree_talloc_alloc(NULL, SECURID_SESSION, node, securid_session_cmp, NULL, 0);
if (!inst->session_tree) {
ERROR("Cannot initialize session tree");
return -1;
*/
typedef struct {
pthread_mutex_t session_mutex;
- rbtree_t* session_tree;
+ fr_rb_tree_t* session_tree;
SECURID_SESSION *session_head, *session_tail;
unsigned int last_session_id;
#include "libosmo-m3ua/include/sctp_m3ua.h"
static uint32_t last_txn_id = 0; //!< Global transaction ID
-static rbtree_t *txn_tree = NULL; //!< Global transaction tree... Should really be per module.
+static fr_rb_tree_t *txn_tree = NULL; //!< Global transaction tree... Should really be per module.
static uint32_t txn_tree_inst = 0;
/** Compare rounds of a transaction
/*
* Remove the outstanding transaction
*/
- if (!rbtree_delete(txn_tree, txn)) ERROR("Transaction removed before timeout");
+ if (!fr_rb_delete(txn_tree, txn)) ERROR("Transaction removed before timeout");
txn->response.type = SIGTRAN_RESPONSE_FAIL;
return -1;
}
- if (rbtree_num_elements(txn_tree) > UINT8_MAX) {
+ if (fr_rb_num_elements(txn_tree) > UINT8_MAX) {
ERROR("Too many outstanding requests, dropping the request");
return -1;
txn->ctx.invoke_id &= 0x7f; /* Invoke ID is 7bits */
DEBUG2("Sending request with OTID %u Invoke ID %u", txn->ctx.otid, txn->ctx.invoke_id);
- if (!rbtree_insert(txn_tree, txn)) {
+ if (!fr_rb_insert(txn_tree, txn)) {
ERROR("Failed inserting transaction, maybe at txn limit?");
msgb_free(msg);
/*
* Lookup the transaction in our tree of outstanding transactions
*/
- found = rbtree_find(txn_tree, &find);
+ found = fr_rb_find(txn_tree, &find);
if (!found) {
/*
* Not an error, could be a retransmission
ERROR("No outstanding transaction with DTID %u Invoke ID %u", find.ctx.otid, find.ctx.invoke_id);
return 0;
}
- if (!rbtree_delete(txn_tree, found)) { /* Remove the outstanding transaction */
+ if (!fr_rb_delete(txn_tree, found)) { /* Remove the outstanding transaction */
ERROR("Failed removing transaction");
fr_assert(0);
}
return 0;
}
- txn_tree = rbtree_talloc_alloc(NULL, sigtran_transaction_t, node, sigtran_txn_cmp, false, 0);
+ txn_tree = fr_rb_tree_talloc_alloc(NULL, sigtran_transaction_t, node, sigtran_txn_cmp, false, 0);
if (!txn_tree) return -1;
txn_tree_inst++;
fr_time_t last_manage; //!< when we deleted old things
- rbtree_t *src; //!< stats by source
- rbtree_t *dst; //!< stats by destination
+ fr_rb_tree_t *src; //!< stats by source
+ fr_rb_tree_t *dst; //!< stats by destination
uint64_t stats[FR_RADIUS_CODE_MAX];
} rlm_stats_thread_t;
{
rlm_stats_data_t *stats;
rlm_stats_thread_t *other;
- rbtree_t **tree;
+ fr_rb_tree_t **tree;
uint64_t local_stats[FR_RADIUS_CODE_MAX];
- tree = (rbtree_t **) (((uint8_t *) t) + tree_offset);
+ tree = (fr_rb_tree_t **) (((uint8_t *) t) + tree_offset);
/*
* Bootstrap with my statistics, where we don't need a
* lock.
*/
- stats = rbtree_find(*tree, mydata);
+ stats = fr_rb_find(*tree, mydata);
if (!stats) {
memset(final_stats, 0, sizeof(uint64_t) * FR_RADIUS_CODE_MAX);
} else {
if (other == t) continue;
- tree = (rbtree_t **) (((uint8_t *) other) + tree_offset);
- stats = rbtree_find(*tree, mydata);
+ tree = (fr_rb_tree_t **) (((uint8_t *) other) + tree_offset);
+ stats = fr_rb_find(*tree, mydata);
if (!stats) {
continue;
}
* Update source statistics
*/
mydata.ipaddr = request->packet->socket.inet.src_ipaddr;
- stats = rbtree_find(t->src, &mydata);
+ stats = fr_rb_find(t->src, &mydata);
if (!stats) {
MEM(stats = talloc_zero(t, rlm_stats_data_t));
stats->ipaddr = request->packet->socket.inet.src_ipaddr;
stats->created = request->async->recv_time;
- (void) rbtree_insert(t->src, stats);
+ (void) fr_rb_insert(t->src, stats);
}
stats->last_packet = request->async->recv_time;
* Update destination statistics
*/
mydata.ipaddr = request->packet->socket.inet.dst_ipaddr;
- stats = rbtree_find(t->dst, &mydata);
+ stats = fr_rb_find(t->dst, &mydata);
if (!stats) {
MEM(stats = talloc_zero(t, rlm_stats_data_t));
stats->ipaddr = request->packet->socket.inet.dst_ipaddr;
stats->created = request->async->recv_time;
- (void) rbtree_insert(t->dst, stats);
+ (void) fr_rb_insert(t->dst, stats);
}
stats->last_packet = request->async->recv_time;
t->inst = inst;
- t->src = rbtree_talloc_alloc(t, rlm_stats_data_t, src_node, data_cmp, NULL, RBTREE_FLAG_LOCK);
- t->dst = rbtree_talloc_alloc(t, rlm_stats_data_t, dst_node, data_cmp, NULL, RBTREE_FLAG_LOCK);
+ t->src = fr_rb_tree_talloc_alloc(t, rlm_stats_data_t, src_node, data_cmp, NULL, RB_FLAG_LOCK);
+ t->dst = fr_rb_tree_talloc_alloc(t, rlm_stats_data_t, dst_node, data_cmp, NULL, RB_FLAG_LOCK);
pthread_mutex_lock(&inst->mutex);
fr_dlist_insert_head(&inst->list, t);
* that should be managed.
*/
struct fr_packet_list_s {
- rbtree_t *tree;
+ fr_rb_tree_t *tree;
int alloc_id;
uint32_t num_outgoing;
pl = talloc_zero(NULL, fr_packet_list_t);
if (!pl) return NULL;
- pl->tree = rbtree_alloc(pl, fr_radius_packet_t, node, fr_packet_cmp, NULL, 0); /* elements not talloc safe */
+ pl->tree = fr_rb_alloc(pl, fr_radius_packet_t, node, fr_packet_cmp, NULL, 0); /* elements not talloc safe */
if (!pl->tree) {
fr_packet_list_free(pl);
return NULL;
{
if (!pl || !request) return 0;
- return rbtree_insert(pl->tree, request);
+ return fr_rb_insert(pl->tree, request);
}
fr_radius_packet_t *fr_packet_list_find(fr_packet_list_t *pl, fr_radius_packet_t *request)
{
if (!pl || !request) return 0;
- return rbtree_find(pl->tree, request);
+ return fr_rb_find(pl->tree, request);
}
my_request.id = reply->id;
request = &my_request;
- return rbtree_find(pl->tree, request);
+ return fr_rb_find(pl->tree, request);
}
{
if (!pl || !request) return false;
- return rbtree_delete(pl->tree, request);
+ return fr_rb_delete(pl->tree, request);
}
uint32_t fr_packet_list_num_elements(fr_packet_list_t *pl)
{
if (!pl) return 0;
- return rbtree_num_elements(pl->tree);
+ return fr_rb_num_elements(pl->tree);
}
if (!pl) return 0;
- num_elements = rbtree_num_elements(pl->tree);
+ num_elements = fr_rb_num_elements(pl->tree);
if (num_elements < pl->num_outgoing) return 0; /* panic! */
return num_elements - pl->num_outgoing;
#include <stdio.h>
#include <netdb.h>
-#include <freeradius-devel/util/rbtree.c>
+#include <freeradius-devel/util/rb.c>
#include <freeradius-devel/util/rand.h>
typedef struct {
uint32_t num;
fr_rb_node_t node;
-} fr_rb_test_node_t;
+} fr_rb_tree_test_node_t;
static int8_t comp(void const *a, void const *b)
{
- fr_rb_test_node_t const *our_a = a, *our_b = b;
+ fr_rb_tree_test_node_t const *our_a = a, *our_b = b;
return CMP(our_a->num, our_b->num);
}
#if 0
static int print_cb(void *i, UNUSED void *uctx)
{
- fprintf(stderr, "%i\n", (fr_rb_test_node_t *)i->num);
+ fprintf(stderr, "%i\n", (fr_rb_tree_test_node_t *)i->num);
return 0;
}
#endif
#define MAXSIZE 1024
static int cb_stored = 0;
-static fr_rb_test_node_t rvals[MAXSIZE];
+static fr_rb_tree_test_node_t rvals[MAXSIZE];
static uint32_t mask;
static int filter_cb(void *i, void *uctx)
{
- if ((((fr_rb_test_node_t *)i)->num & mask) == (((fr_rb_test_node_t *)uctx)->num & mask)) {
+ if ((((fr_rb_tree_test_node_t *)i)->num & mask) == (((fr_rb_tree_test_node_t *)uctx)->num & mask)) {
return 2;
}
return 0;
* Returns the count of BLACK nodes from root to child leaves, or a
* negative number indicating which RED-BLACK rule was broken.
*/
-static int rbcount(rbtree_t *t)
+static int rbcount(fr_rb_tree_t *t)
{
fr_rb_node_t *n;
int count, count_expect;
int main(UNUSED int argc, UNUSED char *argv[])
{
- rbtree_t *t;
+ fr_rb_tree_t *t;
int i, j;
- fr_rb_test_node_t thresh = {};
+ fr_rb_tree_test_node_t thresh = {};
int n, rep;
- fr_rb_test_node_t vals[MAXSIZE];
- fr_rb_tree_iter_inorder_t iter;
- fr_rb_test_node_t const *node;
+ fr_rb_tree_test_node_t vals[MAXSIZE];
+ fr_rb_iter_inorder_t iter;
+ fr_rb_tree_test_node_t const *node;
memset(&vals, 0, sizeof(vals));
fprintf(stderr, "filter = %x mask = %x n = %i\n", thresh.num, mask, n);
- t = rbtree_alloc(NULL, fr_rb_test_node_t, node, comp, freenode, RBTREE_FLAG_LOCK);
+ t = fr_rb_alloc(NULL, fr_rb_tree_test_node_t, node, comp, freenode, RB_FLAG_LOCK);
for (i = 0; i < n; i++) {
- fr_rb_test_node_t *p;
+ fr_rb_tree_test_node_t *p;
- p = talloc(t, fr_rb_test_node_t); /* Do not use talloc_zero, rbcode should initialise fr_rb_node_t */
+ p = talloc(t, fr_rb_tree_test_node_t); /* Do not use talloc_zero, rbcode should initialise fr_rb_node_t */
p->num = fr_rand();
vals[i].num = p->num;
- rbtree_insert(t, p);
+ fr_rb_insert(t, p);
}
i = rbcount(t);
fprintf(stderr,"After insert rbcount is %i\n", i);
if (i < 0) return i;
- qsort(vals, n, sizeof(fr_rb_test_node_t), qsort_comp);
+ qsort(vals, n, sizeof(fr_rb_tree_test_node_t), qsort_comp);
/*
* For testing deletebydata instead
for (i = 0; i < n; i++) {
- if (filter_cb(&vals[i], &thresh) == 2) rbtree_delete(t, &vals[i]);
+ if (filter_cb(&vals[i], &thresh) == 2) fr_rb_delete(t, &vals[i]);
}
*
*/
- for (node = rbtree_iter_init_inorder(&iter, t);
+ for (node = fr_rb_iter_init_inorder(&iter, t);
node;
- node = rbtree_iter_next_inorder(&iter)) {
- if ((node->num & mask) == (thresh.num & mask)) rbtree_iter_delete_inorder(&iter);
+ node = fr_rb_iter_next_inorder(&iter)) {
+ if ((node->num & mask) == (thresh.num & mask)) fr_rb_iter_delete_inorder(&iter);
}
i = rbcount(t);
fprintf(stderr,"After delete rbcount is %i\n", i);
if (i < 0) return i;
cb_stored = 0;
- for (node = rbtree_iter_init_inorder(&iter, t);
+ for (node = fr_rb_iter_init_inorder(&iter, t);
node;
- node = rbtree_iter_next_inorder(&iter)) {
+ node = fr_rb_iter_next_inorder(&iter)) {
rvals[cb_stored++].num = node->num;
}
projects / thirdparty / freeradius-server.git / commitdiff
