From: Arran Cudbard-Bell Date: Thu, 15 Apr 2021 14:59:32 +0000 (-0500) Subject: Add the `fr` prefix drop the `tree` component X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=b8d97cca6cec7f6a6d57ec7fa661b289e25e3671;p=thirdparty%2Ffreeradius-server.git Add the `fr` prefix drop the `tree` component --- diff --git a/src/bin/radclient.c b/src/bin/radclient.c index 76d580b8394..39acda865a3 100644 --- a/src/bin/radclient.c +++ b/src/bin/radclient.c @@ -1126,7 +1126,7 @@ int main(int argc, char **argv) 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 @@ -1152,7 +1152,7 @@ int main(int argc, char **argv) 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"); @@ -1219,7 +1219,7 @@ int main(int argc, char **argv) files->packets = optarg; files->filters = NULL; } - rbtree_insert(filename_tree, (void *) files); + fr_rb_insert(filename_tree, (void *) files); } break; @@ -1403,7 +1403,7 @@ int main(int argc, char **argv) /* * 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); @@ -1415,12 +1415,12 @@ int main(int argc, char **argv) * 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); diff --git a/src/bin/radsniff.c b/src/bin/radsniff.c index c99e70380c4..e291a7893e5 100644 --- a/src/bin/radsniff.c +++ b/src/bin/radsniff.c @@ -50,8 +50,8 @@ static rs_t *conf; 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; @@ -978,12 +978,12 @@ static int _request_free(rs_request_t *request) * 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); } @@ -1391,7 +1391,7 @@ static void rs_packet_process(uint64_t count, rs_event_t *event, struct pcap_pkt { /* 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 @@ -1609,8 +1609,8 @@ static void rs_packet_process(uint64_t count, rs_event_t *event, struct pcap_pkt 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 @@ -1624,7 +1624,7 @@ static void rs_packet_process(uint64_t count, rs_event_t *event, struct pcap_pkt * 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)) { /* @@ -1674,7 +1674,7 @@ static void rs_packet_process(uint64_t count, rs_event_t *event, struct pcap_pkt /* 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 */ @@ -1715,7 +1715,7 @@ static void rs_packet_process(uint64_t count, rs_event_t *event, struct pcap_pkt 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; } @@ -1735,7 +1735,7 @@ static void rs_packet_process(uint64_t count, rs_event_t *event, struct pcap_pkt 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; } @@ -2658,7 +2658,7 @@ int main(int argc, char *argv[]) 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; @@ -2716,7 +2716,7 @@ int main(int argc, char *argv[]) /* * 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; diff --git a/src/lib/io/master.c b/src/lib/io/master.c index 0ed98764184..c749049eef1 100644 --- a/src/lib/io/master.c +++ b/src/lib/io/master.c @@ -98,7 +98,7 @@ struct fr_io_client_s { 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 @@ -158,9 +158,9 @@ static int track_free(fr_io_track_t *track) 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); } @@ -531,8 +531,8 @@ static fr_io_connection_t *fr_io_connection_alloc(fr_io_instance_t const *inst, * #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)); } /* @@ -898,7 +898,7 @@ static fr_io_track_t *fr_io_track_add(fr_io_client_t *client, /* * 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); @@ -967,7 +967,7 @@ static fr_io_track_t *fr_io_track_add(fr_io_client_t *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); @@ -978,7 +978,7 @@ static fr_io_track_t *fr_io_track_add(fr_io_client_t *client, } do_insert: - if (!rbtree_insert(client->table, track)) { + if (!fr_rb_insert(client->table, track)) { fr_assert(0); } @@ -1463,8 +1463,8 @@ do_read: */ 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)); } /* diff --git a/src/lib/io/network.c b/src/lib/io/network.c index 9bfd572ac7c..4ca6882f167 100644 --- a/src/lib/io/network.c +++ b/src/lib/io/network.c @@ -32,7 +32,7 @@ RCSID("$Id$") #include #include #include -#include +#include #include #include #include @@ -131,8 +131,8 @@ struct fr_network_s { 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 @@ -244,7 +244,7 @@ int fr_network_socket_delete(fr_network_t *nr, fr_listen_t *li) { 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); @@ -297,7 +297,7 @@ void fr_network_listen_read(fr_network_t *nr, fr_listen_t *li) (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; /* @@ -394,14 +394,14 @@ static void fr_network_suspend(fr_network_t *nr) 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; @@ -413,14 +413,14 @@ static void fr_network_unsuspend(fr_network_t *nr) 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; @@ -1046,8 +1046,8 @@ static int _network_socket_free(fr_network_socket_t *s) 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); @@ -1143,8 +1143,8 @@ static void fr_network_listen_callback(void *ctx, void const *data, size_t data_ 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. @@ -1215,8 +1215,8 @@ static void fr_network_directory_callback(void *ctx, void const *data, size_t da 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); } @@ -1284,7 +1284,7 @@ static void fr_network_inject_callback(void *ctx, void const *data, size_t data_ 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; @@ -1344,7 +1344,7 @@ static void fr_network_post_event(UNUSED fr_event_list_t *el, UNUSED fr_time_t n * @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... @@ -1414,7 +1414,7 @@ int fr_network_destroy(fr_network_t *nr) 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]); @@ -1585,9 +1585,9 @@ fr_network_t *fr_network_create(TALLOC_CTX *ctx, fr_event_list_t *el, char const 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); @@ -1663,13 +1663,13 @@ fr_network_t *fr_network_create(TALLOC_CTX *ctx, fr_event_list_t *el, char const /* * 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; @@ -1744,7 +1744,7 @@ static int cmd_stats_self(FILE *fp, UNUSED FILE *fp_err, void *ctx, UNUSED fr_cm 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; } @@ -1752,14 +1752,14 @@ static int cmd_stats_self(FILE *fp, UNUSED FILE *fp_err, void *ctx, UNUSED fr_cm 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 { @@ -1774,7 +1774,7 @@ static int cmd_stats_socket(FILE *fp, FILE *fp_err, void *ctx, fr_cmd_info_t con 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; diff --git a/src/lib/io/schedule.c b/src/lib/io/schedule.c index b497b17c4cd..94bb0b3e790 100644 --- a/src/lib/io/schedule.c +++ b/src/lib/io/schedule.c @@ -30,7 +30,7 @@ RCSID("$Id$") #include #include -#include +#include #include #include diff --git a/src/lib/io/worker.c b/src/lib/io/worker.c index eda35da2c14..db1afa544e2 100644 --- a/src/lib/io/worker.c +++ b/src/lib/io/worker.c @@ -97,7 +97,7 @@ struct fr_worker_s { 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 @@ -745,7 +745,7 @@ nak: 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 @@ -812,7 +812,7 @@ nak: 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); @@ -951,7 +951,7 @@ static void _worker_request_done_external(request_t *request, UNUSED rlm_rcode_t * 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); } /* @@ -1205,9 +1205,9 @@ fr_worker_t *fr_worker_create(TALLOC_CTX *ctx, fr_event_list_t *el, char const * 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); @@ -1283,7 +1283,7 @@ nomem: 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; @@ -1479,7 +1479,7 @@ static void worker_verify(fr_worker_t *worker) (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; diff --git a/src/lib/redis/cluster.c b/src/lib/redis/cluster.c index d1006ac8b29..f3e682dda15 100644 --- a/src/lib/redis/cluster.c +++ b/src/lib/redis/cluster.c @@ -78,7 +78,7 @@ * - 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 @@ -99,7 +99,7 @@ * 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. @@ -256,7 +256,7 @@ struct fr_redis_cluster { //!< 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. @@ -551,14 +551,14 @@ do { \ 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; \ @@ -599,7 +599,7 @@ do { \ 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; @@ -651,7 +651,7 @@ do { \ */ 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; @@ -726,7 +726,7 @@ do { \ 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); @@ -751,7 +751,7 @@ do { \ /* * 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; @@ -1117,7 +1117,7 @@ static fr_redis_cluster_rcode_t cluster_redirect(fr_redis_cluster_node_t **out, * 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); @@ -1140,7 +1140,7 @@ static fr_redis_cluster_rcode_t cluster_redirect(fr_redis_cluster_node_t **out, 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; @@ -1298,12 +1298,12 @@ static int cluster_node_find_live(fr_redis_cluster_node_t **live_node, fr_redis_ 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; @@ -1313,9 +1313,9 @@ static int cluster_node_find_live(fr_redis_cluster_node_t **live_node, fr_redis_ 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 */ @@ -1568,7 +1568,7 @@ fr_redis_cluster_key_slot_t const *fr_redis_cluster_slot_by_key(fr_redis_cluster * 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); @@ -1706,7 +1706,7 @@ fr_redis_rcode_t fr_redis_cluster_state_init(fr_redis_cluster_state_t *state, fr 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; @@ -2028,7 +2028,7 @@ int fr_redis_cluster_pool_by_node_addr(fr_pool_t **pool, fr_redis_cluster_t *clu 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]; @@ -2055,14 +2055,14 @@ int fr_redis_cluster_pool_by_node_addr(fr_pool_t **pool, fr_redis_cluster_t *clu 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); @@ -2086,8 +2086,8 @@ int fr_redis_cluster_pool_by_node_addr(fr_pool_t **pool, fr_redis_cluster_t *clu 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; @@ -2106,9 +2106,9 @@ ssize_t fr_redis_cluster_node_addr_by_role(TALLOC_CTX *ctx, fr_socket_t *out[], 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; } @@ -2150,7 +2150,7 @@ static int _fr_redis_cluster_free(fr_redis_cluster_t *cluster) 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]; @@ -2158,9 +2158,9 @@ bool fr_redis_cluster_min_version(fr_redis_cluster_t *cluster, char const *min_v 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; @@ -2177,7 +2177,7 @@ bool fr_redis_cluster_min_version(fr_redis_cluster_t *cluster, char const *min_v 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; } } @@ -2314,7 +2314,7 @@ fr_redis_cluster_t *fr_redis_cluster_alloc(TALLOC_CTX *ctx, 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); @@ -2380,7 +2380,7 @@ fr_redis_cluster_t *fr_redis_cluster_alloc(TALLOC_CTX *ctx, 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; } @@ -2470,7 +2470,7 @@ fr_redis_cluster_t *fr_redis_cluster_alloc(TALLOC_CTX *ctx, /* * 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; diff --git a/src/lib/server/cf_file.c b/src/lib/server/cf_file.c index 81e3d5bab31..0e6c89b94f5 100644 --- a/src/lib/server/cf_file.c +++ b/src/lib/server/cf_file.c @@ -514,12 +514,12 @@ static int cf_file_open(CONF_SECTION *cs, char const *filename, bool from_dir, F { 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); /* @@ -535,7 +535,7 @@ static int cf_file_open(CONF_SECTION *cs, char const *filename, bool from_dir, F 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 @@ -585,7 +585,7 @@ static int cf_file_open(CONF_SECTION *cs, char const *filename, bool from_dir, F * * 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; @@ -607,11 +607,11 @@ bool cf_file_check(CONF_SECTION *cs, char const *filename, bool check_perms) { 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); @@ -692,7 +692,7 @@ bool cf_file_check(CONF_SECTION *cs, char const *filename, bool check_perms) /* * 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; } @@ -2295,7 +2295,7 @@ int cf_file_read(CONF_SECTION *cs, char const *filename) int i; char *p; CONF_PAIR *cp; - rbtree_t *tree; + fr_rb_tree_t *tree; cf_stack_t stack; cf_stack_frame_t *frame; @@ -2305,7 +2305,7 @@ int cf_file_read(CONF_SECTION *cs, char const *filename) 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); diff --git a/src/lib/server/cf_file.h b/src/lib/server/cf_file.h index 7d88cc3b05d..9cb52ad1731 100644 --- a/src/lib/server/cf_file.h +++ b/src/lib/server/cf_file.h @@ -30,7 +30,7 @@ RCSIDH(cf_file_h, "$Id$") #include -#include +#include #include #include #include diff --git a/src/lib/server/cf_parse.h b/src/lib/server/cf_parse.h index 432c976d8a2..2b9f5e01b09 100644 --- a/src/lib/server/cf_parse.h +++ b/src/lib/server/cf_parse.h @@ -31,7 +31,7 @@ RCSIDH(cf_parse_h, "$Id$") #include #include #include -#include +#include #include #ifdef __cplusplus diff --git a/src/lib/server/cf_priv.h b/src/lib/server/cf_priv.h index 113dfaf35db..06c059b9064 100644 --- a/src/lib/server/cf_priv.h +++ b/src/lib/server/cf_priv.h @@ -33,7 +33,7 @@ extern "C" { #include #include -#include +#include #include typedef enum conf_type { @@ -57,8 +57,8 @@ struct cf_item { 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. diff --git a/src/lib/server/cf_util.c b/src/lib/server/cf_util.c index 2ada2c5dba2..205c0e8f1d7 100644 --- a/src/lib/server/cf_util.c +++ b/src/lib/server/cf_util.c @@ -133,12 +133,12 @@ static CONF_ITEM *cf_find(CONF_ITEM const *parent, CONF_ITEM_TYPE type, char con /* * 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 @@ -370,13 +370,13 @@ void _cf_item_add(CONF_ITEM *parent, CONF_ITEM *child) /* * 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 */ } @@ -408,14 +408,14 @@ CONF_ITEM *_cf_item_remove(CONF_ITEM *parent, CONF_ITEM *child) 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; } @@ -427,12 +427,12 @@ CONF_ITEM *_cf_item_remove(CONF_ITEM *parent, CONF_ITEM *child) 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; } } @@ -1683,14 +1683,14 @@ void *_cf_data_remove(CONF_ITEM *parent, CONF_DATA const *cd) 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 */ @@ -1701,7 +1701,7 @@ int _cf_data_walk(CONF_ITEM *ci, char const *type, cf_walker_t cb, void *ctx) ret = cb(UNCONST(void *, cd->data), ctx); if (ret) { - rbtree_iter_done(&iter); + fr_rb_iter_done(&iter); break; } } @@ -2065,8 +2065,8 @@ void _cf_debug(CONF_ITEM const *ci) 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; @@ -2078,8 +2078,8 @@ void _cf_debug(CONF_ITEM const *ci) 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: diff --git a/src/lib/server/cf_util.h b/src/lib/server/cf_util.h index 6086a324f56..76cabb865bb 100644 --- a/src/lib/server/cf_util.h +++ b/src/lib/server/cf_util.h @@ -45,7 +45,7 @@ typedef struct cf_data CONF_DATA; //!< #CONF_ITEM used to associate arbitrary da #include #include -#include +#include #include #include #include diff --git a/src/lib/server/client.c b/src/lib/server/client.c index 39d30a5b708..b26b77d8131 100644 --- a/src/lib/server/client.c +++ b/src/lib/server/client.c @@ -56,7 +56,7 @@ struct rad_client_list { fr_trie_t *v4_tcp; fr_trie_t *v6_tcp; #else - rbtree_t *tree[129]; + fr_rb_tree_t *tree[129]; #endif }; @@ -287,14 +287,14 @@ bool client_add(RADCLIENT_LIST *clients, RADCLIENT *client) #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) { /* @@ -325,7 +325,7 @@ bool client_add(RADCLIENT_LIST *clients, RADCLIENT *client) 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; } @@ -363,7 +363,7 @@ void client_delete(RADCLIENT_LIST *clients, RADCLIENT *client) 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 } @@ -409,7 +409,7 @@ RADCLIENT *client_find(RADCLIENT_LIST const *clients, fr_ipaddr_t const *ipaddr, 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; } diff --git a/src/lib/server/dl_module.c b/src/lib/server/dl_module.c index 8d38896f7d6..d14a5a1b316 100644 --- a/src/lib/server/dl_module.c +++ b/src/lib/server/dl_module.c @@ -42,8 +42,8 @@ RCSID("$Id$") * 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; }; @@ -209,7 +209,7 @@ dl_module_inst_t const *dl_module_instance_by_data(void const *data) 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 @@ -293,7 +293,7 @@ static void dl_module_instance_data_alloc(dl_module_inst_t *dl_inst, dl_module_t * 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); } @@ -316,7 +316,7 @@ static int _dl_module_free(dl_module_t *dl_module) } 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; } @@ -372,7 +372,7 @@ dl_module_t const *dl_module(CONF_SECTION *conf, dl_module_t const *parent, char /* * 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); @@ -427,7 +427,7 @@ dl_module_t const *dl_module(CONF_SECTION *conf, dl_module_t const *parent, char /* * 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; @@ -465,7 +465,7 @@ static int _dl_module_instance_free(dl_module_inst_t *dl_inst) * 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 @@ -576,15 +576,15 @@ static int _dl_module_loader_free(dl_module_loader_t *dl_module_l) { 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); @@ -655,7 +655,7 @@ dl_module_loader_t *dl_module_loader_init(char const *lib_dir) } 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) { @@ -663,7 +663,7 @@ dl_module_loader_t *dl_module_loader_init(char const *lib_dir) 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) { diff --git a/src/lib/server/dl_module.h b/src/lib/server/dl_module.h index 66dd2edb3a7..6516dd4af83 100644 --- a/src/lib/server/dl_module.h +++ b/src/lib/server/dl_module.h @@ -33,7 +33,7 @@ RCSIDH(dl_module_h, "$Id$") #include #include -#include +#include #include #ifdef __cplusplus diff --git a/src/lib/server/listen.h b/src/lib/server/listen.h index 46ebbc8fed3..95e1b9a33ed 100644 --- a/src/lib/server/listen.h +++ b/src/lib/server/listen.h @@ -89,7 +89,7 @@ struct rad_listen { int count; bool dual; - rbtree_t *children; + fr_rb_tree_t *children; rad_listen_t *parent; bool nodup; diff --git a/src/lib/server/map_proc.c b/src/lib/server/map_proc.c index 9f4aed8d38e..c1fb819926c 100644 --- a/src/lib/server/map_proc.c +++ b/src/lib/server/map_proc.c @@ -30,7 +30,7 @@ RCSID("$Id$") #include #include -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 * @@ -63,10 +63,10 @@ static int _map_proc_talloc_free(map_proc_t *proc) 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; } @@ -92,7 +92,7 @@ map_proc_t *map_proc_find(char const *name) 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 @@ -117,8 +117,8 @@ int map_proc_register(void *mod_inst, char const *name, 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; @@ -134,7 +134,7 @@ int map_proc_register(void *mod_inst, char const *name, 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; } @@ -210,7 +210,7 @@ rlm_rcode_t map_proc(request_t *request, map_proc_inst_t const *inst, fr_value_b */ 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); diff --git a/src/lib/server/method.c b/src/lib/server/method.c index ca33a924802..18bc0796fac 100644 --- a/src/lib/server/method.c +++ b/src/lib/server/method.c @@ -143,7 +143,7 @@ module_method_set_t *module_method_alloc_set(TALLOC_CTX *ctx) 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; @@ -162,7 +162,7 @@ int module_method_insert(module_method_set_t *set, module_method_id_t id, module { 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)", @@ -175,7 +175,7 @@ int module_method_insert(module_method_set_t *set, module_method_id_t id, module 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; } @@ -198,7 +198,7 @@ module_method_t module_method_find(module_method_set_t *set, module_method_id_t { 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; diff --git a/src/lib/server/method.h b/src/lib/server/method.h index 86c1277f321..e367a8a5c15 100644 --- a/src/lib/server/method.h +++ b/src/lib/server/method.h @@ -44,7 +44,7 @@ RCSIDH(methods_h, "$Id$") #include -#include +#include /** Unique identifier for an abstract method * @@ -67,7 +67,7 @@ typedef struct { * */ 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. diff --git a/src/lib/server/module.c b/src/lib/server/module.c index 11e4f586a8f..7eb33e06a79 100644 --- a/src/lib/server/module.c +++ b/src/lib/server/module.c @@ -48,11 +48,11 @@ static _Thread_local module_thread_instance_t **module_thread_inst_array; /** 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 */ @@ -85,7 +85,7 @@ static int cmd_show_module_config(FILE *fp, UNUSED FILE *fp_err, void *ctx, UNUS 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; @@ -95,13 +95,13 @@ static int module_name_tab_expand(UNUSED TALLOC_CTX *talloc_ctx, UNUSED void *uc 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)) { @@ -116,12 +116,12 @@ static int module_name_tab_expand(UNUSED TALLOC_CTX *talloc_ctx, UNUSED void *uc 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); @@ -647,7 +647,7 @@ module_instance_t *module_by_name(module_instance_t const *parent, char const *a 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 @@ -1052,7 +1052,7 @@ module_instance_t *module_by_data(void const *data) { 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) }, }); @@ -1116,15 +1116,15 @@ void module_free(module_instance_t *mi) 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); } @@ -1135,10 +1135,10 @@ void modules_free(void) 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; @@ -1187,7 +1187,7 @@ static int _module_thread_inst_array_free(module_thread_instance_t **array) 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 @@ -1206,9 +1206,9 @@ int modules_thread_instantiate(TALLOC_CTX *ctx, fr_event_list_t *el) */ 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; @@ -1235,7 +1235,7 @@ int modules_thread_instantiate(TALLOC_CTX *ctx, fr_event_list_t *el) 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; } @@ -1332,15 +1332,15 @@ static int _module_instantiate(void *instance) 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; } } @@ -1428,8 +1428,8 @@ static int _module_instance_free(module_instance_t *mi) { 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 @@ -1529,7 +1529,7 @@ module_instance_t *module_bootstrap(module_instance_t const *parent, CONF_SECTIO /* * 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; /* @@ -1539,7 +1539,7 @@ module_instance_t *module_bootstrap(module_instance_t const *parent, CONF_SECTIO * 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; } diff --git a/src/lib/server/state.c b/src/lib/server/state.c index 0033a1a0597..44b1f88aba7 100644 --- a/src/lib/server/state.c +++ b/src/lib/server/state.c @@ -136,7 +136,7 @@ struct fr_state_tree_s { 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. @@ -241,7 +241,7 @@ fr_state_tree_t *fr_state_tree_init(TALLOC_CTX *ctx, fr_dict_attr_t const *da, b * 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; @@ -268,7 +268,7 @@ static void state_entry_unlink(fr_state_tree_t *state, fr_state_entry_t *entry) 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); } @@ -358,7 +358,7 @@ static fr_state_entry_t *state_entry_create(fr_state_tree_t *state, request_t *r 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 @@ -516,7 +516,7 @@ static fr_state_entry_t *state_entry_create(fr_state_tree_t *state, request_t *r */ *((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); @@ -566,7 +566,7 @@ static fr_state_entry_t *state_entry_find(fr_state_tree_t *state, fr_value_box_t */ 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); @@ -904,5 +904,5 @@ uint64_t fr_state_entries_timeout(fr_state_tree_t *state) */ uint64_t fr_state_entries_tracked(fr_state_tree_t *state) { - return rbtree_num_elements(state->tree); + return fr_rb_num_elements(state->tree); } diff --git a/src/lib/server/trigger.c b/src/lib/server/trigger.c index e978ecc419b..4b29c6092ac 100644 --- a/src/lib/server/trigger.c +++ b/src/lib/server/trigger.c @@ -38,7 +38,7 @@ RCSID("$Id$") */ 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 @@ -149,7 +149,7 @@ int trigger_exec_init(CONF_SECTION const *cs) 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)); @@ -346,13 +346,13 @@ int trigger_exec(unlang_interpret_t *intp, request_t *request, 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); diff --git a/src/lib/server/virtual_servers.c b/src/lib/server/virtual_servers.c index fe71807841f..fb498e71272 100644 --- a/src/lib/server/virtual_servers.c +++ b/src/lib/server/virtual_servers.c @@ -92,11 +92,11 @@ static fr_virtual_server_t **virtual_servers; */ 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); @@ -753,7 +753,7 @@ fr_listen_t *listen_find_any(fr_listen_t *li) { if (!listen_addr_root) return false; - return rbtree_find(listen_addr_root, li); + return fr_rb_find(listen_addr_root, li); } @@ -768,7 +768,7 @@ bool listen_record(fr_listen_t *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) @@ -810,7 +810,7 @@ static int process_instantiate(CONF_SECTION *server_cs, dl_module_inst_t *dl_ins 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); @@ -851,7 +851,7 @@ int virtual_servers_instantiate(void) 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)); @@ -1207,7 +1207,7 @@ static int8_t _virtual_namespace_cmp(void const *one, void const *two) 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 */ @@ -1217,17 +1217,17 @@ int virtual_namespace_register(char const *namespace, fr_dict_t const *dict, 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"); @@ -1236,7 +1236,7 @@ int virtual_namespace_register(char const *namespace, fr_dict_t const *dict, } } - if (!rbtree_insert(vns_tree, vns)) { + if (!fr_rb_insert(vns_tree, vns)) { ERROR("Failed inserting namespace into tree"); return -1; } @@ -1341,9 +1341,9 @@ int virtual_server_has_namespace(CONF_SECTION **out, 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; @@ -1358,9 +1358,9 @@ int virtual_servers_init(CONF_SECTION *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; @@ -1619,7 +1619,7 @@ int virtual_server_section_register(virtual_server_compile_t const *entry) 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 @@ -1649,7 +1649,7 @@ int virtual_server_section_register(virtual_server_compile_t const *entry) } #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; } @@ -1671,7 +1671,7 @@ virtual_server_method_t const *virtual_server_section_methods(char const *name1, * 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, @@ -1682,7 +1682,7 @@ virtual_server_method_t const *virtual_server_section_methods(char const *name1, /* * 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, diff --git a/src/lib/tls/engine.c b/src/lib/tls/engine.c index ca4b173fadd..73acb54b2e5 100644 --- a/src/lib/tls/engine.c +++ b/src/lib/tls/engine.c @@ -33,7 +33,7 @@ USES_APPLE_DEPRECATED_API /* OpenSSL API has been deprecated by Apple */ #include #include #include -#include +#include #include #include @@ -62,7 +62,7 @@ typedef struct { * 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 * @@ -251,7 +251,7 @@ int fr_tls_engine_init(ENGINE **e_out, 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"); @@ -260,7 +260,7 @@ int fr_tls_engine_init(ENGINE **e_out, } 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 ? " (" : "", @@ -436,7 +436,7 @@ int fr_tls_engine(ENGINE **e_out, char const *id, char const *instance, bool aut } - 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; @@ -456,7 +456,7 @@ void fr_tls_engine_load_builtin(void) /* * 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 */ diff --git a/src/lib/unlang/xlat_builtin.c b/src/lib/unlang/xlat_builtin.c index a2707ba691a..7c11483edb7 100644 --- a/src/lib/unlang/xlat_builtin.c +++ b/src/lib/unlang/xlat_builtin.c @@ -54,7 +54,7 @@ RCSID("$Id$") #include -static rbtree_t *xlat_root = NULL; +static fr_rb_tree_t *xlat_root = NULL; static char const hextab[] = "0123456789abcdef"; @@ -120,7 +120,7 @@ xlat_t *xlat_func_find(char const *in, ssize_t inlen) 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; @@ -128,7 +128,7 @@ xlat_t *xlat_func_find(char const *in, ssize_t inlen) 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 }); } @@ -141,8 +141,8 @@ static int _xlat_func_talloc_free(xlat_t *xlat) { 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; } @@ -194,7 +194,7 @@ xlat_t *xlat_register_legacy(void *mod_inst, char const *name, /* * 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); @@ -221,7 +221,7 @@ xlat_t *xlat_register_legacy(void *mod_inst, char const *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); @@ -256,7 +256,7 @@ xlat_t *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, bool /* * 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); @@ -292,7 +292,7 @@ xlat_t *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, bool 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; @@ -481,7 +481,7 @@ void xlat_unregister(char const *name) 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); @@ -493,15 +493,15 @@ void xlat_unregister(char const *name) 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); } } @@ -3075,7 +3075,7 @@ int xlat_init(void) /* * 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; @@ -3165,7 +3165,7 @@ do { \ */ 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; diff --git a/src/lib/unlang/xlat_inst.c b/src/lib/unlang/xlat_inst.c index 97bd77cb042..0c6753411ee 100644 --- a/src/lib/unlang/xlat_inst.c +++ b/src/lib/unlang/xlat_inst.c @@ -34,11 +34,11 @@ RCSID("$Id$") /** 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 * @@ -159,8 +159,8 @@ static int _xlat_inst_detach(xlat_inst_t *inst) * 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); @@ -302,7 +302,7 @@ static int _xlat_thread_instantiate(void *data, void *uctx) } } - rbtree_insert(xlat_thread_inst_tree, thread_inst); + fr_rb_insert(xlat_thread_inst_tree, thread_inst); return 0; } @@ -323,7 +323,7 @@ xlat_thread_inst_t *xlat_thread_instance_find(xlat_exp_t const *node) 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; @@ -343,25 +343,25 @@ xlat_thread_inst_t *xlat_thread_instance_find(xlat_exp_t const *node) */ 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; } } @@ -386,8 +386,8 @@ static int xlat_instantiate_init(void) { 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; @@ -399,19 +399,19 @@ static int xlat_instantiate_init(void) */ 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; } } @@ -442,7 +442,7 @@ int xlat_bootstrap_func(xlat_exp_t *node) 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; diff --git a/src/lib/util/all.mk b/src/lib/util/all.mk index e3d92e69a8d..9873efe4ce5 100644 --- a/src/lib/util/all.mk +++ b/src/lib/util/all.mk @@ -6,7 +6,7 @@ SUBMAKEFILES := \ libfreeradius-util.mk \ pair_legacy_tests.mk \ pair_tests.mk \ - rbtree_tests.mk \ + rb_tests.mk \ sbuff_tests.mk \ strerror_tests.mk diff --git a/src/lib/util/base.h b/src/lib/util/base.h index af177240618..0694fd7aa4a 100644 --- a/src/lib/util/base.h +++ b/src/lib/util/base.h @@ -58,7 +58,7 @@ RCSIDH(libradius_h, "$Id$") #include #include #include -#include +#include #include #include #include diff --git a/src/lib/util/dict.h b/src/lib/util/dict.h index c621dcdb06b..f5d68b42ad4 100644 --- a/src/lib/util/dict.h +++ b/src/lib/util/dict.h @@ -31,7 +31,7 @@ extern "C" { #include #include #include -#include +#include #include #include #include diff --git a/src/lib/util/dict_priv.h b/src/lib/util/dict_priv.h index dd0e23affb5..d6d68f2dd09 100644 --- a/src/lib/util/dict_priv.h +++ b/src/lib/util/dict_priv.h @@ -106,7 +106,7 @@ struct fr_dict { 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 { diff --git a/src/lib/util/dict_util.c b/src/lib/util/dict_util.c index ca164c94e18..dc6b32446c1 100644 --- a/src/lib/util/dict_util.c +++ b/src/lib/util/dict_util.c @@ -2770,7 +2770,7 @@ int dict_dependent_add(fr_dict_t *dict, char const *dependent) { 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; @@ -2787,7 +2787,7 @@ int dict_dependent_add(fr_dict_t *dict, char const *dependent) * a dictionary. */ new->dependent = talloc_typed_strdup(new, dependent); - rbtree_insert(dict->dependents, new); + fr_rb_insert(dict->dependents, new); new->count = 1; @@ -2809,7 +2809,7 @@ int dict_dependent_remove(fr_dict_t *dict, char const *dependent) { 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; @@ -2822,7 +2822,7 @@ int dict_dependent_remove(fr_dict_t *dict, char const *dependent) } if (--found->count == 0) { - rbtree_delete(dict->dependents, found); + fr_rb_delete(dict->dependents, found); talloc_free(found); return 0; } @@ -2839,7 +2839,7 @@ int dict_dependent_remove(fr_dict_t *dict, char const *dependent) */ 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) @@ -2857,14 +2857,14 @@ 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; @@ -2965,7 +2965,7 @@ fr_dict_t *dict_alloc(TALLOC_CTX *ctx) /* * 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. @@ -3453,7 +3453,7 @@ void fr_dict_global_ctx_debug(void) { 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) { @@ -3465,17 +3465,17 @@ void fr_dict_global_ctx_debug(void) 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); } } diff --git a/src/lib/util/dl.c b/src/lib/util/dl.c index ebd82fdd3c4..feca5ac48ff 100644 --- a/src/lib/util/dl.c +++ b/src/lib/util/dl.c @@ -99,7 +99,7 @@ struct dl_loader_s { 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. @@ -433,7 +433,7 @@ static int _dl_free(dl_t *dl) 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; } @@ -463,7 +463,7 @@ dl_t *dl_by_name(dl_loader_t *dl_loader, char const *name, void *uctx, bool uctx * 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; @@ -592,7 +592,7 @@ dl_t *dl_by_name(dl_loader_t *dl_loader, char const *name, void *uctx, bool uctx }; 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; @@ -635,17 +635,17 @@ static int _dl_loader_free(dl_loader_t *dl_loader) * 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)); @@ -795,7 +795,7 @@ dl_loader_t *dl_loader_init(TALLOC_CTX *ctx, void *uctx, bool uctx_free, bool de 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: diff --git a/src/lib/util/dl.h b/src/lib/util/dl.h index 0784bf633a2..aaefd911c79 100644 --- a/src/lib/util/dl.h +++ b/src/lib/util/dl.h @@ -31,7 +31,7 @@ RCSIDH(dl_h, "$Id$") # include #endif #include -#include +#include #include #include diff --git a/src/lib/util/event.c b/src/lib/util/event.c index a8cf42954c6..7cfe21e3eb7 100644 --- a/src/lib/util/event.c +++ b/src/lib/util/event.c @@ -33,7 +33,7 @@ RCSID("$Id$") #include #include #include -#include +#include #include #include #include @@ -347,7 +347,7 @@ typedef struct { */ 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 @@ -430,7 +430,7 @@ uint64_t fr_event_list_num_fds(fr_event_list_t *el) { 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 @@ -721,7 +721,7 @@ static int _event_fd_delete(fr_event_fd_t *ef) } } - rbtree_delete(el->fds, ef); + fr_rb_delete(el->fds, ef); ef->is_registered = false; } @@ -783,7 +783,7 @@ int _fr_event_fd_move(NDEBUG_LOCATION_ARGS /* * 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; @@ -829,7 +829,7 @@ int _fr_event_filter_update(NDEBUG_LOCATION_ARGS 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; @@ -925,7 +925,7 @@ int _fr_event_filter_insert(NDEBUG_LOCATION_ARGS } 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)); @@ -992,7 +992,7 @@ int _fr_event_filter_insert(NDEBUG_LOCATION_ARGS } ef->filter = filter; - rbtree_insert(el->fds, ef); + fr_rb_insert(el->fds, ef); ef->is_registered = true; /* @@ -1084,7 +1084,7 @@ int fr_event_fd_delete(fr_event_list_t *el, int fd, fr_event_filter_t filter) { 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; @@ -1122,7 +1122,7 @@ int fr_event_fd_armour(fr_event_list_t *el, int fd, fr_event_filter_t filter, ui { 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; @@ -1152,7 +1152,7 @@ int fr_event_fd_unarmour(fr_event_list_t *el, int fd, fr_event_filter_t filter, { 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; @@ -2281,7 +2281,7 @@ fr_event_list_t *fr_event_list_alloc(TALLOC_CTX *ctx, fr_event_status_cb_t statu 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; @@ -2338,7 +2338,7 @@ void fr_event_list_set_time_func(fr_event_list_t *el, fr_event_time_source_t fun */ 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 @@ -2389,7 +2389,7 @@ void fr_event_report(fr_event_list_t *el, fr_time_t now, void *uctx) 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; @@ -2402,7 +2402,7 @@ void fr_event_report(fr_event_list_t *el, fr_time_t now, void *uctx) } 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; } @@ -2420,14 +2420,14 @@ void fr_event_report(fr_event_list_t *el, fr_time_t now, void *uctx) 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++; } @@ -2445,7 +2445,7 @@ void fr_event_report(fr_event_list_t *el, fr_time_t now, void *uctx) 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; @@ -2458,9 +2458,9 @@ void fr_event_report(fr_event_list_t *el, fr_time_t now, void *uctx) 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]", @@ -2498,7 +2498,7 @@ void fr_event_timer_dump(fr_event_list_t *el) #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 * diff --git a/src/lib/util/libfreeradius-util.mk b/src/lib/util/libfreeradius-util.mk index 297928a8880..862318465c2 100644 --- a/src/lib/util/libfreeradius-util.mk +++ b/src/lib/util/libfreeradius-util.mk @@ -52,7 +52,7 @@ SOURCES := \ print.c \ proto.c \ rand.c \ - rbtree.c \ + rb.c \ regex.c \ retry.c \ sbuff.c \ diff --git a/src/lib/util/packet.h b/src/lib/util/packet.h index 3937cdc9278..71de57dbe43 100644 --- a/src/lib/util/packet.h +++ b/src/lib/util/packet.h @@ -31,7 +31,7 @@ extern "C" { #include #include #include -#include +#include #include #include #include diff --git a/src/lib/util/rbtree.c b/src/lib/util/rb.c similarity index 83% rename from src/lib/util/rbtree.c rename to src/lib/util/rb.c index 520d15fde49..301320b79ef 100644 --- a/src/lib/util/rbtree.c +++ b/src/lib/util/rb.c @@ -16,14 +16,14 @@ /** 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 -#include +#include #include #include @@ -31,7 +31,7 @@ RCSID("$Id$") #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 @@ -53,12 +53,12 @@ struct rbtree_s { }; #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; @@ -69,22 +69,22 @@ static inline void rbtree_free_data(rbtree_t *tree, fr_rb_node_t *node) /** 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); } @@ -103,7 +103,7 @@ void rbtree_node_talloc_free(void *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 @@ -150,33 +150,33 @@ static int _tree_free(rbtree_t *tree) * @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); @@ -189,7 +189,7 @@ rbtree_t *_rbtree_alloc(TALLOC_CTX *ctx, /** 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; @@ -199,7 +199,7 @@ void rbtree_unlock(rbtree_t *tree) /** 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; @@ -228,7 +228,7 @@ static void rotate_left(rbtree_t *tree, fr_rb_node_t *x) /** 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; @@ -256,7 +256,7 @@ static void rotate_right(rbtree_t *tree, fr_rb_node_t *x) /** 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)) { @@ -316,7 +316,7 @@ static void insert_fixup(rbtree_t *tree, fr_rb_node_t *x) /** 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; @@ -350,7 +350,7 @@ static fr_rb_node_t *rbtree_insert_node(rbtree_t *tree, void *data) /* * 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) { @@ -417,16 +417,16 @@ static fr_rb_node_t *rbtree_insert_node(rbtree_t *tree, void *data) 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) { @@ -492,7 +492,7 @@ static void delete_fixup(rbtree_t *tree, fr_rb_node_t *x, fr_rb_node_t *parent) /** 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; @@ -557,12 +557,12 @@ static void rbtree_delete_internal(rbtree_t *tree, fr_rb_node_t *z, bool skiploc 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); } @@ -576,7 +576,7 @@ static void rbtree_delete_internal(rbtree_t *tree, fr_rb_node_t *z, bool skiploc /* 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; @@ -605,13 +605,13 @@ static fr_rb_node_t *rbtree_find_node(rbtree_t *tree, void const *data) * * @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; @@ -621,18 +621,18 @@ void *rbtree_find(rbtree_t *tree, void const *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; } @@ -641,14 +641,14 @@ bool rbtree_delete(rbtree_t *tree, void const *data) * * @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. @@ -656,7 +656,7 @@ uint64_t rbtree_num_elements(rbtree_t *tree) * - 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; @@ -669,7 +669,7 @@ void *rbtree_iter_init_inorder(fr_rb_tree_iter_inorder_t *iter, rbtree_t *tree) */ while (x->left != NIL) x = x->left; - *iter = (fr_rb_tree_iter_inorder_t){ + *iter = (fr_rb_iter_inorder_t){ .tree = tree, .node = x }; @@ -681,12 +681,12 @@ void *rbtree_iter_init_inorder(fr_rb_tree_iter_inorder_t *iter, rbtree_t *tree) * * @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; @@ -697,7 +697,7 @@ void *rbtree_iter_next_inorder(fr_rb_tree_iter_inorder_t *iter) 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.) */ @@ -741,22 +741,22 @@ void *rbtree_iter_next_inorder(fr_rb_tree_iter_inorder_t *iter) * * @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. @@ -764,7 +764,7 @@ void rbtree_iter_delete_inorder(fr_rb_tree_iter_inorder_t *iter) * - 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; @@ -775,7 +775,7 @@ void *rbtree_iter_init_preorder(fr_rb_tree_iter_preorder_t *iter, rbtree_t *tree /* * First, the root. */ - *iter = (fr_rb_tree_iter_preorder_t){ + *iter = (fr_rb_iter_preorder_t){ .tree = tree, .node = x }; @@ -787,12 +787,12 @@ void *rbtree_iter_init_preorder(fr_rb_tree_iter_preorder_t *iter, rbtree_t *tree * * @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; @@ -840,7 +840,7 @@ void *rbtree_iter_next_preorder(fr_rb_tree_iter_preorder_t *iter) /** 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. @@ -848,7 +848,7 @@ void *rbtree_iter_next_preorder(fr_rb_tree_iter_preorder_t *iter) * - 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; @@ -866,7 +866,7 @@ void *rbtree_iter_init_postorder(fr_rb_tree_iter_postorder_t *iter, rbtree_t *tr x = x->right; } - *iter = (fr_rb_tree_iter_postorder_t){ + *iter = (fr_rb_iter_postorder_t){ .tree = tree, .node = x }; @@ -878,12 +878,12 @@ void *rbtree_iter_init_postorder(fr_rb_tree_iter_postorder_t *iter, rbtree_t *tr * * @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; @@ -930,19 +930,19 @@ void *rbtree_iter_next_postorder(fr_rb_tree_iter_postorder_t *iter) 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) diff --git a/src/lib/util/rbtree.h b/src/lib/util/rb.h similarity index 56% rename from src/lib/util/rbtree.h rename to src/lib/util/rb.h index 5a8d8963cb3..a7167a8f901 100644 --- a/src/lib/util/rbtree.h +++ b/src/lib/util/rb.h @@ -17,11 +17,11 @@ /** 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" { @@ -32,8 +32,8 @@ extern "C" { #include #include -/* 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 { @@ -52,9 +52,9 @@ struct fr_rb_node_s { 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 * @@ -71,9 +71,9 @@ struct fr_rb_node_s { * - 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 @@ -91,30 +91,30 @@ struct fr_rb_node_s { * - 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; @@ -124,58 +124,58 @@ static inline void *rbtree_node_to_data(UNUSED rbtree_t *tree, fr_rb_node_t *nod /** 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 diff --git a/src/lib/util/rbtree_tests.c b/src/lib/util/rb_tests.c similarity index 62% rename from src/lib/util/rbtree_tests.c rename to src/lib/util/rb_tests.c index 691f82e5103..cd26c75fce6 100644 --- a/src/lib/util/rbtree_tests.c +++ b/src/lib/util/rb_tests.c @@ -16,7 +16,7 @@ /** Tests for rbtrees * - * @file src/lib/util/rbtree_tests.c + * @file src/lib/util/fr_rb_tree_tests.c * * @copyright 2021 Arran Cudbard-Bell */ @@ -25,37 +25,37 @@ #include #include -#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; @@ -65,17 +65,17 @@ static void test_rbtree_iter_inorder(void) * 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 */ @@ -96,29 +96,29 @@ static uint32_t pre_post_input[] = {0, 15, 256, 49, 3, 8192, 144, 4, 4096, 25194 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 */ @@ -130,29 +130,29 @@ static void test_rbtree_iter_preorder(void) 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 */ @@ -165,7 +165,7 @@ static void test_rbtree_iter_postorder(void) } /* - * primality test used in rbtree_delete_iter() test. + * primality test used in fr_rb_delete_iter() test. */ static bool is_prime(uint32_t n) { @@ -182,14 +182,14 @@ 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); /* @@ -197,26 +197,26 @@ static void test_rbtree_iter_delete(void) * 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 */ @@ -227,14 +227,14 @@ static void test_rbtree_iter_delete(void) 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); /* @@ -242,19 +242,19 @@ static void test_rbtree_iter_done(void) * 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 */ @@ -267,11 +267,11 @@ static void test_rbtree_iter_done(void) 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 } }; diff --git a/src/lib/util/rbtree_tests.mk b/src/lib/util/rb_tests.mk similarity index 68% rename from src/lib/util/rbtree_tests.mk rename to src/lib/util/rb_tests.mk index fddf8d43d29..12e636e2125 100644 --- a/src/lib/util/rbtree_tests.mk +++ b/src/lib/util/rb_tests.mk @@ -1,5 +1,5 @@ -TARGET := rbtree_tests -SOURCES := rbtree_tests.c +TARGET := rb_tests +SOURCES := rb_tests.c TGT_PREREQS += libfreeradius-util.a diff --git a/src/modules/proto_bfd/proto_bfd.c b/src/modules/proto_bfd/proto_bfd.c index 5af6b164160..04aa389a5eb 100644 --- a/src/modules/proto_bfd/proto_bfd.c +++ b/src/modules/proto_bfd/proto_bfd.c @@ -228,7 +228,7 @@ typedef struct { 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; @@ -587,7 +587,7 @@ static bfd_state_t *bfd_new_session(bfd_socket_t *sock, int sockfd, 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; @@ -607,7 +607,7 @@ static bfd_state_t *bfd_new_session(bfd_socket_t *sock, int sockfd, 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; } @@ -1488,7 +1488,7 @@ static int bfd_socket_recv(rad_listen_t *listener) 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; @@ -1590,7 +1590,7 @@ static int bfd_init_sessions(CONF_SECTION *cs, bfd_socket_t *sock, int sockfd) 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; } @@ -1715,7 +1715,7 @@ static int bfd_socket_parse(CONF_SECTION *cs, rad_listen_t *this) } } - 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; diff --git a/src/modules/proto_ldap_sync/sync.c b/src/modules/proto_ldap_sync/sync.c index 56da6a53d1f..7666094acca 100644 --- a/src/modules/proto_ldap_sync/sync.c +++ b/src/modules/proto_ldap_sync/sync.c @@ -724,9 +724,9 @@ int sync_demux(int *sync_id, fr_ldap_connection_t *conn) 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); @@ -774,7 +774,7 @@ int sync_demux(int *sync_id, fr_ldap_connection_t *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); @@ -863,7 +863,7 @@ static int _sync_state_free(sync_state_t *sync) { 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); @@ -876,7 +876,7 @@ static int _sync_state_free(sync_state_t *sync) * 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; } @@ -910,15 +910,15 @@ static int8_t _sync_cmp(void const *one, void const *two) 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 */ } @@ -930,15 +930,15 @@ void sync_state_destroy(fr_ldap_connection_t *conn, int msgid) 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; } @@ -982,7 +982,7 @@ int sync_state_init(fr_ldap_connection_t *conn, sync_config_t const *config, int ret; int mode; sync_state_t *sync; - rbtree_t *tree; + fr_rb_tree_t *tree; fr_assert(conn); fr_assert(config); @@ -994,10 +994,10 @@ int sync_state_init(fr_ldap_connection_t *conn, sync_config_t const *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); } /* @@ -1061,7 +1061,7 @@ int sync_state_init(fr_ldap_connection_t *conn, sync_config_t const *config, return -1; } - if (!rbtree_insert(tree, sync)) { + if (!fr_rb_insert(tree, sync)) { ERROR("Duplicate sync (msgid %i)", sync->msgid); return -1; } diff --git a/src/modules/rlm_cache/drivers/rlm_cache_rbtree/rlm_cache_rbtree.c b/src/modules/rlm_cache/drivers/rlm_cache_rbtree/rlm_cache_rbtree.c index 20fd5536a94..e7261bec6fa 100644 --- a/src/modules/rlm_cache/drivers/rlm_cache_rbtree/rlm_cache_rbtree.c +++ b/src/modules/rlm_cache/drivers/rlm_cache_rbtree/rlm_cache_rbtree.c @@ -27,18 +27,18 @@ #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 * @@ -71,17 +71,17 @@ static int8_t cache_heap_cmp(void const *one, void const *two) */ 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); } @@ -103,12 +103,12 @@ static int mod_detach(void *instance) */ 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; @@ -118,7 +118,7 @@ static int mod_instantiate(void *instance, UNUSED CONF_SECTION *conf) /* * 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; @@ -141,9 +141,9 @@ static int mod_instantiate(void *instance, UNUSED CONF_SECTION *conf) 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; @@ -163,7 +163,7 @@ static cache_status_t cache_entry_find(rlm_cache_entry_t **out, 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; @@ -175,14 +175,14 @@ static cache_status_t cache_entry_find(rlm_cache_entry_t **out, 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; @@ -202,16 +202,16 @@ static cache_status_t cache_entry_expire(UNUSED rlm_cache_config_t const *config 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; @@ -229,7 +229,7 @@ static cache_status_t cache_entry_insert(rlm_cache_config_t const *config, void { 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); @@ -238,11 +238,11 @@ static cache_status_t cache_entry_insert(rlm_cache_config_t const *config, void /* * 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; @@ -250,7 +250,7 @@ static cache_status_t cache_entry_insert(rlm_cache_config_t const *config, void } 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; @@ -269,7 +269,7 @@ static cache_status_t cache_entry_set_ttl(UNUSED rlm_cache_config_t const *confi 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; @@ -281,7 +281,7 @@ static cache_status_t cache_entry_set_ttl(UNUSED rlm_cache_config_t const *confi } 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; } @@ -297,11 +297,11 @@ static cache_status_t cache_entry_set_ttl(UNUSED rlm_cache_config_t const *confi 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 @@ -313,7 +313,7 @@ static uint64_t cache_entry_count(UNUSED rlm_cache_config_t const *config, void 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); @@ -333,7 +333,7 @@ static int cache_acquire(void **handle, UNUSED rlm_cache_config_t const *config, 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); @@ -346,7 +346,7 @@ rlm_cache_driver_t rlm_cache_rbtree = { .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, diff --git a/src/modules/rlm_csv/rlm_csv.c b/src/modules/rlm_csv/rlm_csv.c index 179fd8be39a..39482d5c1f0 100644 --- a/src/modules/rlm_csv/rlm_csv.c +++ b/src/modules/rlm_csv/rlm_csv.c @@ -58,7 +58,7 @@ typedef struct { 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; @@ -185,7 +185,7 @@ static rlm_csv_entry_t *find_entry(rlm_csv_t const *inst, fr_value_box_t const * 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) @@ -226,7 +226,7 @@ static bool insert_entry(CONF_SECTION *conf, rlm_csv_t *inst, rlm_csv_entry_t *e 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; @@ -567,7 +567,7 @@ static int mod_bootstrap(void *instance, CONF_SECTION *conf) (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)) { diff --git a/src/modules/rlm_files/rlm_files.c b/src/modules/rlm_files/rlm_files.c index 04ee501dc85..ddc3e480bb6 100644 --- a/src/modules/rlm_files/rlm_files.c +++ b/src/modules/rlm_files/rlm_files.c @@ -36,24 +36,24 @@ typedef struct { 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; @@ -95,14 +95,14 @@ static int8_t pairlist_cmp(void const *a, void const *b) 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; @@ -204,7 +204,7 @@ static int getusersfile(TALLOC_CTX *ctx, char const *filename, rbtree_t **ptree) } } - 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; @@ -247,7 +247,7 @@ static int getusersfile(TALLOC_CTX *ctx, char const *filename, rbtree_t **ptree) /* * 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); @@ -268,7 +268,7 @@ static int getusersfile(TALLOC_CTX *ctx, char const *filename, rbtree_t **ptree) * 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); @@ -276,7 +276,7 @@ static int getusersfile(TALLOC_CTX *ctx, char const *filename, rbtree_t **ptree) /* * 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 @@ -314,7 +314,7 @@ static int mod_instantiate(void *instance, UNUSED CONF_SECTION *conf) * 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; @@ -331,10 +331,10 @@ static unlang_action_t file_common(rlm_rcode_t *p_result, rlm_files_t const *ins 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; /* diff --git a/src/modules/rlm_icmp/rlm_icmp.c b/src/modules/rlm_icmp/rlm_icmp.c index dd5e841de9c..58a50fcfd3d 100644 --- a/src/modules/rlm_icmp/rlm_icmp.c +++ b/src/modules/rlm_icmp/rlm_icmp.c @@ -48,7 +48,7 @@ typedef struct { typedef struct { rlm_icmp_t *inst; - rbtree_t *tree; + fr_rb_tree_t *tree; int fd; fr_event_list_t *el; @@ -135,7 +135,7 @@ static xlat_action_t xlat_icmp_resume(TALLOC_CTX *ctx, fr_dcursor_t *out, 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); @@ -153,7 +153,7 @@ static void xlat_icmp_cancel(request_t *request, UNUSED void *xlat_inst, void *x 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); } @@ -225,7 +225,7 @@ static xlat_action_t xlat_icmp(TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, * 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; @@ -233,7 +233,7 @@ static xlat_action_t xlat_icmp(TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, 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; } @@ -270,14 +270,14 @@ static xlat_action_t xlat_icmp(TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, 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; } @@ -313,7 +313,7 @@ static void mod_icmp_read(UNUSED fr_event_list_t *el, UNUSED int sockfd, UNUSED /* * 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; } @@ -365,13 +365,13 @@ static void mod_icmp_read(UNUSED fr_event_list_t *el, UNUSED int sockfd, UNUSED * 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! @@ -431,7 +431,7 @@ static int mod_thread_instantiate(UNUSED CONF_SECTION const *cs, void *instance, 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; diff --git a/src/modules/rlm_radius/track.c b/src/modules/rlm_radius/track.c index 2413f7156e1..3f00922b9c5 100644 --- a/src/modules/rlm_radius/track.c +++ b/src/modules/rlm_radius/track.c @@ -24,7 +24,7 @@ RCSID("$Id$") #include -#include +#include #include #include #include @@ -160,8 +160,8 @@ retry: * 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)); } /* @@ -243,7 +243,7 @@ int radius_track_entry_release( * 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; } @@ -257,7 +257,7 @@ int radius_track_entry_release( * 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 @@ -299,7 +299,7 @@ int radius_track_entry_update(radius_track_entry_t *te, uint8_t const *vector) /* * 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)); @@ -321,7 +321,7 @@ int radius_track_entry_update(radius_track_entry_t *te, uint8_t const *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; } @@ -364,7 +364,7 @@ radius_track_entry_t *radius_track_entry_find(radius_track_t *tt, uint8_t packet */ 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 diff --git a/src/modules/rlm_radius/track.h b/src/modules/rlm_radius/track.h index 1845776cbb0..0180ad7ce5a 100644 --- a/src/modules/rlm_radius/track.h +++ b/src/modules/rlm_radius/track.h @@ -71,7 +71,7 @@ struct radius_track_s { 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 diff --git a/src/modules/rlm_securid/mem.c b/src/modules/rlm_securid/mem.c index 4bea06bee63..eca9d274ab5 100644 --- a/src/modules/rlm_securid/mem.c +++ b/src/modules/rlm_securid/mem.c @@ -102,7 +102,7 @@ int securid_sessionlist_add(rlm_securid_t *inst,request_t *request, SECURID_SESS /* * 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; } @@ -127,7 +127,7 @@ int securid_sessionlist_add(rlm_securid_t *inst,request_t *request, SECURID_SESS 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 */ @@ -229,12 +229,12 @@ SECURID_SESSION *securid_sessionlist_find(rlm_securid_t *inst, request_t *reques /************ 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. @@ -260,7 +260,7 @@ static void securid_sessionlist_clean_expired(rlm_securid_t *inst, request_t *re 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); /* @@ -269,7 +269,7 @@ static void securid_sessionlist_clean_expired(rlm_securid_t *inst, request_t *re */ 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 diff --git a/src/modules/rlm_securid/rlm_securid.c b/src/modules/rlm_securid/rlm_securid.c index 6721d9bd831..253335be05e 100644 --- a/src/modules/rlm_securid/rlm_securid.c +++ b/src/modules/rlm_securid/rlm_securid.c @@ -451,7 +451,7 @@ static int mod_instantiate(void *instance, UNUSED CONF_SECTION *conf) * 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; diff --git a/src/modules/rlm_securid/rlm_securid.h b/src/modules/rlm_securid/rlm_securid.h index e5d30d2bd66..e488fec5289 100644 --- a/src/modules/rlm_securid/rlm_securid.h +++ b/src/modules/rlm_securid/rlm_securid.h @@ -64,7 +64,7 @@ typedef struct { */ 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; diff --git a/src/modules/rlm_sigtran/sccp.c b/src/modules/rlm_sigtran/sccp.c index 6783e83c190..df2b307f6e0 100644 --- a/src/modules/rlm_sigtran/sccp.c +++ b/src/modules/rlm_sigtran/sccp.c @@ -52,7 +52,7 @@ #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 @@ -78,7 +78,7 @@ static void sigtran_tcap_timeout(void *data) /* * 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; @@ -138,7 +138,7 @@ int sigtran_tcap_outgoing(UNUSED struct msgb *msg_in, void *ctx, sigtran_transac 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; @@ -183,7 +183,7 @@ int sigtran_tcap_outgoing(UNUSED struct msgb *msg_in, void *ctx, sigtran_transac 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); @@ -245,7 +245,7 @@ static int sigtran_tcap_incoming(struct msgb *msg, UNUSED unsigned int length, U /* * 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 @@ -253,7 +253,7 @@ static int sigtran_tcap_incoming(struct msgb *msg, UNUSED unsigned int length, U 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); } @@ -376,7 +376,7 @@ int sigtran_sccp_global_init(void) 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++; diff --git a/src/modules/rlm_stats/rlm_stats.c b/src/modules/rlm_stats/rlm_stats.c index e44d54d2e59..6a9066f7c85 100644 --- a/src/modules/rlm_stats/rlm_stats.c +++ b/src/modules/rlm_stats/rlm_stats.c @@ -73,8 +73,8 @@ typedef struct { 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; @@ -108,16 +108,16 @@ static void coalesce(uint64_t final_stats[FR_RADIUS_CODE_MAX], rlm_stats_thread_ { 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 { @@ -135,8 +135,8 @@ static void coalesce(uint64_t final_stats[FR_RADIUS_CODE_MAX], rlm_stats_thread_ 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; } @@ -190,14 +190,14 @@ static unlang_action_t CC_HINT(nonnull) mod_stats(rlm_rcode_t *p_result, module_ * 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; @@ -208,14 +208,14 @@ static unlang_action_t CC_HINT(nonnull) mod_stats(rlm_rcode_t *p_result, module_ * 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; @@ -352,8 +352,8 @@ static int mod_thread_instantiate(UNUSED CONF_SECTION const *cs, void *instance, 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); diff --git a/src/protocols/radius/list.c b/src/protocols/radius/list.c index 040ad59786f..04291688388 100644 --- a/src/protocols/radius/list.c +++ b/src/protocols/radius/list.c @@ -105,7 +105,7 @@ typedef struct { * that should be managed. */ struct fr_packet_list_s { - rbtree_t *tree; + fr_rb_tree_t *tree; int alloc_id; uint32_t num_outgoing; @@ -281,7 +281,7 @@ fr_packet_list_t *fr_packet_list_create(int alloc_id) 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; @@ -306,14 +306,14 @@ bool fr_packet_list_insert(fr_packet_list_t *pl, { 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); } @@ -355,7 +355,7 @@ fr_radius_packet_t *fr_packet_list_find_byreply(fr_packet_list_t *pl, fr_radius_ my_request.id = reply->id; request = &my_request; - return rbtree_find(pl->tree, request); + return fr_rb_find(pl->tree, request); } @@ -363,14 +363,14 @@ bool fr_packet_list_yank(fr_packet_list_t *pl, fr_radius_packet_t *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); } @@ -709,7 +709,7 @@ uint64_t fr_packet_list_num_incoming(fr_packet_list_t *pl) 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; diff --git a/src/tests/rbmonkey.c b/src/tests/rbmonkey.c index 23ebde9b734..030d4f5f900 100644 --- a/src/tests/rbmonkey.c +++ b/src/tests/rbmonkey.c @@ -2,17 +2,17 @@ #include #include -#include +#include #include 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); } @@ -26,7 +26,7 @@ static int qsort_comp(void const *a, void const *b) #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 @@ -34,13 +34,13 @@ static int print_cb(void *i, UNUSED void *uctx) #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; @@ -50,7 +50,7 @@ static int filter_cb(void *i, void *uctx) * 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; @@ -131,13 +131,13 @@ static void freenode(void *data) 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)); @@ -154,44 +154,44 @@ again: 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; }