* something has gone very badly wrong.
*/
if (request->in_request_tree) {
- ret = rbtree_deletebydata(request_tree, request);
+ ret = rbtree_delete_by_data(request_tree, request);
RS_ASSERT(ret);
}
if (request->in_link_tree) {
- ret = rbtree_deletebydata(link_tree, request);
+ ret = rbtree_delete_by_data(link_tree, request);
RS_ASSERT(ret);
}
{
/* look for a matching request and use it for decoding */
search.expect = packet;
- original = rbtree_finddata(request_tree, &search);
+ original = rbtree_find_data(request_tree, &search);
/*
* Verify this code is allowed
if (!fr_pair_list_empty(&search.link_vps)) {
rs_request_t *tuple;
- original = rbtree_finddata(link_tree, &search);
- tuple = rbtree_finddata(request_tree, &search);
+ original = rbtree_find_data(link_tree, &search);
+ tuple = rbtree_find_data(request_tree, &search);
/*
* If the packet we matched using attributes is not the same
* Detect duplicates using the normal 5-tuple of src/dst ips/ports id
*/
} else {
- original = rbtree_finddata(request_tree, &search);
+ original = rbtree_find_data(request_tree, &search);
if (original && (memcmp(original->expect->vector, packet->vector,
sizeof(original->expect->vector)) != 0)) {
/*
/* Request may need to be reinserted as the 5 tuple of the response may of changed */
if (rs_packet_cmp(original, &search) != 0) {
- rbtree_deletebydata(request_tree, original);
+ rbtree_delete_by_data(request_tree, original);
}
/* replace expected packets and vps */
static int track_dedup_free(fr_io_track_t *track)
{
fr_assert(track->client->table != NULL);
- fr_assert(rbtree_finddata(track->client->table, track) != NULL);
+ fr_assert(rbtree_find_data(track->client->table, track) != NULL);
- if (!rbtree_deletebydata(track->client->table, track)) {
+ if (!rbtree_delete_by_data(track->client->table, track)) {
fr_assert(0);
}
/*
* No existing duplicate. Return the new tracking entry.
*/
- old = rbtree_finddata(client->table, track);
+ old = rbtree_find_data(client->table, track);
if (!old) goto do_insert;
fr_assert(old->client == client);
} else {
fr_assert(client == old->client);
- if (!rbtree_deletebydata(client->table, old)) {
+ if (!rbtree_delete_by_data(client->table, old)) {
fr_assert(0);
}
if (old->ev) (void) fr_event_timer_delete(&old->ev);
{
fr_network_socket_t *s;
- s = rbtree_finddata(nr->sockets, &(fr_network_socket_t){ .listen = li });
+ s = rbtree_find_data(nr->sockets, &(fr_network_socket_t){ .listen = li });
if (!s) return -1;
fr_network_socket_dead(nr, s);
(void) talloc_get_type_abort(nr, fr_network_t);
(void) talloc_get_type_abort_const(li, fr_listen_t);
- s = rbtree_finddata(nr->sockets, &(fr_network_socket_t){ .listen = li });
+ s = rbtree_find_data(nr->sockets, &(fr_network_socket_t){ .listen = li });
if (!s) return;
/*
fr_network_t *nr = s->nr;
fr_channel_data_t *cd;
- rbtree_deletebydata(nr->sockets, s);
- rbtree_deletebydata(nr->sockets_by_num, s);
+ rbtree_delete_by_data(nr->sockets, s);
+ rbtree_delete_by_data(nr->sockets_by_num, s);
fr_event_fd_delete(nr->el, s->listen->fd, s->filter);
fr_assert(data_size == sizeof(my_inject));
memcpy(&my_inject, data, data_size);
- s = rbtree_finddata(nr->sockets, &(fr_network_socket_t){ .listen = my_inject.listen });
+ s = rbtree_find_data(nr->sockets, &(fr_network_socket_t){ .listen = my_inject.listen });
if (!s) {
talloc_free(my_inject.packet); /* MUST be it's own TALLOC_CTX */
return;
* @todo - cache this somewhere so we don't need
* to do an rbtree lookup for every packet.
*/
- s = rbtree_finddata(nr->sockets, &(fr_network_socket_t){ .listen = li });
+ s = rbtree_find_data(nr->sockets, &(fr_network_socket_t){ .listen = li });
/*
* This shouldn't happen, but be safe...
size_t len;
size_t i;
- len = rbtree_flatten(nr, (void ***)&sockets, nr->sockets, RBTREE_IN_ORDER);
+ if (rbtree_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]);
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%u\n", rbtree_num_elements(nr->sockets));
+ fprintf(fp, "count.sockets\t%"PRIu64"\n", rbtree_num_elements(nr->sockets));
return 0;
}
fr_network_t const *nr = ctx;
fr_network_socket_t *s;
- s = rbtree_finddata(nr->sockets_by_num, &(fr_network_socket_t){ .number = info->box[0]->vb_uint32 });
+ s = rbtree_find_data(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;
*/
if (request->time_order_id >= 0) (void) fr_heap_extract(worker->time_order, request);
if (request->runnable_id >= 0) (void) fr_heap_extract(worker->runnable, request);
- if (request->async->listen && request->async->listen->track_duplicates) rbtree_deletebydata(worker->dedup, request);
+ if (request->async->listen && request->async->listen->track_duplicates) rbtree_delete_by_data(worker->dedup, request);
#ifndef NDEBUG
request->async->process = NULL;
if (request->async->listen->track_duplicates) {
request_t *old;
- old = rbtree_finddata(worker->dedup, request);
+ old = rbtree_find_data(worker->dedup, request);
if (!old) {
/*
* Ignore duplicate packets where we've
* then, only some of the time.
*/
if (request_is_external(request) && request->async->listen->track_duplicates) {
- (void) rbtree_deletebydata(worker->dedup, request);
+ (void) rbtree_delete_by_data(worker->dedup, request);
}
now = fr_time();
do { \
(_node)->is_active = false; \
(_node)->is_master = false; \
- rbtree_deletebydata(cluster->used_nodes, _node); \
+ rbtree_delete_by_data(cluster->used_nodes, _node); \
fr_fifo_push(cluster->free_nodes, _node); \
} while (0)
memset(&tmpl_slot, 0, sizeof(tmpl_slot));
SET_ADDR(find.addr, map->element[2]);
- found = rbtree_finddata(cluster->used_nodes, &find);
+ found = rbtree_find_data(cluster->used_nodes, &find);
if (found) {
active[found->id] = true;
goto reuse_master_node;
*/
for (j = 3; (j < map->elements); j++) {
SET_ADDR(find.addr, map->element[j]);
- found = rbtree_finddata(cluster->used_nodes, &find);
+ found = rbtree_find_data(cluster->used_nodes, &find);
if (found) {
active[found->id] = true;
goto next;
if (cluster->node[i].is_active) {
/* Sanity check for duplicates that are active */
- found = rbtree_finddata(cluster->used_nodes, &cluster->node[i]);
+ found = rbtree_find_data(cluster->used_nodes, &cluster->node[i]);
fr_assert(found);
fr_assert(found->is_active);
fr_assert(found->id == i);
* If we have already have a pool for the
* host we were redirected to, use that.
*/
- found = rbtree_finddata(cluster->used_nodes, &find);
+ found = rbtree_find_data(cluster->used_nodes, &find);
if (found) {
/* We have the new pool, don't need to hold the lock */
pthread_mutex_unlock(&cluster->mutex);
fr_redis_cluster_node_t *node;
fr_redis_cluster_key_slot_t const *key_slot;
uint8_t first, i;
- int used_nodes;
+ uint64_t used_nodes;
fr_assert(cluster);
fr_assert(state);
find.addr.inet.dst_port = node_addr->inet.dst_port;
pthread_mutex_lock(&cluster->mutex);
- found = rbtree_finddata(cluster->used_nodes, &find);
+ found = rbtree_find_data(cluster->used_nodes, &find);
if (!found) {
fr_redis_cluster_node_t *spare;
char buffer[INET6_ADDRSTRLEN];
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)
{
- size_t in_use = rbtree_num_elements(cluster->used_nodes);
+ uint64_t in_use = rbtree_num_elements(cluster->used_nodes);
fr_rb_tree_iter_inorder_t iter;
fr_redis_cluster_node_t *node;
uint8_t count;
CONF_PAIR *cp;
int af = AF_UNSPEC; /* AF of first server */
- int num_nodes;
+ uint64_t num_nodes;
fr_redis_cluster_t *cluster;
fr_assert(triggers_enabled || !trigger_prefix);
if (stat(filename, &my_file.buf) < 0) goto error;
- file = rbtree_finddata(tree, &my_file);
+ file = rbtree_find_data(tree, &my_file);
/*
* The file was previously read by including it
if (gid != 0) conf_check_gid = gid;
}
-/*
- * See if any of the files have changed.
- */
-int cf_file_changed(CONF_SECTION *cs, fr_rb_walker_t callback)
-{
- CONF_SECTION *top, *modules;
- rbtree_t *tree;
- cf_file_t *file;
- int rcode;
- struct stat buf;
- fr_rb_tree_iter_inorder_t iter;
-
- top = cf_root(cs);
- tree = cf_data_value(cf_data_find(top, rbtree_t, "filename"));
- if (!tree) return CF_FILE_ERROR;
-
- rcode = CF_FILE_NONE;
- modules = cf_section_find(cs, "modules", NULL);
-
- for (file = rbtree_iter_init_inorder(&iter, tree);
- file;
- file = rbtree_iter_next_inorder(&iter)) {
- /*
- * The file doesn't exist or we can no longer read it.
- */
- if (stat(file->filename, &buf) < 0) {
- rcode = CF_FILE_ERROR;
- rbtree_iter_done(&iter);
- break;
- }
-
- /*
- * The file changed, we'll need to re-read it.
- */
- if (buf.st_mtime != file->buf.st_mtime) {
- if (callback(modules, file->cs)) {
- rcode |= CF_FILE_MODULE;
- DEBUG3("HUP: Changed module file %s", file->filename);
- } else {
- DEBUG3("HUP: Changed config file %s", file->filename);
- rcode |= CF_FILE_CONFIG;
- }
- }
- }
-
- return rcode;
-}
-
-
static char const parse_tabs[] = " ";
static ssize_t cf_string_write(FILE *fp, char const *string, size_t len, fr_token_t t)
bool cf_file_check(CONF_SECTION *cs, char const *filename, bool check_perms);
void cf_file_check_user(uid_t uid, gid_t gid);
-int cf_file_changed(CONF_SECTION *cs, fr_rb_walker_t callback);
/*
* Config file writing
/*
* No ident2, use the ident1 tree.
*/
- if (IS_WILDCARD(ident2)) return rbtree_finddata(parent->ident1, find);
+ if (IS_WILDCARD(ident2)) return rbtree_find_data(parent->ident1, find);
/*
* Both ident1 and ident2 use the ident2 tree.
*/
- return rbtree_finddata(parent->ident2, find);
+ return rbtree_find_data(parent->ident2, find);
}
/** Return the next child that's of the specified type with the specified identifiers
fr_dlist_remove(&parent->children, found);
if (!fr_cond_assert(found == child)) return NULL;
- in_ident1 = (rbtree_finddata(parent->ident1, child) == child);
- if (in_ident1 && (!rbtree_deletebydata(parent->ident1, child))) {
+ in_ident1 = (rbtree_find_data(parent->ident1, child) == child);
+ if (in_ident1 && (!rbtree_delete_by_data(parent->ident1, child))) {
fr_assert(0);
return NULL;
}
- in_ident2 = (rbtree_finddata(parent->ident2, child) == child);
- if (in_ident2 && (!rbtree_deletebydata(parent->ident2, child))) {
+ in_ident2 = (rbtree_find_data(parent->ident2, child) == child);
+ if (in_ident2 && (!rbtree_delete_by_data(parent->ident2, child))) {
fr_assert(0);
return NULL;
}
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 (%u entries)", ci->ident1, ci->ident1 ? rbtree_num_elements(ci->ident1) : 0);
- DEBUG(" ident2 tree : %p (%u entries)", ci->ident2, ci->ident2 ? rbtree_num_elements(ci->ident2) : 0);
+ 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);
if (fr_dlist_empty(&ci->children)) return;
while ((child = fr_dlist_next(&ci->children, child))) {
char const *in_ident1, *in_ident2;
- in_ident1 = rbtree_finddata(ci->ident1, child) == child? "in ident1 " : "";
- in_ident2 = rbtree_finddata(ci->ident2, child) == child? "in ident2 " : "";
+ in_ident1 = rbtree_find_data(ci->ident1, child) == child? "in ident1 " : "";
+ in_ident2 = rbtree_find_data(ci->ident2, child) == child? "in ident2 " : "";
switch (child->type) {
case CONF_ITEM_SECTION:
}
}
- old = rbtree_finddata(clients->tree[client->ipaddr.prefix], client);
+ old = rbtree_find_data(clients->tree[client->ipaddr.prefix], client);
#endif
if (old) {
/*
if (!clients->tree[client->ipaddr.prefix]) return;
- (void) rbtree_deletebydata(clients->tree[client->ipaddr.prefix], client);
+ (void) rbtree_delete_by_data(clients->tree[client->ipaddr.prefix], client);
#endif
}
my_client.ipaddr = *ipaddr;
fr_ipaddr_mask(&my_client.ipaddr, i);
- client = rbtree_finddata(clients->tree[i], &my_client);
+ client = rbtree_find_data(clients->tree[i], &my_client);
if (client) {
return client;
}
if (dl_inst_cache.data == data) return dl_inst_cache.inst;
- return rbtree_finddata(dl_module_loader->inst_data_tree, &(dl_module_inst_t){ .data = UNCONST(void *, data) });
+ return rbtree_find_data(dl_module_loader->inst_data_tree, &(dl_module_inst_t){ .data = UNCONST(void *, data) });
}
/** Lookup instance name via instance data
}
if (dl_module->in_tree) {
- rbtree_deletebydata(dl_module_loader->module_tree, dl_module);
+ rbtree_delete_by_data(dl_module_loader->module_tree, dl_module);
dl_module->in_tree = false;
}
/*
* If the module's already been loaded, increment the reference count.
*/
- dl_module = rbtree_finddata(dl_module_loader->module_tree,
+ dl_module = rbtree_find_data(dl_module_loader->module_tree,
&(dl_module_t){ .dl = &(dl_t){ .name = module_name }});
if (dl_module) {
talloc_free(module_name);
* Remove this instance from the tracking tree.
*/
fr_assert(dl_module_loader != NULL);
- rbtree_deletebydata(dl_module_loader->inst_data_tree, dl_inst);
+ rbtree_delete_by_data(dl_module_loader->inst_data_tree, dl_inst);
/*
* Decrements the reference count. The module object
}
last_hup = when;
-#if 0
- rcode = cf_file_changed(cs_cache->cs, hup_callback);
- if (rcode == CF_FILE_NONE) {
- INFO("HUP - No files changed. Ignoring");
- return;
- }
-
- if (rcode == CF_FILE_ERROR) {
- INFO("HUP - Cannot read configuration files. Ignoring");
- return;
- }
-#endif
-
INFO("HUP - NYI in version 4"); /* Not yet implemented in v4 */
}
strlcpy(find.name, proc->name, sizeof(find.name));
find.length = strlen(find.name);
- found = rbtree_finddata(map_proc_root, &find);
+ found = rbtree_find_data(map_proc_root, &find);
if (!found) return 0;
- rbtree_deletebydata(map_proc_root, found);
+ rbtree_delete_by_data(map_proc_root, found);
return 0;
}
strlcpy(find.name, name, sizeof(find.name));
find.length = strlen(find.name);
- return rbtree_finddata(map_proc_root, &find);
+ return rbtree_find_data(map_proc_root, &find);
}
/** Register a map processor
{
module_method_entry_t *found, find = { .id = id, .method = method };
- found = rbtree_finddata(set->tree, &find);
+ found = rbtree_find_data(set->tree, &find);
if (found) {
if (unlikely(found->method != method)) {
fr_strerror_printf("Conflict for method id %u (old %p vs new %p)",
{
module_method_entry_t *found;
- found = rbtree_finddata(set->tree, &(module_method_entry_t){ .id = id });
+ found = rbtree_find_data(set->tree, &(module_method_entry_t){ .id = id });
if (!found) return NULL;
return found->method;
inst_name = asked_name;
if (inst_name[0] == '-') inst_name++;
- inst = rbtree_finddata(module_instance_name_tree,
+ inst = rbtree_find_data(module_instance_name_tree,
&(module_instance_t){
.dl_inst = &(dl_module_inst_t){ .parent = parent ? parent->dl_inst : NULL },
.name = inst_name
{
module_instance_t *mi;
- mi = rbtree_finddata(module_instance_data_tree,
+ mi = rbtree_find_data(module_instance_data_tree,
&(module_instance_t){
.dl_inst = &(dl_module_inst_t){ .data = UNCONST(void *, data) },
});
{
DEBUG3("Freeing %s (%p)", mi->name, mi);
- if (mi->in_name_tree) if (!fr_cond_assert(rbtree_deletebydata(module_instance_name_tree, mi))) return 1;
- if (mi->in_data_tree) if (!fr_cond_assert(rbtree_deletebydata(module_instance_data_tree, mi))) return 1;
+ 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->mutex) {
/*
* FIXME
fr_dlist_remove(&state->to_expire, entry);
- rbtree_deletebydata(state->tree, entry);
+ rbtree_delete_by_data(state->tree, entry);
DEBUG4("State ID %" PRIu64 " unlinked", entry->id);
}
*/
my_entry.state_comp.server_hash ^= fr_hash_string(cf_section_name2(request->server_cs));
- entry = rbtree_finddata(state->tree, &my_entry);
+ entry = rbtree_find_data(state->tree, &my_entry);
if (entry) (void) talloc_get_type_abort(entry, fr_state_entry_t);
/** Return number of entries we're currently tracking
*
*/
-uint32_t fr_state_entries_tracked(fr_state_tree_t *state)
+uint64_t fr_state_entries_tracked(fr_state_tree_t *state)
{
- return (uint32_t)rbtree_num_elements(state->tree);
+ return rbtree_num_elements(state->tree);
}
*/
uint64_t fr_state_entries_created(fr_state_tree_t *state);
uint64_t fr_state_entries_timeout(fr_state_tree_t *state);
-uint32_t fr_state_entries_tracked(fr_state_tree_t *state);
+uint64_t fr_state_entries_tracked(fr_state_tree_t *state);
#ifdef __cplusplus
}
pthread_mutex_lock(trigger_mutex);
- found = rbtree_finddata(trigger_last_fired_tree, &find);
+ found = rbtree_find_data(trigger_last_fired_tree, &find);
if (!found) {
MEM(found = talloc(NULL, trigger_last_fired_t));
found->ci = ci;
{
if (!listen_addr_root) return false;
- return rbtree_finddata(listen_addr_root, li);
+ return rbtree_find_data(listen_addr_root, li);
}
fr_virtual_namespace_t find = { .namespace = virtual_servers[i]->namespace };
fr_virtual_namespace_t *found;
- found = rbtree_finddata(vns_tree, &find);
+ found = rbtree_find_data(vns_tree, &find);
if (found) {
fr_assert(dict && (dict->dict == found->dict));
fr_assert(server_section_name_tree != NULL);
- old = rbtree_finddata(server_section_name_tree, entry);
+ old = rbtree_find_data(server_section_name_tree, entry);
if (old) return 0;
#ifndef NDEBUG
* define both "accounting on", and "accounting *".
*/
if (name2 != CF_IDENT_ANY) {
- entry = rbtree_finddata(server_section_name_tree,
+ entry = rbtree_find_data(server_section_name_tree,
&(virtual_server_compile_t) {
.name = name1,
.name2 = name2,
/*
* Then look up the wildcard, if we didn't find any matching name2.
*/
- entry = rbtree_finddata(server_section_name_tree,
+ entry = rbtree_find_data(server_section_name_tree,
&(virtual_server_compile_t) {
.name = name1,
.name2 = CF_IDENT_ANY,
} else {
tls_engine_t *found = NULL;
- found = rbtree_finddata(tls_engines, &(tls_engine_t){ .id = id, .instance = instance });
+ found = rbtree_find_data(tls_engines, &(tls_engine_t){ .id = id, .instance = instance });
if (found) {
fr_strerror_printf("engine %s%s%s%salready initialised", id,
instance ? " (" : "",
}
- found = rbtree_finddata(tls_engines, &(tls_engine_t){ .id = id, .instance = instance });
+ found = rbtree_find_data(tls_engines, &(tls_engine_t){ .id = id, .instance = instance });
if (!found) {
if (!auto_init) goto not_init;
goto do_init;
/*
* Mitigate against CrossTalk (CVE-2020-0543)
*/
- if (!tls_engines || !rbtree_finddata(tls_engines, &(tls_engine_t){ .id = "rdrand" })) {
+ if (!tls_engines || !rbtree_find_data(tls_engines, &(tls_engine_t){ .id = "rdrand" })) {
ENGINE *rand_engine;
ENGINE_register_all_RAND(); /* Give rand engines a chance to register */
if (!xlat_root) return NULL;
if (inlen < 0) {
- return rbtree_finddata(xlat_root, &(xlat_t){ .name = in });
+ return rbtree_find_data(xlat_root, &(xlat_t){ .name = in });
}
if ((size_t) inlen >= sizeof(buffer)) return NULL;
memcpy(buffer, in, inlen);
buffer[inlen] = '\0';
- return rbtree_finddata(xlat_root, &(xlat_t){ .name = buffer });
+ return rbtree_find_data(xlat_root, &(xlat_t){ .name = buffer });
}
{
if (!xlat_root) return 0;
- rbtree_deletebydata(xlat_root, xlat);
+ rbtree_delete_by_data(xlat_root, xlat);
if (rbtree_num_elements(xlat_root) == 0) TALLOC_FREE(xlat_root);
return 0;
/*
* If it already exists, replace the instance.
*/
- c = rbtree_finddata(xlat_root, &(xlat_t){ .name = name });
+ c = rbtree_find_data(xlat_root, &(xlat_t){ .name = name });
if (c) {
if (c->internal) {
ERROR("%s: Cannot re-define internal expansion %s", __FUNCTION__, name);
/*
* If it already exists, replace the instance.
*/
- c = rbtree_finddata(xlat_root, &(xlat_t){ .name = name });
+ c = rbtree_find_data(xlat_root, &(xlat_t){ .name = name });
if (c) {
if (c->internal) {
ERROR("%s: Cannot re-define internal expansion %s", __FUNCTION__, name);
if (!name || !xlat_root) return;
- c = rbtree_finddata(xlat_root, &(xlat_t){ .name = name });
+ c = rbtree_find_data(xlat_root, &(xlat_t){ .name = name });
if (!c) return;
(void) talloc_get_type_abort(c, xlat_t);
* Remove permanent data from the instance tree.
*/
if (!inst->node->call.ephemeral) {
- rbtree_deletebydata(xlat_inst_tree, inst);
+ rbtree_delete_by_data(xlat_inst_tree, inst);
if (rbtree_num_elements(xlat_inst_tree) == 0) TALLOC_FREE(xlat_inst_tree);
}
if (node->call.ephemeral) return node->call.thread_inst;
- found = rbtree_finddata(xlat_thread_inst_tree, &(xlat_thread_inst_t){ .node = node });
+ found = rbtree_find_data(xlat_thread_inst_tree, &(xlat_thread_inst_t){ .node = node });
fr_assert(found);
return found;
dl->handle = NULL;
- if (dl->in_tree) rbtree_deletebydata(dl->loader->tree, dl);
+ if (dl->in_tree) rbtree_delete_by_data(dl->loader->tree, dl);
return 0;
}
* There's already something in the tree,
* just return that instead.
*/
- dl = rbtree_finddata(dl_loader->tree, &(dl_t){ .name = name });
+ dl = rbtree_find_data(dl_loader->tree, &(dl_t){ .name = name });
if (dl) {
talloc_increase_ref_count(dl);
return dl;
/** Return the number of file descriptors is_registered with this event loop
*
*/
-int fr_event_list_num_fds(fr_event_list_t *el)
+uint64_t fr_event_list_num_fds(fr_event_list_t *el)
{
if (unlikely(!el)) return -1;
}
}
- rbtree_deletebydata(el->fds, ef);
+ rbtree_delete_by_data(el->fds, ef);
ef->is_registered = false;
}
/*
* Ensure this exists
*/
- ef = rbtree_finddata(src->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+ ef = rbtree_find_data(src->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
if (unlikely(!ef)) {
fr_strerror_printf("No events are registered for fd %i", fd);
return -1;
struct kevent evset[10];
int count = 0;
- ef = rbtree_finddata(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+ ef = rbtree_find_data(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
if (unlikely(!ef)) {
fr_strerror_printf("No events are registered for fd %i", fd);
return -1;
}
if (!ef_out || !*ef_out) {
- ef = rbtree_finddata(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+ ef = rbtree_find_data(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
} else {
ef = *ef_out;
fr_assert((fd < 0) || (ef->fd == fd));
{
fr_event_fd_t *ef;
- ef = rbtree_finddata(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+ ef = rbtree_find_data(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
if (unlikely(!ef)) {
fr_strerror_printf("No events are registered for fd %i", fd);
return -1;
{
fr_event_fd_t *ef;
- ef = rbtree_finddata(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+ ef = rbtree_find_data(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
if (unlikely(!ef)) {
fr_strerror_printf("No events are registered for fd %i", fd);
return -1;
{
fr_event_fd_t *ef;
- ef = rbtree_finddata(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
+ ef = rbtree_find_data(el->fds, &(fr_event_fd_t){ .fd = fd, .filter = filter });
if (unlikely(!ef)) {
fr_strerror_printf("No events are registered for fd %i", fd);
return -1;
fr_event_counter_t find = { .file = ev->file, .line = ev->line };
fr_event_counter_t *counter;
- counter = rbtree_finddata(locations[i], &find);
+ counter = rbtree_find_data(locations[i], &find);
if (!counter) {
counter = talloc(locations[i], fr_event_counter_t);
if (!counter) goto oom;
pthread_mutex_lock(&print_lock);
EVENT_DEBUG("Event list %p", el);
- EVENT_DEBUG(" fd events : %u", fr_event_list_num_fds(el));
+ EVENT_DEBUG(" fd events : %"PRIu64, fr_event_list_num_fds(el));
EVENT_DEBUG(" events last iter : %u", el->num_fd_events);
EVENT_DEBUG(" num timer events : %u", fr_event_list_num_timers(el));
fr_event_vnode_func_t vnode; //!< vnode callback functions.
} fr_event_funcs_t;
-int fr_event_list_num_fds(fr_event_list_t *el);
+uint64_t fr_event_list_num_fds(fr_event_list_t *el);
int fr_event_list_num_timers(fr_event_list_t *el);
int fr_event_list_kq(fr_event_list_t *el);
fr_time_t fr_event_list_time(fr_event_list_t *el) CC_HINT(nonnull);
///< the structure being inserted.
char const *type; //!< Talloc type to check elements against.
- uint64_t num_elements; //!< How many elements are inside the tree.
+ size_t num_elements; //!< How many elements are inside the tree.
fr_rb_cmp_t compare; //!< The comparator.
fr_rb_free_t free; //!< Free function called when a node is freed.
rbtree_delete_internal(tree, z, false);
}
-/** Delete a node from the tree, based on given data, which MUST have come from rbtree_finddata().
+/** Delete a node from the tree, based on given data, which MUST have come from rbtree_find_data().
*
*
*/
-bool rbtree_deletebydata(rbtree_t *tree, void const *data)
+bool rbtree_delete_by_data(rbtree_t *tree, void const *data)
{
fr_rb_node_t *node;
*
* @hidecallergraph
*/
-void *rbtree_finddata(rbtree_t *tree, void const *data)
+void *rbtree_find_data(rbtree_t *tree, void const *data)
{
fr_rb_node_t *x;
return x->data;
}
-/** Walk the tree, Pre-order
+/** Return how many nodes there are in a tree
*
- * We call ourselves recursively for each function, but that's OK,
- * as the stack is only log(N) deep, which is ~12 entries deep.
+ * @param[in] tree to return node count for.
*/
-static int walk_node_pre_order(fr_rb_node_t *x, fr_rb_walker_t compare, void *uctx)
-{
- int ret;
- fr_rb_node_t *left, *right;
-
- left = x->left;
- right = x->right;
-
- ret = compare(x->data, uctx);
- if (ret != 0) return ret;
-
- if (left != NIL) {
- ret = walk_node_pre_order(left, compare, uctx);
- if (ret != 0) return ret;
- }
-
- if (right != NIL) {
- ret = walk_node_pre_order(right, compare, uctx);
- if (ret != 0) return ret;
- }
-
- return 0;/* we know everything returned zero */
-}
-
-/** rbtree_in_order
- *
- */
-static int walk_node_in_order(fr_rb_node_t *x, fr_rb_walker_t compare, void *uctx)
-{
- int ret;
- fr_rb_node_t *right;
-
- if (x->left != NIL) {
- ret = walk_node_in_order(x->left, compare, uctx);
- if (ret != 0) return ret;
- }
-
- right = x->right;
-
- ret = compare(x->data, uctx);
- if (ret != 0) return ret;
-
- if (right != NIL) {
- ret = walk_node_in_order(right, compare, uctx);
- if (ret != 0) return ret;
- }
-
- return 0; /* we know everything returned zero */
-}
-
-
-/** rbtree_post_order
- *
- */
-static int walk_node_post_order(fr_rb_node_t *x, fr_rb_walker_t compare, void *uctx)
-{
- int ret;
-
- if (x->left != NIL) {
- ret = walk_node_post_order(x->left, compare, uctx);
- if (ret != 0) return ret;
- }
-
- if (x->right != NIL) {
- ret = walk_node_post_order(x->right, compare, uctx);
- if (ret != 0) return ret;
- }
-
- ret = compare(x->data, uctx);
- if (ret != 0) return ret;
-
- return 0; /* we know everything returned zero */
-}
-
-/** rbtree_delete_order
- *
- * This executes an rbtree_in_order-like walk that adapts to changes in the
- * tree above it, which may occur because we allow the compare to
- * tell us to delete the current node.
- *
- * The compare should return:
- *
- * < 0 - on error
- * 0 - continue walking, don't delete the node
- * 1 - delete the node and stop walking
- * 2 - delete the node and continue walking
- */
-static int walk_delete_order(rbtree_t *tree, fr_rb_walker_t compare, void *uctx)
-{
- fr_rb_node_t *solid, *x;
- int ret = 0;
-
- /* Keep track of last node that refused deletion. */
- solid = NIL;
- while (solid == NIL) {
- x = tree->root;
- if (x == NIL) break;
- descend:
- while (x->left != NIL) {
- x = x->left;
- }
- visit:
- ret = compare(x->data, uctx);
- if (ret < 0) {
- return ret;
- }
- if (ret) {
- rbtree_delete_internal(tree, x, true);
- if (ret != 2) {
- return ret;
- }
- } else {
- solid = x;
- }
- }
- if (solid != NIL) {
- x = solid;
- if (x->right != NIL) {
- x = x->right;
- goto descend;
- }
- while (x->parent != NIL) {
- if (x->parent->left == x) {
- x = x->parent;
- goto visit;
- }
- x = x->parent;
- }
- }
- return ret;
-}
-
-
-/*
- * walk the entire tree. The compare function CANNOT modify
- * the tree.
- *
- * The compare function should return 0 to continue walking.
- * Any other value stops the walk, and is returned.
- */
-int rbtree_walk(rbtree_t *tree, fr_rb_order_t order, fr_rb_walker_t compare, void *uctx)
-{
- int ret;
-
- if (tree->root == NIL) return 0;
-
- if (tree->lock) pthread_mutex_lock(&tree->mutex);
-
- switch (order) {
- case RBTREE_PRE_ORDER:
- ret = walk_node_pre_order(tree->root, compare, uctx);
- break;
-
- case RBTREE_IN_ORDER:
- ret = walk_node_in_order(tree->root, compare, uctx);
- break;
-
- case RBTREE_POST_ORDER:
- ret = walk_node_post_order(tree->root, compare, uctx);
- break;
-
- case RBTREE_DELETE_ORDER:
- ret = walk_delete_order(tree, compare, uctx);
- break;
-
- default:
- ret = -1;
- break;
- }
-
- if (tree->lock) pthread_mutex_unlock(&tree->mutex);
- return ret;
-}
-
-uint32_t rbtree_num_elements(rbtree_t *tree)
+uint64_t rbtree_num_elements(rbtree_t *tree)
{
return tree->num_elements;
}
-typedef struct {
- size_t idx;
- void **data;
-} rbtree_flatten_ctx_t;
-
-static int _flatten_cb(void *data, void *uctx)
-{
- rbtree_flatten_ctx_t *ctx = uctx;
- ctx->data[ctx->idx++] = data;
- return 0;
-}
-
-
-
-/*
- * Given a Node, return the data.
- */
-void *rbtree_node2data(UNUSED rbtree_t *tree, fr_rb_node_t *node)
-{
- if (!node) return NULL;
-
- return node->data;
-}
-
/** Initialise an in-order iterator
*
* @note If iteration ends early because of a loop condition #rbtree_iter_done must be called.
*
- * @param[out] iter to initialise.
- * @param[in] tree to iterate over.
+ * @param[out] iter to initialise.
+ * @param[in] tree to iterate over.
* @return
* - The first node. Mutex will be held.
* - NULL if the tree is empty.
*
* @note If iteration ends early because of a loop condition #rbtree_iter_done must be called.
*
- * @param[out] iter to initialise.
- * @param[in] tree to iterate over.
+ * @param[out] iter to initialise.
+ * @param[in] tree to iterate over.
* @return
* - The first node. Mutex will be held.
* - NULL if the tree is empty.
*
* @note If iteration ends early because of a loop condition #rbtree_iter_done must be called.
*
- * @param[out] iter to initialise.
- * @param[in] tree to iterate over.
+ * @param[out] iter to initialise.
+ * @param[in] tree to iterate over.
* @return
* - The first node. Mutex will be held.
* - NULL if the tree is empty.
return x->data;
}
-#define DEF_RBTREE_FLATTEN_FUNC(_order)
-ssize_t rbtree_flatten_##_order(TALLOC_CTX *ctx, void **out[], rbtree_t *tree) \
+#define DEF_RBTREE_FLATTEN_FUNC(_order) \
+int rbtree_flatten_##_order(TALLOC_CTX *ctx, void **out[], rbtree_t *tree) \
{ \
- uint32_t num = rbtree_num_elements(tree), i; \
+ uint64_t num = rbtree_num_elements(tree), i; \
fr_rb_tree_iter_##_order##_t iter; \
void *item, **list; \
- if (unlikely(!(list = talloc_array(ctx, void *, num)))) return -1;
+ if (unlikely(!(list = talloc_array(ctx, void *, num)))) return -1; \
for (item = rbtree_iter_init_##_order(&iter, tree), i = 0; \
item; \
item = rbtree_iter_next_##_order(&iter), i++) list[i] = item; \
- return list; \
+ *out = list; \
+ return 0; \
}
DEF_RBTREE_FLATTEN_FUNC(preorder)
DEF_RBTREE_FLATTEN_FUNC(postorder)
/* rbtree.c */
typedef struct rbtree_s rbtree_t;
-/* callback order for walking */
-typedef enum {
- RBTREE_PRE_ORDER,
- RBTREE_IN_ORDER,
- RBTREE_POST_ORDER,
-} fr_rb_order_t;
-
/* Red-Black tree description */
typedef enum {
BLACK,
#define RBTREE_FLAG_LOCK (1 << 1)
typedef int (*fr_rb_cmp_t)(void const *one, void const *two);
-typedef int (*fr_rb_walker_t)(void *data, void *uctx);
typedef void (*fr_rb_free_t)(void *data);
#ifndef STABLE_COMPARE
void rbtree_delete(rbtree_t *tree, fr_rb_node_t *z) CC_HINT(nonnull);
-bool rbtree_deletebydata(rbtree_t *tree, void const *data) 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);
/** @hidecallergraph */
-void *rbtree_finddata(rbtree_t *tree, void const *data) CC_HINT(nonnull);
-
-uint32_t rbtree_num_elements(rbtree_t *tree) CC_HINT(nonnull);
+void *rbtree_find_data(rbtree_t *tree, void const *data) CC_HINT(nonnull);
-void *rbtree_node2data(rbtree_t *tree, fr_rb_node_t *node);
+uint64_t rbtree_num_elements(rbtree_t *tree) CC_HINT(nonnull);
-/*
- * The callback should be declared as:
- * int callback(void *context, void *data)
- *
- * The "context" is some user-defined context.
- * The "data" is the pointer to the user data in the node,
- * NOT the node itself.
- *
- * It should return 0 if all is OK, and !0 for any error.
- * The walking will stop on any error.
- *
- * Except with RBTREE_DELETE_ORDER, where the callback should return <0 for
- * errors, and may return 1 to delete the current node and halt,
- * or 2 to delete the current node and continue. This may be
- * used to batch-delete select nodes from a locked rbtree.
+/** Given a Node, return the data
*/
-int rbtree_walk(rbtree_t *tree, fr_rb_order_t order, fr_rb_walker_t compare, void *uctx);
+static inline void *rbtree_node_to_data(UNUSED rbtree_t *tree, fr_rb_node_t *node)
+{
+ if (!node) return NULL;
+
+ return node->data;
+}
/** Iterator structure for in-order traversal of an rbtree
*/
))
-ssize_t rbtree_flatten_inorder(TALLOC_CTX *ctx, void **out[], rbtree_t *tree);
-
-ssize_t rbtree_flatten_preorder(TALLOC_CTX *ctx, void **out[], rbtree_t *tree);
-
-ssize_t rbtree_flatten_postorder(TALLOC_CTX *ctx, void **out[], rbtree_t *tree);
+int rbtree_flatten_inorder(TALLOC_CTX *ctx, void **out[], rbtree_t *tree);
+int rbtree_flatten_preorder(TALLOC_CTX *ctx, void **out[], rbtree_t *tree);
+int rbtree_flatten_postorder(TALLOC_CTX *ctx, void **out[], rbtree_t *tree);
#ifdef __cplusplus
}
#endif
session->pthread_id = pthread_self();
} else {
if (!bfd_pthread_create(session)) {
- rbtree_deletebydata(sock->session_tree, session);
+ rbtree_delete_by_data(sock->session_tree, session);
talloc_free(session);
return NULL;
}
fr_ipaddr_from_sockaddr(&my_session.socket.inet.dst_ipaddr,
&my_session.socket.inet.dst_port, &src, sizeof_src);
- session = rbtree_finddata(sock->session_tree, &my_session);
+ session = rbtree_find_data(sock->session_tree, &my_session);
if (!session) {
DEBUG("BFD unknown peer");
return 0;
my_session.socket.inet.dst_ipaddr = ipaddr;
my_session.socket.inet.dst_port = port;
- if (rbtree_finddata(sock->session_tree, &my_session) != NULL) {
+ if (rbtree_find_data(sock->session_tree, &my_session) != NULL) {
cf_log_err(ci, "Peers must have unique IP addresses");
return -1;
}
if (!sync || (sync->msgid != msgid)) {
find.msgid = msgid;
- sync = rbtree_finddata(tree, &find);
+ sync = rbtree_find_data(tree, &find);
if (!sync) {
WARN("Ignoring msgid %i, doesn't match any outstanding syncs",
find.msgid);
* Tell the remote server to stop sending results
*/
ldap_abandon_ext(sync->conn->handle, sync->msgid, NULL, NULL);
- rbtree_deletebydata(tree, &find);
+ rbtree_delete_by_data(tree, &find);
return 0;
}
find.msgid = msgid;
- sync = rbtree_finddata(tree, &find);
+ sync = rbtree_find_data(tree, &find);
talloc_free(sync); /* Will inform the server */
}
find.msgid = msgid;
- sync = rbtree_finddata(tree, &find);
+ sync = rbtree_find_data(tree, &find);
return sync->config;
}
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_deletebydata(driver->cache, c);
+ rbtree_delete_by_data(driver->cache, c);
talloc_free(c);
}
/*
* Is there an entry for this key?
*/
- c = rbtree_finddata(driver->cache, &(rlm_cache_entry_t){ .key = key, .key_len = key_len });
+ c = rbtree_find_data(driver->cache, &(rlm_cache_entry_t){ .key = key, .key_len = key_len });
if (!c) {
*out = NULL;
return CACHE_MISS;
if (!request) return CACHE_ERROR;
- c = rbtree_finddata(driver->cache, &(rlm_cache_entry_t){ .key = key, .key_len = key_len });
+ c = rbtree_find_data(driver->cache, &(rlm_cache_entry_t){ .key = key, .key_len = key_len });
if (!c) return CACHE_MISS;
fr_heap_extract(driver->heap, c);
- rbtree_deletebydata(driver->cache, c);
+ rbtree_delete_by_data(driver->cache, c);
talloc_free(c);
return CACHE_OK;
}
if (fr_heap_insert(driver->heap, UNCONST(rlm_cache_entry_t *, c)) < 0) {
- rbtree_deletebydata(driver->cache, c);
+ rbtree_delete_by_data(driver->cache, c);
RERROR("Failed adding entry to expiry heap");
return CACHE_ERROR;
}
if (fr_heap_insert(driver->heap, c) < 0) {
- rbtree_deletebydata(driver->cache, c); /* make sure we don't leak entries... */
+ rbtree_delete_by_data(driver->cache, c); /* make sure we don't leak entries... */
RERROR("Failed updating entry TTL. Entry was forcefully expired");
return CACHE_ERROR;
}
*
* @copydetails cache_entry_count_t
*/
-static uint32_t cache_entry_count(UNUSED rlm_cache_config_t const *config, void *instance,
+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);
* #cache_acquire_t callback was provided.
* @return number of entries in the cache.
*/
-typedef uint32_t (*cache_entry_count_t)(rlm_cache_config_t const *config, void *instance,
+typedef uint64_t (*cache_entry_count_t)(rlm_cache_config_t const *config, void *instance,
request_t *request, void *handle);
/** Acquire a handle to access the cache
memcpy(&my_e.key, &key, sizeof(key)); /* const issues */
- return rbtree_finddata(inst->tree, &my_e);
+ return rbtree_find_data(inst->tree, &my_e);
}
static bool insert_entry(CONF_SECTION *conf, rlm_csv_t *inst, rlm_csv_entry_t *e, int lineno)
* for a matching list header already in the tree.
*/
search_list.name = entry->name;
- user_list = rbtree_finddata(tree, &search_list);
+ user_list = rbtree_find_data(tree, &search_list);
if (!user_list) {
user_list = talloc_zero(ctx, PAIR_LIST_LIST);
pairlist_list_init(user_list);
if (!tree) RETURN_MODULE_NOOP;
my_list.name = name;
- user_list = rbtree_finddata(tree, &my_list);
+ user_list = rbtree_find_data(tree, &my_list);
user_pl = (user_list) ? fr_dlist_head(&user_list->head) : NULL;
my_list.name = "DEFAULT";
- default_list = rbtree_finddata(tree, &my_list);
+ default_list = rbtree_find_data(tree, &my_list);
default_pl = (default_list) ? fr_dlist_head(&default_list->head) : NULL;
/*
MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_BOOL, NULL, false));
vb->vb_bool = echo->replied;
- (void) rbtree_deletebydata(thread->t->tree, echo);
+ (void) rbtree_delete_by_data(thread->t->tree, echo);
talloc_free(echo);
fr_dcursor_insert(out, vb);
RDEBUG2("Cancelling ICMP request for %pV (counter=%d)", echo->ip, echo->counter);
- (void) rbtree_deletebydata(thread->t->tree, echo);
+ (void) rbtree_delete_by_data(thread->t->tree, echo);
talloc_free(echo);
}
if (unlang_xlat_event_timeout_add(request, _xlat_icmp_timeout, echo, fr_time() + inst->timeout) < 0) {
RPEDEBUG("Failed adding timeout");
- (void) rbtree_deletebydata(thread->t->tree, echo);
+ (void) rbtree_delete_by_data(thread->t->tree, echo);
talloc_free(echo);
return XLAT_ACTION_FAIL;
}
rcode = sendto(thread->t->fd, &icmp, sizeof(icmp), 0, (struct sockaddr *) &dst, salen);
if (rcode < 0) {
REDEBUG("Failed sending ICMP request to %pV: %s", echo->ip, fr_syserror(errno));
- (void) rbtree_deletebydata(thread->t->tree, echo);
+ (void) rbtree_delete_by_data(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_deletebydata(thread->t->tree, echo);
+ (void) rbtree_delete_by_data(thread->t->tree, echo);
talloc_free(echo);
return XLAT_ACTION_FAIL;
}
* Look up the packet by the fields which determine *our* ICMP packets.
*/
my_echo.counter = icmp->counter;
- echo = rbtree_finddata(t->tree, &my_echo);
+ echo = rbtree_find_data(t->tree, &my_echo);
if (!echo) {
DEBUG("Can't find packet counter=%d in tree", icmp->counter);
return;
}
- (void) rbtree_deletebydata(t->tree, echo);
+ (void) rbtree_delete_by_data(t->tree, echo);
/*
* We have a reply!
* This entry MAY be in a subtree. If so, delete
* it.
*/
- if (tt->subtree[te->id]) (void) rbtree_deletebydata(tt->subtree[te->id], te);
+ if (tt->subtree[te->id]) (void) rbtree_delete_by_data(tt->subtree[te->id], te);
goto done;
}
* Delete it from the tracking subtree.
*/
fr_assert(tt->subtree[te->id] != NULL);
- (void) rbtree_deletebydata(tt->subtree[te->id], te);
+ (void) rbtree_delete_by_data(tt->subtree[te->id], te);
/*
* Try to free memory if the system gets idle. If the
/*
* The authentication vector may have changed.
*/
- if (tt->subtree[te->id]) (void) rbtree_deletebydata(tt->subtree[te->id], te);
+ if (tt->subtree[te->id]) (void) rbtree_delete_by_data(tt->subtree[te->id], te);
memcpy(te->vector, vector, sizeof(te->vector));
*/
memcpy(&my_te.vector, vector, sizeof(my_te.vector));
- te = rbtree_finddata(tt->subtree[packet_id], &my_te);
+ te = rbtree_find_data(tt->subtree[packet_id], &my_te);
/*
* Not found, the packet MAY have been allocated in the
static void securid_sessionlist_clean_expired(rlm_securid_t *inst, request_t *request, time_t timestamp)
{
- int num_sessions;
+ uint64_t num_sessions;
SECURID_SESSION *session;
num_sessions = rbtree_num_elements(inst->session_tree);
/*
* Remove the outstanding transaction
*/
- if (!rbtree_deletebydata(txn_tree, txn)) ERROR("Transaction removed before timeout");
+ if (!rbtree_delete_by_data(txn_tree, txn)) ERROR("Transaction removed before timeout");
txn->response.type = SIGTRAN_RESPONSE_FAIL;
/*
* Lookup the transaction in our tree of outstanding transactions
*/
- found = rbtree_finddata(txn_tree, &find);
+ found = rbtree_find_data(txn_tree, &find);
if (!found) {
/*
* Not an error, could be a retransmission
ERROR("No outstanding transaction with DTID %u Invoke ID %u", find.ctx.otid, find.ctx.invoke_id);
return 0;
}
- if (!rbtree_deletebydata(txn_tree, found)) { /* Remove the outstanding transaction */
+ if (!rbtree_delete_by_data(txn_tree, found)) { /* Remove the outstanding transaction */
ERROR("Failed removing transaction");
fr_assert(0);
}
* Bootstrap with my statistics, where we don't need a
* lock.
*/
- stats = rbtree_finddata(*tree, mydata);
+ stats = rbtree_find_data(*tree, mydata);
if (!stats) {
memset(final_stats, 0, sizeof(uint64_t) * FR_RADIUS_MAX_PACKET_CODE);
} else {
if (other == t) continue;
tree = (rbtree_t **) (((uint8_t *) other) + tree_offset);
- stats = rbtree_finddata(*tree, mydata);
+ stats = rbtree_find_data(*tree, mydata);
if (!stats) {
continue;
}
* Update source statistics
*/
mydata.ipaddr = request->packet->socket.inet.src_ipaddr;
- stats = rbtree_finddata(t->src, &mydata);
+ stats = rbtree_find_data(t->src, &mydata);
if (!stats) {
MEM(stats = talloc_zero(t, rlm_stats_data_t));
* Update destination statistics
*/
mydata.ipaddr = request->packet->socket.inet.dst_ipaddr;
- stats = rbtree_finddata(t->dst, &mydata);
+ stats = rbtree_find_data(t->dst, &mydata);
if (!stats) {
MEM(stats = talloc_zero(t, rlm_stats_data_t));
{
if (!pl || !request) return 0;
- return rbtree_finddata(pl->tree, request);
+ return rbtree_find_data(pl->tree, request);
}
my_request.id = reply->id;
request = &my_request;
- return rbtree_finddata(pl->tree, request);
+ return rbtree_find_data(pl->tree, request);
}
return NULL;
}
-uint32_t fr_packet_list_num_incoming(fr_packet_list_t *pl)
+uint64_t fr_packet_list_num_incoming(fr_packet_list_t *pl)
{
- uint32_t num_elements;
+ uint64_t num_elements;
if (!pl) return 0;
int fr_packet_list_fd_set(fr_packet_list_t *pl, fd_set *set);
fr_radius_packet_t *fr_packet_list_recv(fr_packet_list_t *pl, fd_set *set, uint32_t max_attributes, bool require_ma);
-uint32_t fr_packet_list_num_incoming(fr_packet_list_t *pl);
+uint64_t fr_packet_list_num_incoming(fr_packet_list_t *pl);
uint32_t fr_packet_list_num_outgoing(fr_packet_list_t *pl);
void fr_packet_header_log(fr_log_t const *log, fr_radius_packet_t *packet, bool received);
* For testing deletebydata instead
for (i = 0; i < n; i++) {
- if (filter_cb(&vals[i], &thresh) == 2) rbtree_deletebydata(t, &vals[i]);
+ if (filter_cb(&vals[i], &thresh) == 2) rbtree_delete_by_data(t, &vals[i]);
}
*
projects / thirdparty / freeradius-server.git / commitdiff
