From: Alan T. DeKok Date: Fri, 16 Jan 2026 20:49:33 +0000 (-0500) Subject: tweak RB iterators to use same API layout as other tables X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=366279140647ee4a0c494ed2abe3d2cbb5f4bf26;p=thirdparty%2Ffreeradius-server.git tweak RB iterators to use same API layout as other tables hash / etc. all use (thing, iter), whereas the RB code either used (iter, thing), or just (iter). Using the same API means that we can then add iterators to the htrie code. --- diff --git a/src/lib/bio/dedup.c b/src/lib/bio/dedup.c index 252e5208526..58b0821e8d1 100644 --- a/src/lib/bio/dedup.c +++ b/src/lib/bio/dedup.c @@ -1018,8 +1018,8 @@ static int fr_bio_dedup_shutdown(fr_bio_t *bio) * Cancel all outgoing packets. Don't bother updating the tree or the free list, as all of the * entries will be deleted when the memory is freed. */ - while ((item = fr_rb_iter_init_inorder(&iter, &my->rb)) != NULL) { - fr_rb_iter_delete_inorder(&iter); + while ((item = fr_rb_iter_init_inorder(&my->rb, &iter)) != NULL) { + fr_rb_iter_delete_inorder(&my->rb, &iter); my->release((fr_bio_t *) my, item, FR_BIO_DEDUP_CANCELLED); } diff --git a/src/lib/io/network.c b/src/lib/io/network.c index 51dd2049c70..4d049bff8ca 100644 --- a/src/lib/io/network.c +++ b/src/lib/io/network.c @@ -465,9 +465,9 @@ static void fr_network_suspend(fr_network_t *nr) if (nr->suspended) return; - for (s = fr_rb_iter_init_inorder(&iter, nr->sockets); + for (s = fr_rb_iter_init_inorder(nr->sockets, &iter); s != NULL; - s = fr_rb_iter_next_inorder(&iter)) { + s = fr_rb_iter_next_inorder(nr->sockets, &iter)) { fr_event_filter_update(s->nr->el, s->listen->fd, FR_EVENT_FILTER_IO, pause_read); } nr->suspended = true; @@ -484,9 +484,9 @@ static void fr_network_unsuspend(fr_network_t *nr) if (!nr->suspended) return; - for (s = fr_rb_iter_init_inorder(&iter, nr->sockets); + for (s = fr_rb_iter_init_inorder(nr->sockets, &iter); s != NULL; - s = fr_rb_iter_next_inorder(&iter)) { + s = fr_rb_iter_next_inorder(nr->sockets, &iter)) { fr_event_filter_update(s->nr->el, s->listen->fd, FR_EVENT_FILTER_IO, resume_read); } nr->suspended = false; @@ -2083,9 +2083,9 @@ static int cmd_socket_list(FILE *fp, UNUSED FILE *fp_err, void *ctx, UNUSED fr_c // @todo - note that this isn't thread-safe! - for (s = fr_rb_iter_init_inorder(&iter, nr->sockets); + for (s = fr_rb_iter_init_inorder(nr->sockets, &iter); s != NULL; - s = fr_rb_iter_next_inorder(&iter)) { + s = fr_rb_iter_next_inorder(nr->sockets, &iter)) { if (!s->listen->app_io->get_name) { fprintf(fp, "%s\n", s->listen->app_io->common.name); } else { diff --git a/src/lib/redis/cluster.c b/src/lib/redis/cluster.c index 170abdcc6b6..5ec6b47d166 100644 --- a/src/lib/redis/cluster.c +++ b/src/lib/redis/cluster.c @@ -1330,9 +1330,9 @@ static int cluster_node_find_live(fr_redis_cluster_node_t **live_node, fr_redis_ live->skip = skip->id; pthread_mutex_lock(&cluster->mutex); - for (node = fr_rb_iter_init_inorder(&iter, cluster->used_nodes); + for (node = fr_rb_iter_init_inorder(cluster->used_nodes, &iter); node; - node = fr_rb_iter_next_inorder(&iter)) { + node = fr_rb_iter_next_inorder(cluster->used_nodes, &iter)) { fr_assert(node->pool); if (live->skip == node->id) continue; /* Skip dead nodes */ @@ -2158,9 +2158,9 @@ ssize_t fr_redis_cluster_node_addr_by_role(TALLOC_CTX *ctx, fr_socket_t *out[], pthread_mutex_lock(&cluster->mutex); - for (node = fr_rb_iter_init_inorder(&iter, cluster->used_nodes); + for (node = fr_rb_iter_init_inorder(cluster->used_nodes, &iter); node; - node = fr_rb_iter_next_inorder(&iter)) { + node = fr_rb_iter_next_inorder(cluster->used_nodes, &iter)) { if ((is_master && node->is_master) || (is_slave && !node->is_master)) found[count++] = node->addr; } @@ -2210,9 +2210,9 @@ bool fr_redis_cluster_min_version(fr_redis_cluster_t *cluster, char const *min_v pthread_mutex_lock(&cluster->mutex); - for (node = fr_rb_iter_init_inorder(&iter, cluster->used_nodes); + for (node = fr_rb_iter_init_inorder(cluster->used_nodes, &iter); node; - node = fr_rb_iter_next_inorder(&iter)) { + node = fr_rb_iter_next_inorder(cluster->used_nodes, &iter)) { conn = fr_pool_connection_get(node->pool, NULL); if (!conn) continue; diff --git a/src/lib/server/cf_util.c b/src/lib/server/cf_util.c index 3728f71db9a..72f1a6c647d 100644 --- a/src/lib/server/cf_util.c +++ b/src/lib/server/cf_util.c @@ -1889,9 +1889,9 @@ int _cf_data_walk(CONF_ITEM *ci, char const *type, cf_walker_t cb, void *ctx) if (!ci->ident2) return 0; - for (ci = fr_rb_iter_init_inorder(&iter, ci->ident2); + for (ci = fr_rb_iter_init_inorder(ci->ident2, &iter); ci; - ci = fr_rb_iter_next_inorder(&iter)) { + ci = fr_rb_iter_next_inorder(ci->ident2, &iter)) { /* * We're walking ident2, not all of the items will be data */ diff --git a/src/lib/server/dl_module.c b/src/lib/server/dl_module.c index b8a7cdf56fb..16f336329e9 100644 --- a/src/lib/server/dl_module.c +++ b/src/lib/server/dl_module.c @@ -442,9 +442,9 @@ static int _dl_module_loader_free(dl_module_loader_t *dl_module_l) void *data; WARN("Refusing to cleanup dl loader, the following modules are still in use:"); - for (data = fr_rb_iter_init_inorder(&iter, dl_module_l->module_tree); + for (data = fr_rb_iter_init_inorder(dl_module_l->module_tree, &iter); data; - data = fr_rb_iter_next_inorder(&iter)) { + data = fr_rb_iter_next_inorder(dl_module_l->module_tree, &iter)) { dl_module_t *module = talloc_get_type_abort(data, dl_module_t); WARN(" %s", module->exported->name); diff --git a/src/lib/server/module.c b/src/lib/server/module.c index 0e8c319fb3d..c264596c76c 100644 --- a/src/lib/server/module.c +++ b/src/lib/server/module.c @@ -628,9 +628,9 @@ void module_list_debug(module_list_t const *ml) * they would be bootstrapped or inserted * into the tree. */ - for (inst = fr_rb_iter_init_inorder(&iter, ml->name_tree); + for (inst = fr_rb_iter_init_inorder(ml->name_tree, &iter); inst; - inst = fr_rb_iter_next_inorder(&iter)) { + inst = fr_rb_iter_next_inorder(ml->name_tree, &iter)) { module_instance_debug(inst); } } @@ -1010,9 +1010,9 @@ void modules_thread_detach(module_list_t *ml) * finding and extracting their thread specific * data, and calling their detach methods. */ - for (inst = fr_rb_iter_init_inorder(&iter, ml->name_tree); + for (inst = fr_rb_iter_init_inorder(ml->name_tree, &iter); inst; - inst = fr_rb_iter_next_inorder(&iter)) { + inst = fr_rb_iter_next_inorder(ml->name_tree, &iter)) { module_instance_t *mi = talloc_get_type_abort(inst, module_instance_t); module_thread_instance_t *ti = module_thread(mi); @@ -1165,9 +1165,9 @@ int modules_thread_instantiate(TALLOC_CTX *ctx, module_list_t const *ml, fr_even if (unlikely(ret < 0)) return ret; } - for (inst = fr_rb_iter_init_inorder(&iter, ml->name_tree); + for (inst = fr_rb_iter_init_inorder(ml->name_tree, &iter); inst; - inst = fr_rb_iter_next_inorder(&iter)) { + inst = fr_rb_iter_next_inorder(ml->name_tree, &iter)) { module_instance_t *mi = talloc_get_type_abort(inst, module_instance_t); /* Sanity check*/ if (module_thread_instantiate(ctx, mi, el) < 0) { @@ -1279,9 +1279,9 @@ int modules_instantiate(module_list_t const *ml) DEBUG2("#### Instantiating %s modules ####", ml->name); - for (inst = fr_rb_iter_init_inorder(&iter, ml->name_tree); + for (inst = fr_rb_iter_init_inorder(ml->name_tree, &iter); inst; - inst = fr_rb_iter_next_inorder(&iter)) { + inst = fr_rb_iter_next_inorder(ml->name_tree, &iter)) { module_instance_t *mi = talloc_get_type_abort(inst, module_instance_t); if (module_instantiate(mi) < 0) return -1; } @@ -1370,9 +1370,9 @@ int modules_bootstrap(module_list_t const *ml) DEBUG2("#### Bootstrapping %s modules ####", ml->name); - for (instance = fr_rb_iter_init_inorder(&iter, ml->name_tree); + for (instance = fr_rb_iter_init_inorder(ml->name_tree, &iter); instance; - instance = fr_rb_iter_next_inorder(&iter)) { + instance = fr_rb_iter_next_inorder(ml->name_tree, &iter)) { module_instance_t *mi = talloc_get_type_abort(instance, module_instance_t); if (module_bootstrap(mi) < 0) return -1; } @@ -1775,8 +1775,8 @@ static int _module_list_free(module_list_t *ml) * tree. It can cause problems when we delete children * without the iterator knowing about it. */ - while ((mi = fr_rb_iter_init_inorder(&iter, ml->name_tree)) != NULL) { - fr_rb_iter_delete_inorder(&iter); /* Keeps the iterator sane */ + while ((mi = fr_rb_iter_init_inorder(ml->name_tree, &iter)) != NULL) { + fr_rb_iter_delete_inorder(ml->name_tree, &iter); /* Keeps the iterator sane */ talloc_free(mi); } diff --git a/src/lib/server/module_rlm.c b/src/lib/server/module_rlm.c index b752457e9e8..2cb471c662a 100644 --- a/src/lib/server/module_rlm.c +++ b/src/lib/server/module_rlm.c @@ -1337,9 +1337,9 @@ int modules_rlm_bootstrap(CONF_SECTION *root) * register our redundant xlats. But only when all of * the items in such a section are the same. */ - for (vm = fr_rb_iter_init_inorder(&iter, module_rlm_virtual_name_tree); + for (vm = fr_rb_iter_init_inorder(module_rlm_virtual_name_tree, &iter); vm; - vm = fr_rb_iter_next_inorder(&iter)) { + vm = fr_rb_iter_next_inorder(module_rlm_virtual_name_tree, &iter)) { if (!vm->all_same) continue; if (xlat_register_redundant(vm->cs) < 0) return -1; diff --git a/src/lib/unlang/compile.c b/src/lib/unlang/compile.c index 1d25388fc45..851fe14a35e 100644 --- a/src/lib/unlang/compile.c +++ b/src/lib/unlang/compile.c @@ -2290,9 +2290,9 @@ int unlang_thread_instantiate(TALLOC_CTX *ctx) /* * Instantiate each instruction with thread-specific data. */ - for (instruction = fr_rb_iter_init_inorder(&iter, unlang_instruction_tree); + for (instruction = fr_rb_iter_init_inorder(unlang_instruction_tree, &iter); instruction; - instruction = fr_rb_iter_next_inorder(&iter)) { + instruction = fr_rb_iter_next_inorder(unlang_instruction_tree, &iter)) { unlang_op_t *op; unlang_thread_array[instruction->number].instruction = instruction; diff --git a/src/lib/unlang/xlat_func.c b/src/lib/unlang/xlat_func.c index c3c8b0442b3..fd2c4d08547 100644 --- a/src/lib/unlang/xlat_func.c +++ b/src/lib/unlang/xlat_func.c @@ -534,13 +534,13 @@ void xlat_func_unregister_module(module_instance_t const *inst) if (!xlat_root) return; /* All xlats have already been freed */ - for (c = fr_rb_iter_init_inorder(&iter, xlat_root); + for (c = fr_rb_iter_init_inorder(xlat_root, &iter); c; - c = fr_rb_iter_next_inorder(&iter)) { + c = fr_rb_iter_next_inorder(xlat_root, &iter)) { if (!c->mctx) continue; if (c->mctx->mi != inst) continue; - fr_rb_iter_delete_inorder(&iter); + fr_rb_iter_delete_inorder(xlat_root, &iter); } } diff --git a/src/lib/unlang/xlat_redundant.c b/src/lib/unlang/xlat_redundant.c index e6eddb81fcb..79406c8af76 100644 --- a/src/lib/unlang/xlat_redundant.c +++ b/src/lib/unlang/xlat_redundant.c @@ -566,12 +566,12 @@ int xlat_register_redundant(CONF_SECTION *cs) fr_sbuff_marker(&name_start, name); - mrx = fr_rb_iter_init_inorder(&iter, mrx_tree); - /* * Iterate over the all the xlats, registered by * all the modules in the section. */ + mrx = fr_rb_iter_init_inorder(mrx_tree, &iter); + while (mrx) { xlat_t *xlat; xlat_func_flags_t flags = default_flags; @@ -621,7 +621,7 @@ int xlat_register_redundant(CONF_SECTION *cs) if (!mrx->xlat->flags.pure) flags &= ~XLAT_FUNC_FLAG_PURE; xlat_redundant_add_xlat(xr, mrx->xlat); prev_mrx = mrx; - } while ((mrx = fr_rb_iter_next_inorder(&iter)) && (module_xlat_cmp(prev_mrx, mrx) == 0)); + } while ((mrx = fr_rb_iter_next_inorder(mrx_tree, &iter)) && (module_xlat_cmp(prev_mrx, mrx) == 0)); /* * Warn, but allow, redundant/failover expansions that are diff --git a/src/lib/util/dict_util.c b/src/lib/util/dict_util.c index c19d0bad4e4..76fde9090e1 100644 --- a/src/lib/util/dict_util.c +++ b/src/lib/util/dict_util.c @@ -4060,9 +4060,9 @@ static void dependent_debug(fr_dict_t *dict) fprintf(stderr, "DEPENDENTS FOR %s\n", dict->root->name); - for (dep = fr_rb_iter_init_inorder(&iter, dict->dependents); + for (dep = fr_rb_iter_init_inorder(dict->dependents, &iter); dep; - dep = fr_rb_iter_next_inorder(&iter)) { + dep = fr_rb_iter_next_inorder(dict->dependents, &iter)) { fprintf(stderr, "\t<- %s (%d)\n", dep->dependent, dep->count); } } @@ -4143,9 +4143,9 @@ static int _dict_free(fr_dict_t *dict) fr_strerror_printf("Refusing to free dictionary \"%s\", still has dependents", dict->root->name); - for (dep = fr_rb_iter_init_inorder(&iter, dict->dependents); + for (dep = fr_rb_iter_init_inorder(dict->dependents, &iter); dep; - dep = fr_rb_iter_next_inorder(&iter)) { + dep = fr_rb_iter_next_inorder(dict->dependents, &iter)) { fr_strerror_printf_push("%s (%d)", dep->dependent, dep->count); } @@ -4871,18 +4871,18 @@ void fr_dict_gctx_debug(FILE *fp, fr_dict_gctx_t const *gctx) for (dict = fr_hash_table_iter_init(gctx->protocol_by_num, &dict_iter); dict; dict = fr_hash_table_iter_next(gctx->protocol_by_num, &dict_iter)) { - for (dep = fr_rb_iter_init_inorder(&dep_iter, dict->dependents); + for (dep = fr_rb_iter_init_inorder(dict->dependents, &dep_iter); dep; - dep = fr_rb_iter_next_inorder(&dep_iter)) { + dep = fr_rb_iter_next_inorder(dict->dependents, &dep_iter)) { fprintf(fp, "\t%s is referenced from %s count (%d)\n", dict->root->name, dep->dependent, dep->count); } } if (gctx->internal) { - for (dep = fr_rb_iter_init_inorder(&dep_iter, gctx->internal->dependents); + for (dep = fr_rb_iter_init_inorder(gctx->internal->dependents, &dep_iter); dep; - dep = fr_rb_iter_next_inorder(&dep_iter)) { + dep = fr_rb_iter_next_inorder(gctx->internal->dependents, &dep_iter)) { fprintf(fp, "\t%s is referenced from %s count (%d)\n", gctx->internal->root->name, dep->dependent, dep->count); } diff --git a/src/lib/util/dl.c b/src/lib/util/dl.c index 8f3c6af8b8f..05cd062200f 100644 --- a/src/lib/util/dl.c +++ b/src/lib/util/dl.c @@ -704,9 +704,9 @@ static int _dl_loader_free(dl_loader_t *dl_loader) /* * Yes, this is the correct call order */ - for (data = fr_rb_iter_init_inorder(&iter, dl_loader->tree); + for (data = fr_rb_iter_init_inorder(dl_loader->tree, &iter); data; - data = fr_rb_iter_next_inorder(&iter)) { + data = fr_rb_iter_next_inorder(dl_loader->tree, &iter)) { dl_t *dl = talloc_get_type_abort(data, dl_t); fr_strerror_printf_push(" %s (%zu)", dl->name, talloc_reference_count(dl)); diff --git a/src/lib/util/rb.c b/src/lib/util/rb.c index 49f598d553e..1371e8abac9 100644 --- a/src/lib/util/rb.c +++ b/src/lib/util/rb.c @@ -815,13 +815,13 @@ void *fr_rb_last(fr_rb_tree_t *tree) /** Initialise an in-order iterator * - * @param[out] iter to initialise. * @param[in] tree to iterate over. + * @param[out] iter to initialise. * @return * - The first node. Mutex will be held. * - NULL if the tree is empty. */ -void *fr_rb_iter_init_inorder(fr_rb_iter_inorder_t *iter, fr_rb_tree_t *tree) +void *fr_rb_iter_init_inorder(fr_rb_tree_t *tree, fr_rb_iter_inorder_t *iter) { fr_rb_node_t *x = tree->root; @@ -833,7 +833,6 @@ void *fr_rb_iter_init_inorder(fr_rb_iter_inorder_t *iter, fr_rb_tree_t *tree) while (x->left != NIL) x = x->left; *iter = (fr_rb_iter_inorder_t){ - .tree = tree, .node = x }; @@ -842,12 +841,13 @@ void *fr_rb_iter_init_inorder(fr_rb_iter_inorder_t *iter, fr_rb_tree_t *tree) /** Return the next node * + * @param[in] tree to iterate over. * @param[in] iter previously initialised with #fr_rb_iter_init_inorder * @return * - The next node. * - NULL if no more nodes remain. */ -void *fr_rb_iter_next_inorder(fr_rb_iter_inorder_t *iter) +void *fr_rb_iter_next_inorder(UNUSED fr_rb_tree_t *tree, fr_rb_iter_inorder_t *iter) { fr_rb_node_t *x = iter->node, *y; @@ -893,28 +893,29 @@ void *fr_rb_iter_next_inorder(fr_rb_iter_inorder_t *iter) * * @note Only makes sense for in-order traversals. * + * @param[in] tree to iterate over. * @param[in] iter previously initialised with #fr_rb_iter_init_inorder */ -void fr_rb_iter_delete_inorder(fr_rb_iter_inorder_t *iter) +void fr_rb_iter_delete_inorder(fr_rb_tree_t *tree, fr_rb_iter_inorder_t *iter) { fr_rb_node_t *x = iter->node; if (unlikely(x == NIL)) return; - (void) fr_rb_iter_next_inorder(iter); + (void) fr_rb_iter_next_inorder(tree, iter); iter->next = iter->node; iter->node = NULL; - delete_internal(iter->tree, x, true); + delete_internal(tree, x, true); } /** Initialise a pre-order iterator * - * @param[out] iter to initialise. * @param[in] tree to iterate over. + * @param[out] iter to initialise. * @return * - The first node. Mutex will be held. * - NULL if the tree is empty. */ -void *fr_rb_iter_init_preorder(fr_rb_iter_preorder_t *iter, fr_rb_tree_t *tree) +void *fr_rb_iter_init_preorder(fr_rb_tree_t *tree, fr_rb_iter_preorder_t *iter) { fr_rb_node_t *x = tree->root; @@ -924,7 +925,6 @@ void *fr_rb_iter_init_preorder(fr_rb_iter_preorder_t *iter, fr_rb_tree_t *tree) * First, the root. */ *iter = (fr_rb_iter_preorder_t){ - .tree = tree, .node = x }; @@ -933,12 +933,13 @@ void *fr_rb_iter_init_preorder(fr_rb_iter_preorder_t *iter, fr_rb_tree_t *tree) /** Return the next node * + * @param[in] tree to iterate over. * @param[in] iter previously initialised with #fr_rb_iter_init_preorder * @return * - The next node. * - NULL if no more nodes remain. */ -void *fr_rb_iter_next_preorder(fr_rb_iter_preorder_t *iter) +void *fr_rb_iter_next_preorder(UNUSED fr_rb_tree_t *tree, fr_rb_iter_preorder_t *iter) { fr_rb_node_t *x = iter->node, *y; @@ -985,13 +986,13 @@ void *fr_rb_iter_next_preorder(fr_rb_iter_preorder_t *iter) /** Initialise a post-order iterator * - * @param[out] iter to initialise. * @param[in] tree to iterate over. + * @param[out] iter to initialise. * @return * - The first node. * - NULL if the tree is empty. */ -void *fr_rb_iter_init_postorder(fr_rb_iter_postorder_t *iter, fr_rb_tree_t *tree) +void *fr_rb_iter_init_postorder(fr_rb_tree_t *tree, fr_rb_iter_postorder_t *iter) { fr_rb_node_t *x = tree->root; @@ -1008,7 +1009,6 @@ void *fr_rb_iter_init_postorder(fr_rb_iter_postorder_t *iter, fr_rb_tree_t *tree } *iter = (fr_rb_iter_postorder_t){ - .tree = tree, .node = x }; @@ -1017,12 +1017,13 @@ void *fr_rb_iter_init_postorder(fr_rb_iter_postorder_t *iter, fr_rb_tree_t *tree /** Return the next node * + * @param[in] tree to iterate over. * @param[in] iter previously initialised with #fr_rb_iter_init_postorder * @return * - The next node. * - NULL if no more nodes remain. */ -void *fr_rb_iter_next_postorder(fr_rb_iter_postorder_t *iter) +void *fr_rb_iter_next_postorder(UNUSED fr_rb_tree_t *tree, fr_rb_iter_postorder_t *iter) { fr_rb_node_t *x = iter->node, *y; @@ -1075,9 +1076,9 @@ int fr_rb_flatten_##_order(TALLOC_CTX *ctx, void **out[], fr_rb_tree_t *tree) \ fr_rb_iter_##_order##_t iter; \ void *item, **list; \ if (unlikely(!(list = talloc_array(ctx, void *, num)))) return -1; \ - for (item = fr_rb_iter_init_##_order(&iter, tree), i = 0; \ + for (item = fr_rb_iter_init_##_order(tree, &iter), i = 0; \ item; \ - item = fr_rb_iter_next_##_order(&iter), i++) list[i] = item; \ + item = fr_rb_iter_next_##_order(tree, &iter), i++) list[i] = item; \ *out = list; \ return 0; \ } diff --git a/src/lib/util/rb.h b/src/lib/util/rb.h index 0fe56ccec7a..c53c14e0844 100644 --- a/src/lib/util/rb.h +++ b/src/lib/util/rb.h @@ -319,53 +319,50 @@ static inline bool fr_rb_node_inline_in_tree(fr_rb_node_t const *node) /** Iterator structure for in-order traversal of an rbtree */ typedef struct { - fr_rb_tree_t *tree; //!< Tree being iterated over. fr_rb_node_t *node; ///< current node--set to NULL (not NIL) by fr_rb_iter_delete() fr_rb_node_t *next; ///< if non-NULL, next node cached by fr_rb_iter_delete() } fr_rb_iter_inorder_t; -void *fr_rb_iter_init_inorder(fr_rb_iter_inorder_t *iter, fr_rb_tree_t *tree) CC_HINT(nonnull); +void *fr_rb_iter_init_inorder(fr_rb_tree_t *tree, fr_rb_iter_inorder_t *iter) CC_HINT(nonnull); -void *fr_rb_iter_next_inorder(fr_rb_iter_inorder_t *iter) CC_HINT(nonnull); +void *fr_rb_iter_next_inorder(fr_rb_tree_t *tree, fr_rb_iter_inorder_t *iter) CC_HINT(nonnull); -void fr_rb_iter_delete_inorder(fr_rb_iter_inorder_t *iter) CC_HINT(nonnull); +void fr_rb_iter_delete_inorder(fr_rb_tree_t *tree, fr_rb_iter_inorder_t *iter) CC_HINT(nonnull); #define fr_rb_inorder_foreach(_tree, _type, _iter) \ { \ fr_rb_iter_inorder_t _state; \ - for (_type *_iter = fr_rb_iter_init_inorder(&_state, _tree); _iter; _iter = fr_rb_iter_next_inorder(&_state)) + for (_type *_iter = fr_rb_iter_init_inorder(_tree, &_state); _iter; _iter = fr_rb_iter_next_inorder(_tree, &_state)) /** Iterator structure for pre-order traversal of an rbtree */ typedef struct { - fr_rb_tree_t *tree; //!< Tree being iterated over. fr_rb_node_t *node; ///< current node } fr_rb_iter_preorder_t; -void *fr_rb_iter_init_preorder(fr_rb_iter_preorder_t *iter, fr_rb_tree_t *tree) CC_HINT(nonnull); +void *fr_rb_iter_init_preorder(fr_rb_tree_t *tree, fr_rb_iter_preorder_t *iter) CC_HINT(nonnull); -void *fr_rb_iter_next_preorder(fr_rb_iter_preorder_t *iter) CC_HINT(nonnull); +void *fr_rb_iter_next_preorder(fr_rb_tree_t *tree, fr_rb_iter_preorder_t *iter) CC_HINT(nonnull); #define fr_rb_preorder_foreach(_tree, _type, _iter) \ { \ fr_rb_iter_preorder_t _state; \ - for (_type *_iter = fr_rb_iter_init_preorder(&_state, _tree); _iter; _iter = fr_rb_iter_next_preorder(&_state)) + for (_type *_iter = fr_rb_iter_init_preorder(_tree, &_state); _iter; _iter = fr_rb_iter_next_preorder(_tree, &_state)) /** Iterator structure for post-order traversal of an rbtree */ typedef struct { - fr_rb_tree_t *tree; //!< Tree being iterated over. fr_rb_node_t *node; ///< current node } fr_rb_iter_postorder_t; -void *fr_rb_iter_init_postorder(fr_rb_iter_postorder_t *iter, fr_rb_tree_t *tree) CC_HINT(nonnull); +void *fr_rb_iter_init_postorder(fr_rb_tree_t *tree, fr_rb_iter_postorder_t *iter) CC_HINT(nonnull); -void *fr_rb_iter_next_postorder(fr_rb_iter_postorder_t *iter) CC_HINT(nonnull); +void *fr_rb_iter_next_postorder(fr_rb_tree_t *tree, fr_rb_iter_postorder_t *iter) CC_HINT(nonnull); #define fr_rb_postorder_foreach(_tree, _type, _iter) \ { \ fr_rb_iter_postorder_t _state; \ - for (_type *_iter = fr_rb_iter_init_postorder(&_state, _tree); _iter; _iter = fr_rb_iter_next_postorder(&_state)) + for (_type *_iter = fr_rb_iter_init_postorder(_tree, &_state); _iter; _iter = fr_rb_iter_next_postorder(_tree, &_state)) int fr_rb_flatten_inorder(TALLOC_CTX *ctx, void **out[], fr_rb_tree_t *tree); diff --git a/src/lib/util/rb_tests.c b/src/lib/util/rb_tests.c index ec254e2e69f..71add2c290d 100644 --- a/src/lib/util/rb_tests.c +++ b/src/lib/util/rb_tests.c @@ -71,9 +71,9 @@ static void test_fr_rb_iter_inorder(void) qsort(sorted, n, sizeof(fr_rb_tree_test_node_t), fr_rb_qsort_cmp); - for (p = fr_rb_iter_init_inorder(&iter, t), i = 0; + for (p = fr_rb_iter_init_inorder(t, &iter), i = 0; p; - p = fr_rb_iter_next_inorder(&iter), i++) { + p = fr_rb_iter_next_inorder(t, &iter), i++) { TEST_MSG("Checking sorted[%zu] s = %u vs n = %u", i, sorted[i].num, p->num); TEST_CHECK(sorted[i].num == p->num); } @@ -110,9 +110,9 @@ static void test_fr_rb_iter_preorder(void) fr_rb_insert(t, p); } - for (p = fr_rb_iter_init_preorder(&iter, t), i = 0; + for (p = fr_rb_iter_init_preorder(t, &iter), i = 0; p; - p = fr_rb_iter_next_preorder(&iter), i++) { + p = fr_rb_iter_next_preorder(t, &iter), i++) { TEST_MSG("Checking pre_output[%zu] = %u vs n = %u", i, pre_output[i], p->num); TEST_CHECK(pre_output[i] == p->num); } @@ -140,9 +140,9 @@ static void test_fr_rb_iter_postorder(void) fr_rb_insert(t, p); } - for (p = fr_rb_iter_init_postorder(&iter, t), i = 0; + for (p = fr_rb_iter_init_postorder(t, &iter), i = 0; p; - p = fr_rb_iter_next_postorder(&iter), i++) { + p = fr_rb_iter_next_postorder(t, &iter), i++) { TEST_MSG("Checking post_output[%zu] s = %u vs n = %u", i, post_output[i], p->num); TEST_CHECK(post_output[i] == p->num); } @@ -191,18 +191,18 @@ static void test_fr_rb_iter_delete(void) /* * Remove the primes. */ - for (p = fr_rb_iter_init_inorder(&iter, t); + for (p = fr_rb_iter_init_inorder(t, &iter); p; - p = fr_rb_iter_next_inorder(&iter)) { - if (is_prime(p->num)) fr_rb_iter_delete_inorder(&iter); + p = fr_rb_iter_next_inorder(t, &iter)) { + if (is_prime(p->num)) fr_rb_iter_delete_inorder(t, &iter); } /* * Check that all the non-primes are still there. */ - for (p = fr_rb_iter_init_inorder(&iter, t), i = 0; + for (p = fr_rb_iter_init_inorder(t, &iter), i = 0; p; - p = fr_rb_iter_next_inorder(&iter), i++) { + p = fr_rb_iter_next_inorder(t, &iter), i++) { TEST_MSG("Checking non_primes[%zu] = %u vs p->num = %u", i, non_primes[i], p->num); TEST_CHECK(non_primes[i] == p->num); } diff --git a/src/lib/util/timer.c b/src/lib/util/timer.c index 9b07f97f3ca..67b8f16a513 100644 --- a/src/lib/util/timer.c +++ b/src/lib/util/timer.c @@ -1531,9 +1531,9 @@ void fr_timer_report(fr_timer_list_t *tl, fr_time_t now, void *uctx) EVENT_DEBUG(" events %5s - %5s : %zu", decade_names[i - 1], decade_names[i], array[i]); } - for (node = fr_rb_iter_init_inorder(&event_iter, locations[i]); + for (node = fr_rb_iter_init_inorder(locations[i], &event_iter); node; - node = fr_rb_iter_next_inorder(&event_iter)) { + node = fr_rb_iter_next_inorder(locations[i], &event_iter)) { fr_event_counter_t *counter = talloc_get_type_abort(node, fr_event_counter_t); EVENT_DEBUG(" : %u allocd at %s[%d]", diff --git a/src/listen/bfd/proto_bfd_udp.c b/src/listen/bfd/proto_bfd_udp.c index 2e40eb6b90e..51183e7c192 100644 --- a/src/listen/bfd/proto_bfd_udp.c +++ b/src/listen/bfd/proto_bfd_udp.c @@ -440,9 +440,9 @@ static int mod_instantiate(module_inst_ctx_t const *mctx) /* * Walk over the list of peers, associating them with this listener. */ - for (peer = fr_rb_iter_init_inorder(&iter, inst->peers); + for (peer = fr_rb_iter_init_inorder(inst->peers, &iter); peer != NULL; - peer = fr_rb_iter_next_inorder(&iter)) { + peer = fr_rb_iter_next_inorder(inst->peers, &iter)) { if (peer->client.ipaddr.af != inst->ipaddr.af) continue; if (peer->inst) continue; @@ -496,9 +496,9 @@ static void mod_event_list_set(fr_listen_t *li, fr_event_list_t *el, void *nr) /* * Walk over the list of peers, associating them with this listener. */ - for (peer = fr_rb_iter_init_inorder(&iter, inst->peers); + for (peer = fr_rb_iter_init_inorder(inst->peers, &iter); peer != NULL; - peer = fr_rb_iter_next_inorder(&iter)) { + peer = fr_rb_iter_next_inorder(inst->peers, &iter)) { if (peer->inst != inst) continue; peer->el = el; 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 ff379f92489..c2fe0e2eb09 100644 --- a/src/modules/rlm_cache/drivers/rlm_cache_rbtree/rlm_cache_rbtree.c +++ b/src/modules/rlm_cache/drivers/rlm_cache_rbtree/rlm_cache_rbtree.c @@ -294,10 +294,10 @@ static int mod_detach(module_detach_ctx_t const *mctx) fr_rb_iter_inorder_t iter; void *data; - for (data = fr_rb_iter_init_inorder(&iter, mutable->cache); + for (data = fr_rb_iter_init_inorder(mutable->cache, &iter); data; - data = fr_rb_iter_next_inorder(&iter)) { - fr_rb_iter_delete_inorder(&iter); + data = fr_rb_iter_next_inorder(mutable->cache, &iter)) { + fr_rb_iter_delete_inorder(mutable->cache, &iter); talloc_free(data); } } diff --git a/src/modules/rlm_lua/rlm_lua.c b/src/modules/rlm_lua/rlm_lua.c index 3fc7643ef67..8d60f9a04f1 100644 --- a/src/modules/rlm_lua/rlm_lua.c +++ b/src/modules/rlm_lua/rlm_lua.c @@ -165,8 +165,10 @@ static int mod_instantiate(module_inst_ctx_t const *mctx) * automatic subroutine names based on section name. */ if (!inst->funcs_init) fr_rb_inline_init(&inst->funcs, lua_func_def_t, node, lua_func_def_cmp, NULL); - func = fr_rb_iter_init_inorder(&iter, &inst->funcs); - while (func) { + + for (func = fr_rb_iter_init_inorder(&inst->funcs, &iter); + func != NULL; + func = fr_rb_iter_next_inorder(&inst->funcs, &iter)) { /* * Check for func__ or func_ config pairs. */ @@ -203,8 +205,6 @@ static int mod_instantiate(module_inst_ctx_t const *mctx) return -1; } } - - func = fr_rb_iter_next_inorder(&iter); } if (inst->func_instantiate) { diff --git a/src/modules/rlm_mruby/rlm_mruby.c b/src/modules/rlm_mruby/rlm_mruby.c index ac645cd7de6..1b64259986d 100644 --- a/src/modules/rlm_mruby/rlm_mruby.c +++ b/src/modules/rlm_mruby/rlm_mruby.c @@ -221,8 +221,10 @@ static int mod_instantiate(module_inst_ctx_t const *mctx) } if (!inst->funcs_init) fr_rb_inline_init(&inst->funcs, mruby_func_def_t, node, mruby_func_def_cmp, NULL); - func = fr_rb_iter_init_inorder(&iter, &inst->funcs); - while (func) { + + for (func = fr_rb_iter_init_inorder(&inst->funcs, &iter); + func != NULL; + func = fr_rb_iter_next_inorder(&inst->funcs, &iter)) { /* * Check for func__ or func_ config pairs. */ @@ -262,8 +264,6 @@ static int mod_instantiate(module_inst_ctx_t const *mctx) return -1; } } - - func = fr_rb_iter_next_inorder(&iter); } if (mrb_nil_p(mrb_check_intern_cstr(mrb, "instantiate"))) return 0; diff --git a/src/modules/rlm_perl/rlm_perl.c b/src/modules/rlm_perl/rlm_perl.c index 0b717f35c6b..2574eeb9e5e 100644 --- a/src/modules/rlm_perl/rlm_perl.c +++ b/src/modules/rlm_perl/rlm_perl.c @@ -1699,8 +1699,10 @@ static int mod_instantiate(module_inst_ctx_t const *mctx) * automatic subroutine names based on section name. */ if (!inst->funcs_init) fr_rb_inline_init(&inst->funcs, perl_func_def_t, node, perl_func_def_cmp, NULL); - func = fr_rb_iter_init_inorder(&iter, &inst->funcs); - while (func) { + + for (func = fr_rb_iter_init_inorder(&inst->funcs, &iter); + func != NULL; + func = fr_rb_iter_next_inorder(&inst->funcs, &iter)) { /* * Check for func__ or func_ config pairs. */ @@ -1736,9 +1738,7 @@ static int mod_instantiate(module_inst_ctx_t const *mctx) cf_log_err(cp, "Perl subroutine %s does not exist", func->function_name); return -1; } - } - - func = fr_rb_iter_next_inorder(&iter); + } } PL_endav = end_AV; diff --git a/src/modules/rlm_python/rlm_python.c b/src/modules/rlm_python/rlm_python.c index 5b84bc1ac85..820bf1f1160 100644 --- a/src/modules/rlm_python/rlm_python.c +++ b/src/modules/rlm_python/rlm_python.c @@ -1696,8 +1696,9 @@ static int mod_instantiate(module_inst_ctx_t const *mctx) /* * Load all the Python functions found by the call_env parser. */ - func = fr_rb_iter_init_inorder(&iter, &inst->funcs); - while (func) { + for (func = fr_rb_iter_init_inorder(&inst->funcs, &iter); + func != NULL; + func = fr_rb_iter_next_inorder(&inst->funcs, &iter)) { /* * Check for mod__ or mod_ config pairs. * If neither exist, fall back to default Python module. @@ -1732,7 +1733,6 @@ static int mod_instantiate(module_inst_ctx_t const *mctx) if (cp) func->function_name = cf_pair_value(cp); if (python_function_load(mctx, func) < 0) goto error; - func = fr_rb_iter_next_inorder(&iter); } /* @@ -1795,10 +1795,10 @@ static int mod_detach(module_detach_ctx_t const *mctx) PYTHON_FUNC_DESTROY(instantiate); PYTHON_FUNC_DESTROY(detach); - func = fr_rb_iter_init_inorder(&iter, &inst->funcs); - while (func) { + for (func = fr_rb_iter_init_inorder(&inst->funcs, &iter); + func != NULL; + func = fr_rb_iter_next_inorder(&inst->funcs, &iter)) { python_function_destroy(func); - func = fr_rb_iter_next_inorder(&iter); } PyEval_SaveThread(); diff --git a/src/modules/rlm_rest/rlm_rest.c b/src/modules/rlm_rest/rlm_rest.c index bf5f66c9e62..18421f5deaf 100644 --- a/src/modules/rlm_rest/rlm_rest.c +++ b/src/modules/rlm_rest/rlm_rest.c @@ -1219,11 +1219,11 @@ static int mod_instantiate(module_inst_ctx_t const *mctx) /* * Parse section configs from calls found by the call_env parser. */ - section = fr_rb_iter_init_inorder(&iter, &inst->sections); - while (section) { + for (section = fr_rb_iter_init_inorder(&inst->sections, &iter); + section != NULL; + section = fr_rb_iter_next_inorder(&inst->sections, &iter)) { if (parse_sub_section(inst, conf, section_config, §ion->section, cf_section_name(section->cs), section->cs) < 0) return -1; - section = fr_rb_iter_next_inorder(&iter); } inst->conn_config.reuse.num_children = 1; diff --git a/src/tests/rbmonkey.c b/src/tests/rbmonkey.c index 136b93f095b..21a5c272328 100644 --- a/src/tests/rbmonkey.c +++ b/src/tests/rbmonkey.c @@ -179,19 +179,19 @@ again: * */ - for (node = fr_rb_iter_init_inorder(&iter, t); + for (node = fr_rb_iter_init_inorder(t, &iter); node; - node = fr_rb_iter_next_inorder(&iter)) { - if ((node->num & mask) == (thresh.num & mask)) fr_rb_iter_delete_inorder(&iter); + node = fr_rb_iter_next_inorder(t, &iter)) { + if ((node->num & mask) == (thresh.num & mask)) fr_rb_iter_delete_inorder(t, &iter); } i = rbcount(t); fprintf(stderr,"After delete rbcount is %i\n", i); if (i < 0) return i; cb_stored = 0; - for (node = fr_rb_iter_init_inorder(&iter, t); + for (node = fr_rb_iter_init_inorder(t, &iter); node; - node = fr_rb_iter_next_inorder(&iter)) { + node = fr_rb_iter_next_inorder(t, &iter)) { rvals[cb_stored++].num = node->num; }