clean up public APIs

move "node" functions internal to rbtree.c.

The public APIs are now:

	rbtree_insert
	rbtree_find
	rbtree_delete

which fixes ~20 years of a bad API

diff --git a/src/bin/radsniff.c b/src/bin/radsniff.c
index 119fc84b32914f9a095d9ac8c36f08ba8caee398..923ba0002babe43e46c8cd00b70db4f679d660e7 100644 (file)
--- a/src/bin/radsniff.c
+++ b/src/bin/radsniff.c
@@ -980,12 +980,12 @@ static int _request_free(rs_request_t *request)
         *      something has gone very badly wrong.
         */
        if (request->in_request_tree) {
-               ret = rbtree_delete_by_data(request_tree, request);
+               ret = rbtree_delete(request_tree, request);
                RS_ASSERT(ret);
        }
 
        if (request->in_link_tree) {
-               ret = rbtree_delete_by_data(link_tree, request);
+               ret = rbtree_delete(link_tree, request);
                RS_ASSERT(ret);
        }
 
@@ -1390,7 +1390,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_data(request_tree, &search);
+               original = rbtree_find(request_tree, &search);
 
                /*
                 *      Verify this code is allowed
@@ -1608,8 +1608,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_data(link_tree, &search);
-                       tuple = rbtree_find_data(request_tree, &search);
+                       original = rbtree_find(link_tree, &search);
+                       tuple = rbtree_find(request_tree, &search);
 
                        /*
                         *      If the packet we matched using attributes is not the same
@@ -1623,7 +1623,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_data(request_tree, &search);
+                       original = rbtree_find(request_tree, &search);
                        if (original && (memcmp(original->expect->vector, packet->vector,
                                                sizeof(original->expect->vector)) != 0)) {
                                /*
@@ -1673,7 +1673,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_by_data(request_tree, original);
+                               rbtree_delete(request_tree, original);
                        }
 
                        /* replace expected packets and vps */

diff --git a/src/lib/io/master.c b/src/lib/io/master.c
index 876edc9d6149b91461c683e39899cd54868c7637..ba4a0f644aece37d57be7346f5b36ff37a286063 100644 (file)
--- a/src/lib/io/master.c
+++ b/src/lib/io/master.c
@@ -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_data(track->client->table, track) != NULL);
+       fr_assert(rbtree_find(track->client->table, track) != NULL);
 
-       if (!rbtree_delete_by_data(track->client->table, track)) {
+       if (!rbtree_delete(track->client->table, track)) {
                fr_assert(0);
        }
 
@@ -895,7 +895,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_data(client->table, track);
+       old = rbtree_find(client->table, track);
        if (!old) goto do_insert;
 
        fr_assert(old->client == client);
@@ -964,7 +964,7 @@ static fr_io_track_t *fr_io_track_add(fr_io_client_t *client,
        } else {
                fr_assert(client == old->client);
 
-               if (!rbtree_delete_by_data(client->table, old)) {
+               if (!rbtree_delete(client->table, old)) {
                        fr_assert(0);
                }
                if (old->ev) (void) fr_event_timer_delete(&old->ev);

diff --git a/src/lib/io/network.c b/src/lib/io/network.c
index c7f45bb25a1a7107d20b482ce02451d1c4a7934f..7e9d6282744936c0e5cf2e967db29dbb6e1ef61a 100644 (file)
--- a/src/lib/io/network.c
+++ b/src/lib/io/network.c
@@ -243,7 +243,7 @@ int fr_network_socket_delete(fr_network_t *nr, fr_listen_t *li)
 {
        fr_network_socket_t *s;
 
-       s = rbtree_find_data(nr->sockets, &(fr_network_socket_t){ .listen = li });
+       s = rbtree_find(nr->sockets, &(fr_network_socket_t){ .listen = li });
        if (!s) return -1;
 
        fr_network_socket_dead(nr, s);
@@ -296,7 +296,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_data(nr->sockets, &(fr_network_socket_t){ .listen = li });
+       s = rbtree_find(nr->sockets, &(fr_network_socket_t){ .listen = li });
        if (!s) return;
 
        /*
@@ -1045,8 +1045,8 @@ static int _network_socket_free(fr_network_socket_t *s)
        fr_network_t *nr = s->nr;
        fr_channel_data_t *cd;
 
-       rbtree_delete_by_data(nr->sockets, s);
-       rbtree_delete_by_data(nr->sockets_by_num, s);
+       rbtree_delete(nr->sockets, s);
+       rbtree_delete(nr->sockets_by_num, s);
 
        fr_event_fd_delete(nr->el, s->listen->fd, s->filter);
 
@@ -1283,7 +1283,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_data(nr->sockets, &(fr_network_socket_t){ .listen = my_inject.listen });
+       s = rbtree_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;
@@ -1343,7 +1343,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_data(nr->sockets, &(fr_network_socket_t){ .listen = li });
+               s = rbtree_find(nr->sockets, &(fr_network_socket_t){ .listen = li });
 
                /*
                 *      This shouldn't happen, but be safe...
@@ -1773,7 +1773,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_data(nr->sockets_by_num, &(fr_network_socket_t){ .number = info->box[0]->vb_uint32 });
+       s = rbtree_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/worker.c b/src/lib/io/worker.c
index 4cf454fdb0fc8a3b142f3a4c97b202531f4b88be..97210b03d7ff49d2c8d8b4191f0cce3bf4c609b8 100644 (file)
--- a/src/lib/io/worker.c
+++ b/src/lib/io/worker.c
@@ -752,7 +752,7 @@ nak:
        if (request->async->listen->track_duplicates) {
                request_t *old;
 
-               old = rbtree_find_data(worker->dedup, request);
+               old = rbtree_find(worker->dedup, request);
                if (!old) {
                        /*
                         *      Ignore duplicate packets where we've
@@ -980,7 +980,7 @@ static void _worker_request_external_done(request_t *request, UNUSED rlm_rcode_t
         *      then, only some of the time.
         */
        if (request->async->listen->track_duplicates) {
-               (void) rbtree_delete_by_data(worker->dedup, request);
+               (void) rbtree_delete(worker->dedup, request);
        }
 
        /*

diff --git a/src/lib/redis/cluster.c b/src/lib/redis/cluster.c
index e83946da99fac405a097cadb578888e6f40e7feb..830fc2258697dd48bac25648e994ba6454bb52b2 100644 (file)
--- a/src/lib/redis/cluster.c
+++ b/src/lib/redis/cluster.c
@@ -553,7 +553,7 @@ do { \
 do { \
        (_node)->is_active = false; \
        (_node)->is_master = false; \
-       rbtree_delete_by_data(cluster->used_nodes, _node); \
+       rbtree_delete(cluster->used_nodes, _node); \
        fr_fifo_push(cluster->free_nodes, _node); \
 } while (0)
 
@@ -601,7 +601,7 @@ do { \
                memset(&tmpl_slot, 0, sizeof(tmpl_slot));
 
                SET_ADDR(find.addr, map->element[2]);
-               found = rbtree_find_data(cluster->used_nodes, &find);
+               found = rbtree_find(cluster->used_nodes, &find);
                if (found) {
                        active[found->id] = true;
                        goto reuse_master_node;
@@ -653,7 +653,7 @@ do { \
                 */
                for (j = 3; (j < map->elements); j++) {
                        SET_ADDR(find.addr, map->element[j]);
-                       found = rbtree_find_data(cluster->used_nodes, &find);
+                       found = rbtree_find(cluster->used_nodes, &find);
                        if (found) {
                                active[found->id] = true;
                                goto next;
@@ -728,7 +728,7 @@ do { \
 
                if (cluster->node[i].is_active) {
                        /* Sanity check for duplicates that are active */
-                       found = rbtree_find_data(cluster->used_nodes, &cluster->node[i]);
+                       found = rbtree_find(cluster->used_nodes, &cluster->node[i]);
                        fr_assert(found);
                        fr_assert(found->is_active);
                        fr_assert(found->id == i);
@@ -1119,7 +1119,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_data(cluster->used_nodes, &find);
+       found = rbtree_find(cluster->used_nodes, &find);
        if (found) {
                /* We have the new pool, don't need to hold the lock */
                pthread_mutex_unlock(&cluster->mutex);
@@ -2030,7 +2030,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_data(cluster->used_nodes, &find);
+       found = rbtree_find(cluster->used_nodes, &find);
        if (!found) {
                fr_redis_cluster_node_t *spare;
                char buffer[INET6_ADDRSTRLEN];

diff --git a/src/lib/server/cf_file.c b/src/lib/server/cf_file.c
index 7df3f28ee86d880a279607a2f1a4ada1e3f46a35..96e03352b2354142fca8c68d7922d470b9dd2782 100644 (file)
--- a/src/lib/server/cf_file.c
+++ b/src/lib/server/cf_file.c
@@ -536,7 +536,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_data(tree, &my_file);
+               file = rbtree_find(tree, &my_file);
 
                /*
                 *      The file was previously read by including it

diff --git a/src/lib/server/cf_util.c b/src/lib/server/cf_util.c
index 5c7581c3402844917d10e322ede00b72d266e695..2860ad752ff740fa69f47c735c33f8ce0f5f4722 100644 (file)
--- 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_data(parent->ident1, find);
+       if (IS_WILDCARD(ident2)) return rbtree_find(parent->ident1, find);
 
        /*
         *      Both ident1 and ident2 use the ident2 tree.
         */
-       return rbtree_find_data(parent->ident2, find);
+       return rbtree_find(parent->ident2, find);
 }
 
 /** Return the next child that's of the specified type with the specified identifiers
@@ -411,14 +411,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_data(parent->ident1, child) == child);
-       if (in_ident1 && (!rbtree_delete_by_data(parent->ident1, child))) {
+       in_ident1 = (rbtree_find(parent->ident1, child) == child);
+       if (in_ident1 && (!rbtree_delete(parent->ident1, child))) {
                fr_assert(0);
                return NULL;
        }
 
-       in_ident2 = (rbtree_find_data(parent->ident2, child) == child);
-       if (in_ident2 && (!rbtree_delete_by_data(parent->ident2, child))) {
+       in_ident2 = (rbtree_find(parent->ident2, child) == child);
+       if (in_ident2 && (!rbtree_delete(parent->ident2, child))) {
                fr_assert(0);
                return NULL;
        }
@@ -2081,8 +2081,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_data(ci->ident1, child) == child? "in ident1 " : "";
-               in_ident2 = rbtree_find_data(ci->ident2, child) == child? "in ident2 " : "";
+               in_ident1 = rbtree_find(ci->ident1, child) == child? "in ident1 " : "";
+               in_ident2 = rbtree_find(ci->ident2, child) == child? "in ident2 " : "";
 
                switch (child->type) {
                case CONF_ITEM_SECTION:

diff --git a/src/lib/server/client.c b/src/lib/server/client.c
index 00e1b08783b8105a413102e0de9d800971f96de5..8e13f2b5dfefc6605f44a3dddd58f9153908ceda 100644 (file)
--- a/src/lib/server/client.c
+++ b/src/lib/server/client.c
@@ -294,7 +294,7 @@ bool client_add(RADCLIENT_LIST *clients, RADCLIENT *client)
                }
        }
 
-       old = rbtree_find_data(clients->tree[client->ipaddr.prefix], client);
+       old = rbtree_find(clients->tree[client->ipaddr.prefix], client);
 #endif
        if (old) {
                /*
@@ -363,7 +363,7 @@ void client_delete(RADCLIENT_LIST *clients, RADCLIENT *client)
 
        if (!clients->tree[client->ipaddr.prefix]) return;
 
-       (void) rbtree_delete_by_data(clients->tree[client->ipaddr.prefix], client);
+       (void) rbtree_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_data(clients->tree[i], &my_client);
+               client = rbtree_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 18941187d5ec0064f791b1f4eda74b9b3aea177e..f2a3f3b54d2423e3bc2f358979d3ce8c6e75f4e3 100644 (file)
--- a/src/lib/server/dl_module.c
+++ b/src/lib/server/dl_module.c
@@ -207,7 +207,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_data(dl_module_loader->inst_data_tree, &(dl_module_inst_t){ .data = UNCONST(void *, data) });
+       return rbtree_find(dl_module_loader->inst_data_tree, &(dl_module_inst_t){ .data = UNCONST(void *, data) });
 }
 
 /** Lookup instance name via instance data
@@ -314,7 +314,7 @@ static int _dl_module_free(dl_module_t *dl_module)
        }
 
        if (dl_module->in_tree) {
-               rbtree_delete_by_data(dl_module_loader->module_tree, dl_module);
+               rbtree_delete(dl_module_loader->module_tree, dl_module);
                dl_module->in_tree = false;
        }
 
@@ -370,7 +370,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_data(dl_module_loader->module_tree,
+       dl_module = rbtree_find(dl_module_loader->module_tree,
                                    &(dl_module_t){ .dl = &(dl_t){ .name = module_name }});
        if (dl_module) {
                talloc_free(module_name);
@@ -463,7 +463,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_by_data(dl_module_loader->inst_data_tree, dl_inst);
+        rbtree_delete(dl_module_loader->inst_data_tree, dl_inst);
 
         /*
          *     Decrements the reference count. The module object

diff --git a/src/lib/server/map_proc.c b/src/lib/server/map_proc.c
index db00daec65fed317289dddabd59a4c70bb3915e9..34ae45fc717c8376a669d7228f2e82278ed0b11b 100644 (file)
--- a/src/lib/server/map_proc.c
+++ b/src/lib/server/map_proc.c
@@ -61,10 +61,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_data(map_proc_root, &find);
+       found = rbtree_find(map_proc_root, &find);
        if (!found) return 0;
 
-       rbtree_delete_by_data(map_proc_root, found);
+       rbtree_delete(map_proc_root, found);
 
        return 0;
 }
@@ -90,7 +90,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_data(map_proc_root, &find);
+       return rbtree_find(map_proc_root, &find);
 }
 
 /** Register a map processor

diff --git a/src/lib/server/method.c b/src/lib/server/method.c
index 52275e6fa181034b8748899678b80769d52f8759..8227417b7a3b143cb84239ae48eb2a0362abbd28 100644 (file)
--- a/src/lib/server/method.c
+++ b/src/lib/server/method.c
@@ -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_data(set->tree, &find);
+       found = rbtree_find(set->tree, &find);
        if (found) {
                if (unlikely(found->method != method)) {
                        fr_strerror_printf("Conflict for method id %u (old %p vs new %p)",
@@ -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_data(set->tree, &(module_method_entry_t){ .id = id });
+       found = rbtree_find(set->tree, &(module_method_entry_t){ .id = id });
        if (!found) return NULL;
 
        return found->method;

diff --git a/src/lib/server/module.c b/src/lib/server/module.c
index 5b6c99503558d03d9bc7f1ca8bc3f9116a2cf79b..6bdf1512a734cdabcecce98a0356b8c2a73ee5dd 100644 (file)
--- a/src/lib/server/module.c
+++ b/src/lib/server/module.c
@@ -646,7 +646,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_data(module_instance_name_tree,
+       inst = rbtree_find(module_instance_name_tree,
                               &(module_instance_t){
                                        .dl_inst = &(dl_module_inst_t){ .parent = parent ? parent->dl_inst : NULL },
                                        .name = inst_name
@@ -1051,7 +1051,7 @@ module_instance_t *module_by_data(void const *data)
 {
        module_instance_t *mi;
 
-       mi = rbtree_find_data(module_instance_data_tree,
+       mi = rbtree_find(module_instance_data_tree,
                             &(module_instance_t){
                                .dl_inst = &(dl_module_inst_t){ .data = UNCONST(void *, data) },
                             });
@@ -1427,8 +1427,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_by_data(module_instance_name_tree, mi))) return 1;
-       if (mi->in_data_tree) if (!fr_cond_assert(rbtree_delete_by_data(module_instance_data_tree, mi))) return 1;
+       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->mutex) {
                /*
                 *      FIXME

diff --git a/src/lib/server/state.c b/src/lib/server/state.c
index afeaf24159971760a55c83ea4d25fdc7938d7118..50824366e7a290f2e00fef003f5f4d608bee49d4 100644 (file)
--- a/src/lib/server/state.c
+++ b/src/lib/server/state.c
@@ -266,7 +266,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_by_data(state->tree, entry);
+       rbtree_delete(state->tree, entry);
 
        DEBUG4("State ID %" PRIu64 " unlinked", entry->id);
 }
@@ -564,7 +564,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_data(state->tree, &my_entry);
+       entry = rbtree_find(state->tree, &my_entry);
 
        if (entry) (void) talloc_get_type_abort(entry, fr_state_entry_t);
 

diff --git a/src/lib/server/trigger.c b/src/lib/server/trigger.c
index 6afbd23632c354da465e2939889bc94cc47cde70..480ae58f2dc62a08d274d2ea68e00e7e6e88d66b 100644 (file)
--- a/src/lib/server/trigger.c
+++ b/src/lib/server/trigger.c
@@ -349,7 +349,7 @@ int trigger_exec(unlang_interpret_t *intp, request_t *request,
 
                pthread_mutex_lock(trigger_mutex);
 
-               found = rbtree_find_data(trigger_last_fired_tree, &find);
+               found = rbtree_find(trigger_last_fired_tree, &find);
                if (!found) {
                        MEM(found = talloc(NULL, trigger_last_fired_t));
                        found->ci = ci;

diff --git a/src/lib/server/virtual_servers.c b/src/lib/server/virtual_servers.c
index 21a79293e2c92d63b4a5a007f55fb8277727e53a..19287fda953940f8aa0e1235cfb4f8a7bc24a57c 100644 (file)
--- a/src/lib/server/virtual_servers.c
+++ b/src/lib/server/virtual_servers.c
@@ -760,7 +760,7 @@ fr_listen_t *listen_find_any(fr_listen_t *li)
 {
        if (!listen_addr_root) return false;
 
-       return rbtree_find_data(listen_addr_root, li);
+       return rbtree_find(listen_addr_root, li);
 }
 
 
@@ -858,7 +858,7 @@ int virtual_servers_instantiate(void)
                        fr_virtual_namespace_t  find = { .namespace = virtual_servers[i]->namespace };
                        fr_virtual_namespace_t  *found;
 
-                       found = rbtree_find_data(vns_tree, &find);
+                       found = rbtree_find(vns_tree, &find);
                        if (found) {
                                fr_assert(dict && (dict->dict == found->dict));
 
@@ -1616,7 +1616,7 @@ int virtual_server_section_register(virtual_server_compile_t const *entry)
 
        fr_assert(server_section_name_tree != NULL);
 
-       old = rbtree_find_data(server_section_name_tree, entry);
+       old = rbtree_find(server_section_name_tree, entry);
        if (old) return 0;
 
 #ifndef NDEBUG
@@ -1668,7 +1668,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_data(server_section_name_tree,
+               entry = rbtree_find(server_section_name_tree,
                                        &(virtual_server_compile_t) {
                                                .name = name1,
                                                .name2 = name2,
@@ -1679,7 +1679,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_data(server_section_name_tree,
+       entry = rbtree_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 fc143061f65cbd4ea6d968accb889ae1d28f4ddd..3d8572010de907769a071c9ebbc63e5abe4f8b27 100644 (file)
--- a/src/lib/tls/engine.c
+++ b/src/lib/tls/engine.c
@@ -258,7 +258,7 @@ int fr_tls_engine_init(ENGINE **e_out,
        } else {
                tls_engine_t *found = NULL;
 
-               found = rbtree_find_data(tls_engines, &(tls_engine_t){ .id = id, .instance = instance });
+               found = rbtree_find(tls_engines, &(tls_engine_t){ .id = id, .instance = instance });
                if (found) {
                        fr_strerror_printf("engine %s%s%s%salready initialised", id,
                                           instance ? " (" : "",
@@ -434,7 +434,7 @@ int fr_tls_engine(ENGINE **e_out, char const *id, char const *instance, bool aut
        }
 
 
-       found = rbtree_find_data(tls_engines, &(tls_engine_t){ .id = id, .instance = instance });
+       found = rbtree_find(tls_engines, &(tls_engine_t){ .id = id, .instance = instance });
        if (!found) {
                if (!auto_init) goto not_init;
                goto do_init;
@@ -454,7 +454,7 @@ void fr_tls_engine_load_builtin(void)
        /*
         *      Mitigate against CrossTalk (CVE-2020-0543)
         */
-       if (!tls_engines || !rbtree_find_data(tls_engines, &(tls_engine_t){ .id = "rdrand" })) {
+       if (!tls_engines || !rbtree_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 ffe64276e03dd2a96075403e898af192bed173b5..de1f55d1e3aee07ddf28e1775f15f1a4df2d5c76 100644 (file)
--- a/src/lib/unlang/xlat_builtin.c
+++ b/src/lib/unlang/xlat_builtin.c
@@ -119,7 +119,7 @@ xlat_t *xlat_func_find(char const *in, ssize_t inlen)
        if (!xlat_root) return NULL;
 
        if (inlen < 0) {
-               return rbtree_find_data(xlat_root, &(xlat_t){ .name = in });
+               return rbtree_find(xlat_root, &(xlat_t){ .name = in });
        }
 
        if ((size_t) inlen >= sizeof(buffer)) return NULL;
@@ -127,7 +127,7 @@ xlat_t *xlat_func_find(char const *in, ssize_t inlen)
        memcpy(buffer, in, inlen);
        buffer[inlen] = '\0';
 
-       return rbtree_find_data(xlat_root, &(xlat_t){ .name = buffer });
+       return rbtree_find(xlat_root, &(xlat_t){ .name = buffer });
 }
 
 
@@ -140,7 +140,7 @@ static int _xlat_func_talloc_free(xlat_t *xlat)
 {
        if (!xlat_root) return 0;
 
-       rbtree_delete_by_data(xlat_root, xlat);
+       rbtree_delete(xlat_root, xlat);
        if (rbtree_num_elements(xlat_root) == 0) TALLOC_FREE(xlat_root);
 
        return 0;
@@ -193,7 +193,7 @@ xlat_t *xlat_register_legacy(void *mod_inst, char const *name,
        /*
         *      If it already exists, replace the instance.
         */
-       c = rbtree_find_data(xlat_root, &(xlat_t){ .name = name });
+       c = rbtree_find(xlat_root, &(xlat_t){ .name = name });
        if (c) {
                if (c->internal) {
                        ERROR("%s: Cannot re-define internal expansion %s", __FUNCTION__, name);
@@ -255,7 +255,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_data(xlat_root, &(xlat_t){ .name = name });
+       c = rbtree_find(xlat_root, &(xlat_t){ .name = name });
        if (c) {
                if (c->internal) {
                        ERROR("%s: Cannot re-define internal expansion %s", __FUNCTION__, name);
@@ -480,7 +480,7 @@ void xlat_unregister(char const *name)
 
        if (!name || !xlat_root) return;
 
-       c = rbtree_find_data(xlat_root, &(xlat_t){ .name = name });
+       c = rbtree_find(xlat_root, &(xlat_t){ .name = name });
        if (!c) return;
 
        (void) talloc_get_type_abort(c, xlat_t);

diff --git a/src/lib/unlang/xlat_inst.c b/src/lib/unlang/xlat_inst.c
index f535b0321692d1a8c98cf47b603ba8d21a254583..2c8f951dd761631f612709744e9b9167c35336a7 100644 (file)
--- a/src/lib/unlang/xlat_inst.c
+++ b/src/lib/unlang/xlat_inst.c
@@ -165,7 +165,7 @@ static int _xlat_inst_detach(xlat_inst_t *inst)
         *      Remove permanent data from the instance tree.
         */
        if (!inst->node->call.ephemeral) {
-               rbtree_delete_by_data(xlat_inst_tree, inst);
+               rbtree_delete(xlat_inst_tree, inst);
                if (rbtree_num_elements(xlat_inst_tree) == 0) TALLOC_FREE(xlat_inst_tree);
        }
 
@@ -329,7 +329,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_data(xlat_thread_inst_tree, &(xlat_thread_inst_t){ .node = node });
+       found = rbtree_find(xlat_thread_inst_tree, &(xlat_thread_inst_t){ .node = node });
        fr_assert(found);
 
        return found;

diff --git a/src/lib/util/dl.c b/src/lib/util/dl.c
index dbedc6277c137edde2a7f577dd5db75639bbe985..bdeba3e20ab2bf34ecba94e0dca911c3a9396fbb 100644 (file)
--- a/src/lib/util/dl.c
+++ b/src/lib/util/dl.c
@@ -428,7 +428,7 @@ static int _dl_free(dl_t *dl)
 
        dl->handle = NULL;
 
-       if (dl->in_tree) rbtree_delete_by_data(dl->loader->tree, dl);
+       if (dl->in_tree) rbtree_delete(dl->loader->tree, dl);
 
        return 0;
 }
@@ -458,7 +458,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_data(dl_loader->tree, &(dl_t){ .name = name });
+       dl = rbtree_find(dl_loader->tree, &(dl_t){ .name = name });
        if (dl) {
                talloc_increase_ref_count(dl);
                return dl;

diff --git a/src/lib/util/event.c b/src/lib/util/event.c
index 4d5743f999c5c1c04d97dac09b72cb42222383c2..ef1e6daf3d01c3c6483108875e346e7515ba0c61 100644 (file)
--- a/src/lib/util/event.c
+++ b/src/lib/util/event.c
@@ -725,7 +725,7 @@ static int _event_fd_delete(fr_event_fd_t *ef)
                        }
                }
 
-               rbtree_delete_by_data(el->fds, ef);
+               rbtree_delete(el->fds, ef);
                ef->is_registered = false;
        }
 
@@ -787,7 +787,7 @@ int _fr_event_fd_move(NDEBUG_LOCATION_ARGS
        /*
         *      Ensure this exists
         */
-       ef = rbtree_find_data(src->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+       ef = rbtree_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;
@@ -833,7 +833,7 @@ int _fr_event_filter_update(NDEBUG_LOCATION_ARGS
        struct kevent           evset[10];
        int                     count = 0;
 
-       ef = rbtree_find_data(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+       ef = rbtree_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;
@@ -929,7 +929,7 @@ int _fr_event_filter_insert(NDEBUG_LOCATION_ARGS
        }
 
        if (!ef_out || !*ef_out) {
-               ef = rbtree_find_data(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+               ef = rbtree_find(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
        } else {
                ef = *ef_out;
                fr_assert((fd < 0) || (ef->fd == fd));
@@ -1088,7 +1088,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_data(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+       ef = rbtree_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;
@@ -1126,7 +1126,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_data(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+       ef = rbtree_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;
@@ -1156,7 +1156,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_data(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+       ef = rbtree_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;
@@ -2425,7 +2425,7 @@ 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_data(locations[i], &find);
+                               counter = rbtree_find(locations[i], &find);
                                if (!counter) {
                                        counter = talloc(locations[i], fr_event_counter_t);
                                        if (!counter) goto oom;

diff --git a/src/lib/util/rbtree.c b/src/lib/util/rbtree.c
index 13066c3fbb7bee8e72db552f4b8c32545942949a..f55b403c84040917d0a4e4aea4da7ddc31ee6622 100644 (file)
--- a/src/lib/util/rbtree.c
+++ b/src/lib/util/rbtree.c
@@ -56,6 +56,8 @@ struct rbtree_s {
 #  define RBTREE_MAGIC (0x5ad09c42)
 #endif
 
+static fr_rb_node_t    *rbtree_insert_node(rbtree_t *tree, void *data) CC_HINT(nonnull);
+
 static inline void rbtree_free_data(rbtree_t *tree, fr_rb_node_t *node)
 {
        if (!tree->free || unlikely(node->being_freed)) return;
@@ -314,7 +316,7 @@ static void insert_fixup(rbtree_t *tree, fr_rb_node_t *x)
 /** Insert an element into the tree
  *
  */
-fr_rb_node_t *rbtree_insert_node(rbtree_t *tree, void *data)
+static fr_rb_node_t *rbtree_insert_node(rbtree_t *tree, void *data)
 {
        fr_rb_node_t *current, *parent, *x;
 
@@ -570,36 +572,11 @@ static void rbtree_delete_internal(rbtree_t *tree, fr_rb_node_t *z, bool skiploc
        }
 }
 
-void rbtree_delete(rbtree_t *tree, fr_rb_node_t *z)
-{
-       if (unlikely(tree->being_freed) || unlikely(z->being_freed)) return;
-
-       rbtree_delete_internal(tree, z, false);
-}
-
-/** Delete a node from the tree, based on given data, which MUST have come from rbtree_find_data().
- *
- *
- */
-bool rbtree_delete_by_data(rbtree_t *tree, void const *data)
-{
-       fr_rb_node_t *node;
-
-       if (unlikely(tree->being_freed)) return false;
-
-       node = rbtree_find(tree, data);
-       if (!node) return false;
-
-       rbtree_delete(tree, node);
-
-       return true;
-}
-
 
 /* Find user data, returning the node
  *
  */
-fr_rb_node_t *rbtree_find(rbtree_t *tree, void const *data)
+static fr_rb_node_t *rbtree_find_node(rbtree_t *tree, void const *data)
 {
        fr_rb_node_t *current;
 
@@ -628,18 +605,38 @@ fr_rb_node_t *rbtree_find(rbtree_t *tree, void const *data)
  *
  * @hidecallergraph
  */
-void *rbtree_find_data(rbtree_t *tree, void const *data)
+void *rbtree_find(rbtree_t *tree, void const *data)
 {
        fr_rb_node_t *x;
 
        if (unlikely(tree->being_freed)) return NULL;
 
-       x = rbtree_find(tree, data);
+       x = rbtree_find_node(tree, data);
        if (!x) return NULL;
 
        return x->data;
 }
 
+/** Delete a node from the tree, based on given data
+ *
+ *
+ */
+bool rbtree_delete(rbtree_t *tree, void const *data)
+{
+       fr_rb_node_t *node;
+
+       if (unlikely(tree->being_freed)) return false;
+
+       node = rbtree_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);
+
+       return true;
+}
+
 /** Return how many nodes there are in a tree
  *
  * @param[in] tree     to return node count for.

diff --git a/src/lib/util/rbtree.h b/src/lib/util/rbtree.h
index 27536403de13124c2944b20d77e7bf1cf3960c0a..e1d6b3a7a651f25c71522b1fa469828bdaec9d1f 100644 (file)
--- a/src/lib/util/rbtree.h
+++ b/src/lib/util/rbtree.h
@@ -110,16 +110,10 @@ void              rbtree_node_talloc_free(void *data) CC_HINT(nonnull);
 
 bool           rbtree_insert(rbtree_t *tree, void const *data) CC_HINT(nonnull);
 
-fr_rb_node_t   *rbtree_insert_node(rbtree_t *tree, void *data) CC_HINT(nonnull);
-
-void           rbtree_delete(rbtree_t *tree, fr_rb_node_t *z) CC_HINT(nonnull);
-
-bool           rbtree_delete_by_data(rbtree_t *tree, void const *data) CC_HINT(nonnull);
-
-fr_rb_node_t   *rbtree_find(rbtree_t *tree, void const *data) CC_HINT(nonnull);
+bool           rbtree_delete(rbtree_t *tree, void const *data) CC_HINT(nonnull);
 
 /** @hidecallergraph */
-void           *rbtree_find_data(rbtree_t *tree, void const *data) CC_HINT(nonnull);
+void           *rbtree_find(rbtree_t *tree, void const *data) CC_HINT(nonnull);
 
 uint64_t       rbtree_num_elements(rbtree_t *tree) CC_HINT(nonnull);
 

diff --git a/src/modules/proto_bfd/proto_bfd.c b/src/modules/proto_bfd/proto_bfd.c
index da13be305ada275175487ed7ff588870b1705a9c..1a274cf11cd75986f53cb23e383d85be592dc539 100644 (file)
--- a/src/modules/proto_bfd/proto_bfd.c
+++ b/src/modules/proto_bfd/proto_bfd.c
@@ -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_by_data(sock->session_tree, session);
+                       rbtree_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_data(sock->session_tree, &my_session);
+       session = rbtree_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_data(sock->session_tree, &my_session) != NULL) {
+              if (rbtree_find(sock->session_tree, &my_session) != NULL) {
                       cf_log_err(ci, "Peers must have unique IP addresses");
                       return -1;
               }

diff --git a/src/modules/proto_ldap_sync/sync.c b/src/modules/proto_ldap_sync/sync.c
index 457361028751e64cbfee454d597c33536fa6ea11..a7168b334d179c47867b824172305d4c13d87c5b 100644 (file)
--- a/src/modules/proto_ldap_sync/sync.c
+++ b/src/modules/proto_ldap_sync/sync.c
@@ -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_data(tree, &find);
+                       sync = rbtree_find(tree, &find);
                        if (!sync) {
                                WARN("Ignoring msgid %i, doesn't match any outstanding syncs",
                                     find.msgid);
@@ -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_by_data(tree, &find);
+       rbtree_delete(tree, &find);
 
        return 0;
 }
@@ -918,7 +918,7 @@ void sync_state_destroy(fr_ldap_connection_t *conn, int msgid)
 
        find.msgid = msgid;
 
-       sync = rbtree_find_data(tree, &find);
+       sync = rbtree_find(tree, &find);
        talloc_free(sync);      /* Will inform the server */
 }
 
@@ -938,7 +938,7 @@ sync_config_t const *sync_state_config_get(fr_ldap_connection_t *conn, int msgid
 
        find.msgid = msgid;
 
-       sync = rbtree_find_data(tree, &find);
+       sync = rbtree_find(tree, &find);
        return sync->config;
 }
 

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 e86b71733ae3fca700a3f7f62260707715a86ba0..3cfdb5407e450a72e33b130105b0a7025ec62ea6 100644 (file)
--- 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
@@ -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_by_data(driver->cache, c);
+               rbtree_delete(driver->cache, c);
                talloc_free(c);
        }
 
        /*
         *      Is there an entry for this key?
         */
-       c = rbtree_find_data(driver->cache, &(rlm_cache_entry_t){ .key = key, .key_len = key_len });
+       c = rbtree_find(driver->cache, &(rlm_cache_entry_t){ .key = key, .key_len = key_len });
        if (!c) {
                *out = NULL;
                return CACHE_MISS;
@@ -207,11 +207,11 @@ static cache_status_t cache_entry_expire(UNUSED rlm_cache_config_t const *config
 
        if (!request) return CACHE_ERROR;
 
-       c = rbtree_find_data(driver->cache, &(rlm_cache_entry_t){ .key = key, .key_len = key_len });
+       c = rbtree_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_by_data(driver->cache, c);
+       rbtree_delete(driver->cache, c);
        talloc_free(c);
 
        return CACHE_OK;
@@ -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_by_data(driver->cache, c);
+               rbtree_delete(driver->cache, c);
                RERROR("Failed adding entry to expiry heap");
 
                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_by_data(driver->cache, c);        /* make sure we don't leak entries... */
+               rbtree_delete(driver->cache, c);        /* make sure we don't leak entries... */
                RERROR("Failed updating entry TTL.  Entry was forcefully expired");
                return CACHE_ERROR;
        }

diff --git a/src/modules/rlm_csv/rlm_csv.c b/src/modules/rlm_csv/rlm_csv.c
index 974cd6587671b9d9a233ead30d589bb9693932a7..ea641cb947da7094025e7e5835fdedcf3eafcbc4 100644 (file)
--- a/src/modules/rlm_csv/rlm_csv.c
+++ b/src/modules/rlm_csv/rlm_csv.c
@@ -183,7 +183,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_data(inst->tree, &my_e);
+       return rbtree_find(inst->tree, &my_e);
 }
 
 static bool insert_entry(CONF_SECTION *conf, rlm_csv_t *inst, rlm_csv_entry_t *e, int lineno)

diff --git a/src/modules/rlm_files/rlm_files.c b/src/modules/rlm_files/rlm_files.c
index f395f0a6b068b11acd84978abdefca217227e7e2..f15f71f70c684933c9922b8ac3ea801e29749985 100644 (file)
--- a/src/modules/rlm_files/rlm_files.c
+++ b/src/modules/rlm_files/rlm_files.c
@@ -265,7 +265,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_data(tree, &search_list);
+               user_list = rbtree_find(tree, &search_list);
                if (!user_list) {
                        user_list = talloc_zero(ctx, PAIR_LIST_LIST);
                        pairlist_list_init(user_list);
@@ -328,10 +328,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_data(tree, &my_list);
+       user_list = rbtree_find(tree, &my_list);
        user_pl = (user_list) ? fr_dlist_head(&user_list->head) : NULL;
        my_list.name = "DEFAULT";
-       default_list = rbtree_find_data(tree, &my_list);
+       default_list = rbtree_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 f3433e3a24377c2d0d082a05325954d0cfd6ea59..6bc02bf3fcc3bcbfe0edabe04fd9934c4ce1943d 100644 (file)
--- a/src/modules/rlm_icmp/rlm_icmp.c
+++ b/src/modules/rlm_icmp/rlm_icmp.c
@@ -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_by_data(thread->t->tree, echo);
+       (void) rbtree_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_by_data(thread->t->tree, echo);
+       (void) rbtree_delete(thread->t->tree, echo);
        talloc_free(echo);
 }
 
@@ -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_by_data(thread->t->tree, echo);
+               (void) rbtree_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_by_data(thread->t->tree, echo);
+               (void) rbtree_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_by_data(thread->t->tree, echo);
+               (void) rbtree_delete(thread->t->tree, echo);
                talloc_free(echo);
                return XLAT_ACTION_FAIL;
        }
@@ -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_data(t->tree, &my_echo);
+       echo = rbtree_find(t->tree, &my_echo);
        if (!echo) {
                DEBUG("Can't find packet counter=%d in tree", icmp->counter);
                return;
        }
 
-       (void) rbtree_delete_by_data(t->tree, echo);
+       (void) rbtree_delete(t->tree, echo);
 
        /*
         *      We have a reply!

diff --git a/src/modules/rlm_radius/track.c b/src/modules/rlm_radius/track.c
index 0926a5f08f8f3281d963931d47835ae2b8d58924..c66040415d50a3a90fdbfd0539a46ab1742fccb2 100644 (file)
--- a/src/modules/rlm_radius/track.c
+++ b/src/modules/rlm_radius/track.c
@@ -241,7 +241,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_by_data(tt->subtree[te->id], te);
+               if (tt->subtree[te->id]) (void) rbtree_delete(tt->subtree[te->id], te);
 
                goto done;
        }
@@ -255,7 +255,7 @@ int radius_track_entry_release(
         *      Delete it from the tracking subtree.
         */
        fr_assert(tt->subtree[te->id] != NULL);
-       (void) rbtree_delete_by_data(tt->subtree[te->id], te);
+       (void) rbtree_delete(tt->subtree[te->id], te);
 
        /*
         *      Try to free memory if the system gets idle.  If the
@@ -297,7 +297,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_by_data(tt->subtree[te->id], te);
+       if (tt->subtree[te->id]) (void) rbtree_delete(tt->subtree[te->id], te);
 
        memcpy(te->vector, vector, sizeof(te->vector));
 
@@ -362,7 +362,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_data(tt->subtree[packet_id], &my_te);
+       te = rbtree_find(tt->subtree[packet_id], &my_te);
 
        /*
         *      Not found, the packet MAY have been allocated in the

diff --git a/src/modules/rlm_securid/mem.c b/src/modules/rlm_securid/mem.c
index 1eae4c9009ee0717df0a0cd7a752aa2b77e8c72a..4bea06bee6360a09739eb2566f92642fa9dbe0f1 100644 (file)
--- a/src/modules/rlm_securid/mem.c
+++ b/src/modules/rlm_securid/mem.c
@@ -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_data(inst->session_tree, session) == session);
+       fr_assert(rbtree_find(inst->session_tree, session) == session);
 
        /*
         *      Delete old session from the tree.
         */
-       rbtree_delete_by_data(inst->session_tree, node);
+       rbtree_delete(inst->session_tree, node);
 
        /*
         *      And unsplice it from the linked list.
@@ -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_by_data(inst->session_tree, session);
+                       rbtree_delete(inst->session_tree, session);
 
                        /*
                         *      session == inst->session_head

diff --git a/src/modules/rlm_sigtran/sccp.c b/src/modules/rlm_sigtran/sccp.c
index 99f62a5c4f325db286a01d527373e385ebd495c3..9cc565e84b8f8a188d84a1c2148f8a2412887a3c 100644 (file)
--- a/src/modules/rlm_sigtran/sccp.c
+++ b/src/modules/rlm_sigtran/sccp.c
@@ -81,7 +81,7 @@ static void sigtran_tcap_timeout(void *data)
        /*
         *      Remove the outstanding transaction
         */
-       if (!rbtree_delete_by_data(txn_tree, txn)) ERROR("Transaction removed before timeout");
+       if (!rbtree_delete(txn_tree, txn)) ERROR("Transaction removed before timeout");
 
        txn->response.type = SIGTRAN_RESPONSE_FAIL;
 
@@ -248,7 +248,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_data(txn_tree, &find);
+       found = rbtree_find(txn_tree, &find);
        if (!found) {
                /*
                 *      Not an error, could be a retransmission
@@ -256,7 +256,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_by_data(txn_tree, found)) {          /* Remove the outstanding transaction */
+       if (!rbtree_delete(txn_tree, found)) {          /* Remove the outstanding transaction */
                ERROR("Failed removing transaction");
                fr_assert(0);
        }

diff --git a/src/modules/rlm_stats/rlm_stats.c b/src/modules/rlm_stats/rlm_stats.c
index 5e7e66229f14ca4c5675c6157da833f4b1ba3d91..ef3e29ee2f03318b22a2579747f8f868d8f40cbc 100644 (file)
--- a/src/modules/rlm_stats/rlm_stats.c
+++ b/src/modules/rlm_stats/rlm_stats.c
@@ -117,7 +117,7 @@ static void coalesce(uint64_t final_stats[FR_RADIUS_CODE_MAX], rlm_stats_thread_
         *      Bootstrap with my statistics, where we don't need a
         *      lock.
         */
-       stats = rbtree_find_data(*tree, mydata);
+       stats = rbtree_find(*tree, mydata);
        if (!stats) {
                memset(final_stats, 0, sizeof(uint64_t) * FR_RADIUS_CODE_MAX);
        } else {
@@ -136,7 +136,7 @@ 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_data(*tree, mydata);
+               stats = rbtree_find(*tree, mydata);
                if (!stats) {
                        continue;
                }
@@ -186,7 +186,7 @@ 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_data(t->src, &mydata);
+               stats = rbtree_find(t->src, &mydata);
                if (!stats) {
                        MEM(stats = talloc_zero(t, rlm_stats_data_t));
 
@@ -204,7 +204,7 @@ 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_data(t->dst, &mydata);
+               stats = rbtree_find(t->dst, &mydata);
                if (!stats) {
                        MEM(stats = talloc_zero(t, rlm_stats_data_t));
 

diff --git a/src/protocols/radius/list.c b/src/protocols/radius/list.c
index b91f14bad8a2dcf8e4e44fb4cece291b0f002507..4f86d3c17c78e09d7bb2b2ac2d30ef1e79d8d398 100644 (file)
--- a/src/protocols/radius/list.c
+++ b/src/protocols/radius/list.c
@@ -331,7 +331,7 @@ fr_radius_packet_t *fr_packet_list_find(fr_packet_list_t *pl, fr_radius_packet_t
 {
        if (!pl || !request) return 0;
 
-       return rbtree_find_data(pl->tree, request);
+       return rbtree_find(pl->tree, request);
 }
 
 
@@ -373,7 +373,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_data(pl->tree, request);
+       return rbtree_find(pl->tree, request);
 }
 
 
@@ -381,7 +381,7 @@ bool fr_packet_list_yank(fr_packet_list_t *pl, fr_radius_packet_t *request)
 {
        if (!pl || !request) return false;
 
-       return rbtree_delete_by_data(pl->tree, request);
+       return rbtree_delete(pl->tree, request);
 }
 
 uint32_t fr_packet_list_num_elements(fr_packet_list_t *pl)

diff --git a/src/tests/rbmonkey.c b/src/tests/rbmonkey.c
index c6b3a1677fc2b7470250a56db028128a07025c1d..73c8f768bd5ec2b9d671ddd798e41a2713efa429 100644 (file)
--- a/src/tests/rbmonkey.c
+++ b/src/tests/rbmonkey.c
@@ -168,7 +168,7 @@ again:
         * For testing deletebydata instead
 
         for (i = 0; i < n; i++) {
-               if (filter_cb(&vals[i], &thresh) == 2) rbtree_delete_by_data(t, &vals[i]);
+               if (filter_cb(&vals[i], &thresh) == 2) rbtree_delete(t, &vals[i]);
         }
 
         *