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 252e5208526e19186e3d8f0704c3380357341d50..58b0821e8d146ff84f150728dc7efa0d3f14c985 100644 (file)
--- 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 51dd2049c70ec8b561341a2cf75d6094a5a423bf..4d049bff8ca0f3f338c79bd7292ee3866c6c2be7 100644 (file)
--- 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 170abdcc6b66d1f00dd83ca6afe703e78d6421e0..5ec6b47d1665dce59be508720fcc83fa8a1859b5 100644 (file)
--- 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 3728f71db9a8a1e50acbe2a3d02f8d13cd3459b3..72f1a6c647d550dd921a6f7337a95a61858eafc5 100644 (file)
--- 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 b8a7cdf56fb897b8a00015f3b82d36ba2a8d7951..16f336329e9178b97bfabb62741287b62c56a516 100644 (file)
--- 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 0e8c319fb3da3846461aac7288291e3aae9b4b02..c264596c76c3bbd8325288d360c038b552898e19 100644 (file)
--- 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 b752457e9e84a290c64261044278bb3759629838..2cb471c662a66dca92dbbaa54a56686e3eb10ac0 100644 (file)
--- 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 1d25388fc4516ed1246523e83ef9ee627379c022..851fe14a35e8f4e61ade0f032fd41047fd2ee8b5 100644 (file)
--- 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 c3c8b0442b3bf2fd10f0d1eadda070b4ac1a7153..fd2c4d085478aa74293b81f79cdb0da916df8f0d 100644 (file)
--- 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 e6eddb81fcbbfbb1121ad63b9a229b29ff93b941..79406c8af7661ed844260def79432208b8cb9951 100644 (file)
--- 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 c19d0bad4e4dbcb367e424f3a97af41f2ce7c0e8..76fde9090e1ef2b2a893b84c96f31717822cbbb8 100644 (file)
--- 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 8f3c6af8b8fd3feac5a124c5e8ff7bcae387a281..05cd062200f980a997f8576855d754feeb7a9264 100644 (file)
--- 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 49f598d553ee2e541f4e773d22b0cea1bcdaf324..1371e8abac99659ec2183ca6f314b9b9249d1bfd 100644 (file)
--- 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 0fe56ccec7ab455556b89432090c9e3b46a55766..c53c14e0844957beaf7bf00a4bd5381e6c59dcce 100644 (file)
--- 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 ec254e2e69f2c15e1eb75cd16b827410134491f4..71add2c290d8613d49d1f11432f4c85b736c32dc 100644 (file)
--- 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 9b07f97f3ca8ffb1a246d181c00e567c78c1150b..67b8f16a51350300a7d05a9b4aa27aad82614877 100644 (file)
--- 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 2e40eb6b90eedd466c1025ff99b87ac7cf054f8c..51183e7c192c05577e4938d37f6ac4484e197e77 100644 (file)
--- 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 ff379f92489fa847498bc47ac542beba9daf1e3d..c2fe0e2eb0987db582fd865c8139735e48a67c0d 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
@@ -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 3fc7643ef6719ab10dc4b661ece44de726940eb1..8d60f9a04f1a76be624d6ae019a1a4dd8c1097f5 100644 (file)
--- 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_<name1>_<name2> or func_<name1> 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 ac645cd7de6f08e5fa15ca10ed7551f60f7ded1e..1b64259986dd285b4bcd7e950e18309746666d50 100644 (file)
--- 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_<name1>_<name2> or func_<name1> 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 0b717f35c6b857c6433a47b325f33b0414e0f4b7..2574eeb9e5e3e926cb2402a54bc0dbb63defccd7 100644 (file)
--- 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_<name1>_<name2> or func_<name1> 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 5b84bc1ac85fab2aa78c917c655414560f71fbec..820bf1f11603cb4dab88e5d6358e54a4e3412ecd 100644 (file)
--- 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_<name1>_<name2> or mod_<name1> 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 bf5f66c9e62e5ddaaebd1e543783ccb5235722c1..18421f5deaf8d15d21acfdb8038cc76989e9bd8c 100644 (file)
--- 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, &section->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 136b93f095b680d24ce958742cdda5f4a6ecce23..21a5c272328b7549f681039388926fb718c48bf5 100644 (file)
--- 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;
        }