xlat: Set func flags using a separate function as the majority of registrations don...

diff --git a/src/bin/unit_test_attribute.c b/src/bin/unit_test_attribute.c
index 1f5dbc865813ff3b0f69a1a7ad849703b02b1923..2e18b63ee5c0dbcb8ed8afd0f46eba36731b9e5d 100644 (file)
--- a/src/bin/unit_test_attribute.c
+++ b/src/bin/unit_test_attribute.c
@@ -3850,7 +3850,7 @@ int main(int argc, char *argv[])
 
        unlang_thread_instantiate(thread_ctx);
 
-       if (!xlat_register(NULL, "test", xlat_test, FR_TYPE_NULL, NULL)) {
+       if (!xlat_register(NULL, "test", xlat_test, FR_TYPE_NULL)) {
                ERROR("Failed registering xlat");
                EXIT_WITH_FAILURE;
        }

diff --git a/src/lib/eap_aka_sim/xlat.c b/src/lib/eap_aka_sim/xlat.c
index c3d55f3097dccf8669a7d3d75c3d0d33faa83025..6714130cc3356480bab05c51ffe8aadeba5901b5 100644 (file)
--- a/src/lib/eap_aka_sim/xlat.c
+++ b/src/lib/eap_aka_sim/xlat.c
@@ -503,16 +503,16 @@ void fr_aka_sim_xlat_register(void)
                return;
        }
 
-       xlat = xlat_register(NULL, "aka_sim_id_method", aka_sim_xlat_id_method_xlat, FR_TYPE_STRING, NULL);
-       xlat_func_args(xlat, aka_sim_xlat_id_method_xlat_args);
-       xlat = xlat_register(NULL, "aka_sim_id_type", aka_sim_xlat_id_type_xlat, FR_TYPE_STRING, NULL);
-       xlat_func_args(xlat, aka_sim_xlat_id_type_xlat_args);
-       xlat = xlat_register(NULL, "3gpp_temporary_id_key_index", aka_sim_id_3gpp_temporary_id_key_index_xlat, FR_TYPE_UINT8, NULL);
-       xlat_func_args(xlat, aka_sim_id_3gpp_temporary_id_key_index_xlat_args);
-       xlat = xlat_register(NULL, "3gpp_temporary_id_decrypt", aka_sim_3gpp_temporary_id_decrypt_xlat, FR_TYPE_STRING, NULL);
-       xlat_func_args(xlat, aka_sim_3gpp_temporary_id_decrypt_xlat_args);
-       xlat = xlat_register(NULL, "3gpp_temporary_id_encrypt", aka_sim_3gpp_temporary_id_encrypt_xlat, FR_TYPE_STRING, NULL);
-       xlat_func_args(xlat, aka_sim_3gpp_temporary_id_encrypt_xlat_args);
+       xlat = xlat_register(NULL, "aka_sim_id_method", aka_sim_xlat_id_method_xlat, FR_TYPE_STRING);
+       xlat_func_args_set(xlat, aka_sim_xlat_id_method_xlat_args);
+       xlat = xlat_register(NULL, "aka_sim_id_type", aka_sim_xlat_id_type_xlat, FR_TYPE_STRING);
+       xlat_func_args_set(xlat, aka_sim_xlat_id_type_xlat_args);
+       xlat = xlat_register(NULL, "3gpp_temporary_id_key_index", aka_sim_id_3gpp_temporary_id_key_index_xlat, FR_TYPE_UINT8);
+       xlat_func_args_set(xlat, aka_sim_id_3gpp_temporary_id_key_index_xlat_args);
+       xlat = xlat_register(NULL, "3gpp_temporary_id_decrypt", aka_sim_3gpp_temporary_id_decrypt_xlat, FR_TYPE_STRING);
+       xlat_func_args_set(xlat, aka_sim_3gpp_temporary_id_decrypt_xlat_args);
+       xlat = xlat_register(NULL, "3gpp_temporary_id_encrypt", aka_sim_3gpp_temporary_id_encrypt_xlat, FR_TYPE_STRING);
+       xlat_func_args_set(xlat, aka_sim_3gpp_temporary_id_encrypt_xlat_args);
        aka_sim_xlat_refs = 1;
 }
 

diff --git a/src/lib/server/main_config.c b/src/lib/server/main_config.c
index 537b8e14a98efe74b390e36482bc2c776e5b26c5..d13057bf7445e2c6b996ca8ecf0fc0f20467b8e3 100644 (file)
--- a/src/lib/server/main_config.c
+++ b/src/lib/server/main_config.c
@@ -23,6 +23,7 @@
  * @copyright 2002,2006-2007 The FreeRADIUS server project
  * @copyright 2002 Alan DeKok (aland@freeradius.org)
  */
+#include "lib/unlang/xlat.h"
 RCSID("$Id$")
 
 #include <freeradius-devel/server/cf_file.h>
@@ -1364,8 +1365,9 @@ do {\
        /*
         *      Register the %(config:section.subsection) xlat function.
         */
-       xlat = xlat_register(NULL, "config", xlat_config, FR_TYPE_STRING, XLAT_FLAG_PURE);
-       xlat_func_args(xlat, xlat_config_args);
+       xlat = xlat_register(NULL, "config", xlat_config, FR_TYPE_STRING);
+       xlat_func_args_set(xlat, xlat_config_args);
+       xlat_func_flags_set(xlat, XLAT_FLAG_PURE);
 
        /*
         *      Ensure cwd is inside the chroot.

diff --git a/src/lib/unlang/foreach.c b/src/lib/unlang/foreach.c
index 8eaddbbc58483361d76d71a32df267086e4a1c32..37ea16d3ddd1c6e14c6e4990e60e6efe8383ba64 100644 (file)
--- a/src/lib/unlang/foreach.c
+++ b/src/lib/unlang/foreach.c
@@ -275,7 +275,7 @@ void unlang_foreach_init(void)
                xlat_t *x;
 
                x = xlat_register(NULL, xlat_foreach_names[i],
-                                 unlang_foreach_xlat, FR_TYPE_VOID, 0);
+                                 unlang_foreach_xlat, FR_TYPE_VOID);
                fr_assert(x);
                x->uctx = &xlat_foreach_inst[i];
                xlat_internal(x);

diff --git a/src/lib/unlang/interpret.c b/src/lib/unlang/interpret.c
index 22bb514cd4ac0f9b29f72403f7c527f47491e0b0..06e69c5b9a4bc75f61a258ae649bafcdf5cd5f88 100644 (file)
--- a/src/lib/unlang/interpret.c
+++ b/src/lib/unlang/interpret.c
@@ -1632,9 +1632,9 @@ void unlang_interpret_init_global(void)
         *  Should be void, but someone decided not to register multiple xlats
         *  breaking the convention we use everywhere else in the server...
         */
-       xlat = xlat_register(NULL, "interpreter", unlang_interpret_xlat, FR_TYPE_VOID, NULL);
-       xlat_func_args(xlat, unlang_interpret_xlat_args);
+       xlat = xlat_register(NULL, "interpreter", unlang_interpret_xlat, FR_TYPE_VOID);
+       xlat_func_args_set(xlat, unlang_interpret_xlat_args);
 
-       xlat = xlat_register(NULL, "cancel", unlang_cancel_xlat, FR_TYPE_VOID, NULL);
-       xlat_func_args(xlat, unlang_cancel_xlat_args);
+       xlat = xlat_register(NULL, "cancel", unlang_cancel_xlat, FR_TYPE_VOID);
+       xlat_func_args_set(xlat, unlang_cancel_xlat_args);
 }

diff --git a/src/lib/unlang/xlat.h b/src/lib/unlang/xlat.h
index b44c0aa80eff7ab268bc7cf6c61e3c1c495b00cc..1fca1b13eb6aa4b5dfd68da0a64cb9a06b5e19e5 100644 (file)
--- a/src/lib/unlang/xlat.h
+++ b/src/lib/unlang/xlat.h
@@ -408,6 +408,8 @@ static inline fr_slen_t xlat_aprint(TALLOC_CTX *ctx, char **out, xlat_exp_head_t
                                    fr_sbuff_escape_rules_t const *e_rules)
                SBUFF_OUT_TALLOC_FUNC_NO_LEN_DEF(xlat_print, head, e_rules)
 
+bool           xlat_is_truthy(xlat_exp_head_t const *head, bool *out);
+
 int            xlat_validate_function_mono(xlat_exp_t *node);
 
 int            xlat_validate_function_args(xlat_exp_t *node);
@@ -425,14 +427,14 @@ bool              xlat_to_string(TALLOC_CTX *ctx, char **str, xlat_exp_head_t **head);
 int            xlat_resolve(xlat_exp_head_t *head, xlat_res_rules_t const *xr_rules);
 
 xlat_t         *xlat_register_module(TALLOC_CTX *ctx, module_inst_ctx_t const *mctx,
-                                     char const *name, xlat_func_t func, fr_type_t return_type, xlat_flags_t const *flags);
-xlat_t         *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, fr_type_t return_type, xlat_flags_t const *flags) CC_HINT(nonnull(2));
+                                     char const *name, xlat_func_t func, fr_type_t return_type);
+xlat_t         *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, fr_type_t return_type) CC_HINT(nonnull(2));
 
-int            xlat_func_args(xlat_t *xlat, xlat_arg_parser_t const args[]) CC_HINT(nonnull);
+int            xlat_func_args_set(xlat_t *xlat, xlat_arg_parser_t const args[]) CC_HINT(nonnull);
 
-int            xlat_func_mono(xlat_t *xlat, xlat_arg_parser_t const *arg) CC_HINT(nonnull);
+int            xlat_func_mono_set(xlat_t *xlat, xlat_arg_parser_t const *arg) CC_HINT(nonnull);
 
-bool           xlat_is_truthy(xlat_exp_head_t const *head, bool *out);
+void           xlat_func_flags_set(xlat_t *x, xlat_flags_t const *flags) CC_HINT(nonnull);
 
 /** Set a callback for global instantiation of xlat functions
  *

diff --git a/src/lib/unlang/xlat_builtin.c b/src/lib/unlang/xlat_builtin.c
index a0c936c1e7ec828d7bd7d9c89f8638050fee2b85..9359831aab33b26b1fee2aa89b860dba0d514109 100644 (file)
--- a/src/lib/unlang/xlat_builtin.c
+++ b/src/lib/unlang/xlat_builtin.c
@@ -33,6 +33,7 @@ RCSID("$Id$")
 #include <freeradius-devel/server/base.h>
 #include <freeradius-devel/server/tmpl_dcursor.h>
 #include <freeradius-devel/unlang/xlat_priv.h>
+#include <freeradius-devel/unlang/xlat.h>
 
 #include <freeradius-devel/io/test_point.h>
 
@@ -155,6 +156,69 @@ static void _xlat_func_tree_free(void *xlat)
        talloc_free(xlat);
 }
 
+#if 0
+/** Compare two argument entries to see if they're equivalent
+ *
+ * @note Does not check escape function or uctx pointers.
+ *
+ * @param[in] a                First argument structure.
+ * @param[in] b                Second argument structure.
+ * @return
+ *     - 1 if a > b
+ *     - 0 if a == b
+ *     - -1 if a < b
+ */
+static int xlat_arg_cmp_no_escape(xlat_arg_parser_t const *a, xlat_arg_parser_t const *b)
+{
+       int8_t ret;
+
+       ret = CMP(a->required, b->required);
+       if (ret != 0) return ret;
+
+       ret = CMP(a->concat, b->concat);
+       if (ret != 0) return ret;
+
+       ret = CMP(a->single, b->single);
+       if (ret != 0) return ret;
+
+       ret = CMP(a->variadic, b->variadic);
+       if (ret != 0) return ret;
+
+       ret = CMP(a->always_escape, b->always_escape);
+       if (ret != 0) return ret;
+
+       return CMP(a->type, b->type);
+}
+
+/** Compare two argument lists to see if they're equivalent
+ *
+ * @note Does not check escape function or uctx pointers.
+ *
+ * @param[in] a                First argument structure.
+ * @param[in] b                Second argument structure.
+ * @return
+ *     - 1 if a > b
+ *     - 0 if a == b
+ *     - -1 if a < b
+ */
+static int xlat_arg_cmp_list_no_escape(xlat_arg_parser_t const a[], xlat_arg_parser_t const b[])
+{
+       xlat_arg_parser_t const *arg_a_p;
+       xlat_arg_parser_t const *arg_b_p;
+
+       for (arg_a_p = a, arg_b_p = b;
+            (arg_a_p->type != FR_TYPE_NULL) && (arg_b_p->type != FR_TYPE_NULL);
+            arg_a_p++, arg_b_p++) {
+               int8_t ret;
+
+               ret = xlat_arg_cmp_no_escape(arg_a_p, arg_b_p);
+               if (ret != 0) return ret;
+       }
+
+       return CMP(arg_a_p, arg_b_p);   /* Check we ended at the same point */
+}
+#endif
+
 /** Register an xlat function for a module
  *
  * @param[in] ctx              Used to automate deregistration of the xlat fnction.
@@ -163,15 +227,13 @@ static void _xlat_func_tree_free(void *xlat)
  * @param[in] name             of the xlat.
  * @param[in] func             to register.
  * @param[in] return_type      what type of output the xlat function will produce.
- * @param[in] flags            various function flags
  * @return
  *     - A handle for the newly registered xlat function on success.
  *     - NULL on failure.
  */
 xlat_t *xlat_register_module(TALLOC_CTX *ctx, module_inst_ctx_t const *mctx,
-                            char const *name, xlat_func_t func, fr_type_t return_type, xlat_flags_t const *flags)
+                            char const *name, xlat_func_t func, fr_type_t return_type)
 {
-       static const xlat_flags_t default_flags;
        xlat_t  *c;
        module_inst_ctx_t *our_mctx = NULL;
 
@@ -182,12 +244,6 @@ xlat_t *xlat_register_module(TALLOC_CTX *ctx, module_inst_ctx_t const *mctx,
                return NULL;
        }
 
-       if (!flags) {
-               flags = &default_flags;
-       } else {
-               fr_assert(!flags->needs_resolving);
-       }
-
        /*
         *      If it already exists, replace the instance.
         */
@@ -219,7 +275,6 @@ xlat_t *xlat_register_module(TALLOC_CTX *ctx, module_inst_ctx_t const *mctx,
                .func = func,
                .return_type = return_type,
                .mctx = our_mctx,
-               .flags = *flags,
                .input_type = XLAT_INPUT_UNPROCESSED    /* set default - will be overridden if args are registered */
        };
        talloc_set_destructor(c, _xlat_func_talloc_free);
@@ -231,12 +286,6 @@ xlat_t *xlat_register_module(TALLOC_CTX *ctx, module_inst_ctx_t const *mctx,
                return NULL;
        }
 
-       /*
-        *      If the function is async, it can't be pure.  But
-        *      non-pure functions don't need to be async.
-        */
-       fr_assert(!flags->needs_resolving);
-
        return c;
 }
 
@@ -246,79 +295,15 @@ xlat_t *xlat_register_module(TALLOC_CTX *ctx, module_inst_ctx_t const *mctx,
  * @param[in] name             of the xlat.
  * @param[in] func             to register.
  * @param[in] return_type      what type of output the xlat function will produce.
- * @param[in] flags            various function flags
  * @return
  *     - A handle for the newly registered xlat function on success.
  *     - NULL on failure.
  */
-xlat_t *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, fr_type_t return_type, xlat_flags_t const *flags)
-{
-       return xlat_register_module(ctx, NULL, name, func, return_type, flags);
-}
-
-#if 0
-/** Compare two argument entries to see if they're equivalent
- *
- * @note Does not check escape function or uctx pointers.
- *
- * @param[in] a                First argument structure.
- * @param[in] b                Second argument structure.
- * @return
- *     - 1 if a > b
- *     - 0 if a == b
- *     - -1 if a < b
- */
-static int xlat_arg_cmp_no_escape(xlat_arg_parser_t const *a, xlat_arg_parser_t const *b)
+xlat_t *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, fr_type_t return_type)
 {
-       int8_t ret;
-
-       ret = CMP(a->required, b->required);
-       if (ret != 0) return ret;
-
-       ret = CMP(a->concat, b->concat);
-       if (ret != 0) return ret;
-
-       ret = CMP(a->single, b->single);
-       if (ret != 0) return ret;
-
-       ret = CMP(a->variadic, b->variadic);
-       if (ret != 0) return ret;
-
-       ret = CMP(a->always_escape, b->always_escape);
-       if (ret != 0) return ret;
-
-       return CMP(a->type, b->type);
+       return xlat_register_module(ctx, NULL, name, func, return_type);
 }
 
-/** Compare two argument lists to see if they're equivalent
- *
- * @note Does not check escape function or uctx pointers.
- *
- * @param[in] a                First argument structure.
- * @param[in] b                Second argument structure.
- * @return
- *     - 1 if a > b
- *     - 0 if a == b
- *     - -1 if a < b
- */
-static int xlat_arg_cmp_list_no_escape(xlat_arg_parser_t const a[], xlat_arg_parser_t const b[])
-{
-       xlat_arg_parser_t const *arg_a_p;
-       xlat_arg_parser_t const *arg_b_p;
-
-       for (arg_a_p = a, arg_b_p = b;
-            (arg_a_p->type != FR_TYPE_NULL) && (arg_b_p->type != FR_TYPE_NULL);
-            arg_a_p++, arg_b_p++) {
-               int8_t ret;
-
-               ret = xlat_arg_cmp_no_escape(arg_a_p, arg_b_p);
-               if (ret != 0) return ret;
-       }
-
-       return CMP(arg_a_p, arg_b_p);   /* Check we ended at the same point */
-}
-#endif
-
 /** Verify xlat arg specifications are valid
  *
  * @param[in] arg      specification to validate.
@@ -372,7 +357,7 @@ static inline int xlat_arg_parser_validate(xlat_arg_parser_t const *arg, bool la
  *     - 0 on success.
  *     - < 0 on failure.
  */
-int xlat_func_args(xlat_t *x, xlat_arg_parser_t const args[])
+int xlat_func_args_set(xlat_t *x, xlat_arg_parser_t const args[])
 {
        xlat_arg_parser_t const *arg_p = args;
        bool                    seen_optional = false;
@@ -404,14 +389,30 @@ int xlat_func_args(xlat_t *x, xlat_arg_parser_t const args[])
  *     - 0 on success.
  *     - < 0 on failure.
  */
-int xlat_func_mono(xlat_t *x, xlat_arg_parser_t const args[])
+int xlat_func_mono_set(xlat_t *x, xlat_arg_parser_t const args[])
 {
-       if (xlat_func_args(x, args) < 0) return -1;
+       if (xlat_func_args_set(x, args) < 0) return -1;
        x->input_type = XLAT_INPUT_MONO;
 
        return 0;
 }
 
+/** Specify flags that alter the xlat's behaviour
+ *
+ * @param[in] x                        xlat to set flags for.
+ * @param[in] flags            to set.
+ */
+void xlat_func_flags_set(xlat_t *x, xlat_flags_t const *flags)
+{
+       /*
+        *      If the function is async, it can't be pure.  But
+        *      non-pure functions don't need to be async.
+        */
+       fr_assert(!flags->needs_resolving);
+
+       x->flags = *flags;
+}
+
 /** Set global instantiation/detach callbacks
  *
  * @param[in] xlat             to set instantiation callbacks for.
@@ -438,7 +439,6 @@ void _xlat_async_instantiate_set(xlat_t const *xlat,
        c->uctx = uctx;
 }
 
-
 /** Register an async xlat
  *
  * All functions registered must be !pure
@@ -476,7 +476,6 @@ void _xlat_async_thread_instantiate_set(xlat_t const *xlat,
        c->thread_uctx = uctx;
 }
 
-
 /** Unregister an xlat function
  *
  * We can only have one function to call per name, so the passing of "func"
@@ -498,7 +497,6 @@ void xlat_unregister(char const *name)
        talloc_free(c); /* Should also remove from tree */
 }
 
-
 void xlat_unregister_module(dl_module_inst_t const *inst)
 {
        xlat_t                          *c;
@@ -516,7 +514,6 @@ void xlat_unregister_module(dl_module_inst_t const *inst)
        }
 }
 
-
 /*
  *     Internal redundant handler for xlats
  */
@@ -936,15 +933,16 @@ int xlat_register_redundant(CONF_SECTION *cs)
                return 1;
        }
 
-       xlat = xlat_register(NULL, name2, xlat_redundant, return_type, &flags);
+       xlat = xlat_register(NULL, name2, xlat_redundant, return_type);
        if (!xlat) {
                ERROR("Registering xlat for %s section failed",
                      fr_table_str_by_value(xlat_redundant_type_table, xr->type, "<INVALID>"));
                talloc_free(xr);
                return -1;
        }
+       xlat_func_flags_set(xlat, &flags);
        xlat_async_instantiate_set(xlat, xlat_redundant_instantiate, xlat_redundant_inst_t, NULL, xr);
-       if (args) xlat_func_args(xlat, xlat_redundant_args);
+       if (args) xlat_func_args_set(xlat, xlat_redundant_args);
 
        return 0;
 }
@@ -4054,9 +4052,9 @@ static int xlat_protocol_register(fr_dict_t const *dict)
        if (tp_decode) {
                snprintf(buffer, sizeof(buffer), "decode.%s", name);
 
-               xlat = xlat_register(NULL, buffer, protocol_decode_xlat, FR_TYPE_UINT32, NULL);
+               xlat = xlat_register(NULL, buffer, protocol_decode_xlat, FR_TYPE_UINT32);
                if (!xlat) return -1;
-               xlat_func_args(xlat, protocol_decode_xlat_args);
+               xlat_func_args_set(xlat, protocol_decode_xlat_args);
                /* coverity[suspicious_sizeof] */
                xlat_async_instantiate_set(xlat, protocol_xlat_instantiate, fr_test_point_pair_decode_t *, NULL, tp_decode);
                xlat_internal(xlat);
@@ -4070,9 +4068,9 @@ static int xlat_protocol_register(fr_dict_t const *dict)
        if (tp_encode) {
                snprintf(buffer, sizeof(buffer), "encode.%s", name);
 
-               xlat = xlat_register(NULL, buffer, protocol_encode_xlat, FR_TYPE_OCTETS, NULL);
+               xlat = xlat_register(NULL, buffer, protocol_encode_xlat, FR_TYPE_OCTETS);
                if (!xlat) return -1;
-               xlat_func_args(xlat, protocol_encode_xlat_args);
+               xlat_func_args_set(xlat, protocol_encode_xlat_args);
                /* coverity[suspicious_sizeof] */
                xlat_async_instantiate_set(xlat, protocol_xlat_instantiate, fr_test_point_pair_encode_t *, NULL, tp_encode);
                xlat_internal(xlat);
@@ -4146,8 +4144,9 @@ int xlat_init(void)
         */
 #define XLAT_REGISTER_ARGS(_xlat, _func, _return_type, _args) \
 do { \
-       if (!(xlat = xlat_register(NULL, _xlat, _func, _return_type, XLAT_FLAG_PURE))) return -1; \
-       xlat_func_args(xlat, _args); \
+       if (!(xlat = xlat_register(NULL, _xlat, _func, _return_type))) return -1; \
+       xlat_func_args_set(xlat, _args); \
+       xlat_func_flags_set(xlat, XLAT_FLAG_PURE); \
        xlat_internal(xlat); \
 } while (0)
 
@@ -4169,8 +4168,8 @@ do { \
 #undef XLAT_REGISTER_ARGS
 #define XLAT_REGISTER_ARGS(_xlat, _func, _return_type, _args) \
 do { \
-       if (!(xlat = xlat_register(NULL, _xlat, _func, _return_type, NULL))) return -1; \
-       xlat_func_args(xlat, _args); \
+       if (!(xlat = xlat_register(NULL, _xlat, _func, _return_type))) return -1; \
+       xlat_func_args_set(xlat, _args); \
        xlat_internal(xlat); \
 } while (0)
 
@@ -4188,9 +4187,9 @@ do { \
        XLAT_REGISTER_ARGS("flatten", xlat_func_flatten, FR_TYPE_NULL, xlat_func_debug_attr_args); /* takes an attribute reference */
        XLAT_REGISTER_ARGS("unflatten", xlat_func_unflatten, FR_TYPE_NULL, xlat_func_debug_attr_args); /* takes an attribute reference */
 
-       xlat = xlat_register(NULL, "untaint", xlat_func_untaint, FR_TYPE_VOID, NULL);
+       xlat = xlat_register(NULL, "untaint", xlat_func_untaint, FR_TYPE_VOID);
        xlat_internal(xlat);
-       xlat = xlat_register(NULL, "taint", xlat_func_taint, FR_TYPE_VOID, NULL);
+       xlat = xlat_register(NULL, "taint", xlat_func_taint, FR_TYPE_VOID);
        xlat_internal(xlat);
 
        /*
@@ -4198,8 +4197,9 @@ do { \
         */
 #define XLAT_REGISTER_MONO(_xlat, _func, _return_type, _arg) \
 do { \
-       if (!(xlat = xlat_register(NULL, _xlat, _func, _return_type, XLAT_FLAG_PURE))) return -1; \
-       xlat_func_mono(xlat, _arg); \
+       if (!(xlat = xlat_register(NULL, _xlat, _func, _return_type))) return -1; \
+       xlat_func_mono_set(xlat, _arg); \
+       xlat_func_flags_set(xlat, XLAT_FLAG_PURE); \
        xlat_internal(xlat); \
 } while (0)
 
@@ -4212,7 +4212,7 @@ do { \
        XLAT_REGISTER_MONO("md5", xlat_func_md5, FR_TYPE_OCTETS, xlat_func_md5_arg);
        XLAT_REGISTER_MONO("pack", xlat_func_pack, FR_TYPE_OCTETS, xlat_func_pack_arg);
 #if defined(HAVE_REGEX_PCRE) || defined(HAVE_REGEX_PCRE2)
-       xlat = xlat_register(NULL, "regex", xlat_func_regex, FR_TYPE_STRING, NULL);
+       xlat = xlat_register(NULL, "regex", xlat_func_regex, FR_TYPE_STRING);
        xlat_internal(xlat);
 #endif
        XLAT_REGISTER_MONO("sha1", xlat_func_sha1, FR_TYPE_OCTETS, xlat_func_sha_arg);
@@ -4246,15 +4246,15 @@ do { \
 #undef XLAT_REGISTER_MONO
 #define XLAT_REGISTER_MONO(_xlat, _func, _return_type, _arg) \
 do { \
-       if (!(xlat = xlat_register(NULL, _xlat, _func, _return_type, NULL))) return -1; \
-       xlat_func_mono(xlat, _arg); \
+       if (!(xlat = xlat_register(NULL, _xlat, _func, _return_type))) return -1; \
+       xlat_func_mono_set(xlat, _arg); \
        xlat_internal(xlat); \
 } while (0)
 
        XLAT_REGISTER_MONO("rand", xlat_func_rand, FR_TYPE_UINT64, xlat_func_rand_arg);
        XLAT_REGISTER_MONO("randstr", xlat_func_randstr, FR_TYPE_STRING, xlat_func_randstr_arg);
 
-       xlat = xlat_register(NULL, "module", xlat_func_module, FR_TYPE_STRING, NULL);
+       xlat = xlat_register(NULL, "module", xlat_func_module, FR_TYPE_STRING);
        xlat_internal(xlat);
 
        return xlat_register_expressions();

diff --git a/src/lib/unlang/xlat_eval.c b/src/lib/unlang/xlat_eval.c
index 710daed2d0d7fba1becbd4e0ed679d852b6ca557..7ffd3a86ccb0dc7adff7d5cba139f74f4bed216b 100644 (file)
--- a/src/lib/unlang/xlat_eval.c
+++ b/src/lib/unlang/xlat_eval.c
@@ -408,7 +408,7 @@ xlat_action_t xlat_process_args(TALLOC_CTX *ctx, fr_value_box_list_t *list,
                                }
 
                                /*
-                                *      The argument isn't required.  Just omit it.  xlat_func_args() enforces
+                                *      The argument isn't required.  Just omit it.  xlat_func_args_set() enforces
                                 *      that optional arguments are at the end of the argument list.
                                 */
                                return XLAT_ACTION_DONE;

diff --git a/src/lib/unlang/xlat_expr.c b/src/lib/unlang/xlat_expr.c
index 42803cb62093a1990734509666fcc3a8056eaf00..5f68d7d45ee2b6b40c01ff957a69c1411eab3245 100644 (file)
--- a/src/lib/unlang/xlat_expr.c
+++ b/src/lib/unlang/xlat_expr.c
@@ -1626,8 +1626,9 @@ static xlat_action_t xlat_func_exists(TALLOC_CTX *ctx, fr_dcursor_t *out,
 #undef XLAT_REGISTER_BINARY_OP
 #define XLAT_REGISTER_BINARY_OP(_op, _name) \
 do { \
-       if (!(xlat = xlat_register(NULL, "op_" STRINGIFY(_name), xlat_func_op_ ## _name, FR_TYPE_VOID, XLAT_FLAG_PURE))) return -1; \
-       xlat_func_args(xlat, binary_op_xlat_args); \
+       if (!(xlat = xlat_register(NULL, "op_" STRINGIFY(_name), xlat_func_op_ ## _name, FR_TYPE_VOID))) return -1; \
+       xlat_func_args_set(xlat, binary_op_xlat_args); \
+       xlat_func_flags_set(xlat, XLAT_FLAG_PURE); \
        xlat_internal(xlat); \
        xlat_print_set(xlat, xlat_expr_print_binary); \
        xlat_async_instantiate_set(xlat, xlat_function_args_to_tmpl, NULL, NULL, NULL); \
@@ -1637,8 +1638,9 @@ do { \
 #undef XLAT_REGISTER_BINARY_CMP
 #define XLAT_REGISTER_BINARY_CMP(_op, _name) \
 do { \
-       if (!(xlat = xlat_register(NULL, "cmp_" STRINGIFY(_name), xlat_func_cmp_ ## _name, FR_TYPE_VOID, XLAT_FLAG_PURE))) return -1; \
-       xlat_func_args(xlat, binary_op_xlat_args); \
+       if (!(xlat = xlat_register(NULL, "cmp_" STRINGIFY(_name), xlat_func_cmp_ ## _name, FR_TYPE_VOID))) return -1; \
+       xlat_func_args_set(xlat, binary_op_xlat_args); \
+       xlat_func_flags_set(xlat, XLAT_FLAG_PURE); \
        xlat_internal(xlat); \
        xlat_print_set(xlat, xlat_expr_print_binary); \
        xlat_resolve_set(xlat, xlat_expr_resolve_binary); \
@@ -1648,8 +1650,9 @@ do { \
 #undef XLAT_REGISTER_NARY_OP
 #define XLAT_REGISTER_NARY_OP(_op, _name, _func_name) \
 do { \
-       if (!(xlat = xlat_register(NULL, STRINGIFY(_name), xlat_func_ ## _func_name, FR_TYPE_VOID, XLAT_FLAG_PURE))) return -1; \
+       if (!(xlat = xlat_register(NULL, STRINGIFY(_name), xlat_func_ ## _func_name, FR_TYPE_VOID))) return -1; \
        xlat_async_instantiate_set(xlat, xlat_instantiate_ ## _func_name, xlat_ ## _func_name ## _inst_t, NULL, NULL); \
+       xlat_func_flags_set(xlat, XLAT_FLAG_PURE); \
        xlat_internal(xlat); \
        xlat_print_set(xlat, xlat_expr_print_ ## _func_name); \
        xlat_purify_set(xlat, xlat_expr_logical_purify); \
@@ -1659,8 +1662,9 @@ do { \
 #undef XLAT_REGISTER_REGEX_OP
 #define XLAT_REGISTER_REGEX_OP(_op, _name) \
 do { \
-       if (!(xlat = xlat_register(NULL, STRINGIFY(_name), xlat_func_ ## _name, FR_TYPE_VOID, XLAT_FLAG_PURE))) return -1; \
-       xlat_func_args(xlat, regex_op_xlat_args); \
+       if (!(xlat = xlat_register(NULL, STRINGIFY(_name), xlat_func_ ## _name, FR_TYPE_VOID))) return -1; \
+       xlat_func_args_set(xlat, regex_op_xlat_args); \
+       xlat_func_flags_set(xlat, XLAT_FLAG_PURE); \
        xlat_async_instantiate_set(xlat, xlat_instantiate_regex, xlat_regex_inst_t, NULL, NULL); \
        xlat_print_set(xlat, xlat_expr_print_regex); \
        xlat_internal(xlat); \
@@ -1669,15 +1673,16 @@ do { \
 
 #define XLAT_REGISTER_MONO(_xlat, _func, _arg) \
 do { \
-       if (!(xlat = xlat_register(NULL, _xlat, _func, FR_TYPE_VOID, NULL))) return -1; \
-       xlat_func_mono(xlat, _arg); \
+       if (!(xlat = xlat_register(NULL, _xlat, _func, FR_TYPE_VOID))) return -1; \
+       xlat_func_mono_set(xlat, _arg); \
        xlat_internal(xlat); \
 } while (0)
 
 #define XLAT_REGISTER_UNARY(_op, _xlat, _func) \
 do { \
-       if (!(xlat = xlat_register(NULL, _xlat, _func, FR_TYPE_VOID, XLAT_FLAG_PURE))) return -1; \
-       xlat_func_args(xlat, unary_op_xlat_args); \
+       if (!(xlat = xlat_register(NULL, _xlat, _func, FR_TYPE_VOID))) return -1; \
+       xlat_func_args_set(xlat, unary_op_xlat_args); \
+       xlat_func_flags_set(xlat, XLAT_FLAG_PURE); \
        xlat_internal(xlat); \
        xlat_print_set(xlat, xlat_expr_print_unary); \
        xlat->token = _op; \
@@ -1736,8 +1741,8 @@ int xlat_register_expressions(void)
        /*
         *      Callback wrapper around old paircmp() API.
         */
-       if (!(xlat = xlat_register(NULL, "paircmp", xlat_paircmp_func, FR_TYPE_VOID, NULL))) return -1; /* never pure! */
-       xlat_func_args(xlat, xlat_paircmp_xlat_args);
+       if (!(xlat = xlat_register(NULL, "paircmp", xlat_paircmp_func, FR_TYPE_VOID))) return -1; /* never pure! */
+       xlat_func_args_set(xlat, xlat_paircmp_xlat_args);
        xlat_internal(xlat);
 
        return 0;

diff --git a/src/modules/rlm_always/rlm_always.c b/src/modules/rlm_always/rlm_always.c
index 0cc551339ee49d2f1077e7bdf29c986a6f40b98e..7c9d4835e1cc31dfbb2efd1ead639274e6357fd2 100644 (file)
--- a/src/modules/rlm_always/rlm_always.c
+++ b/src/modules/rlm_always/rlm_always.c
@@ -125,8 +125,8 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
                return -1;
        }
 
-       xlat = xlat_register_module(inst, mctx, mctx->inst->name, always_xlat, FR_TYPE_STRING, NULL);
-       xlat_func_args(xlat, always_xlat_args);
+       xlat = xlat_register_module(inst, mctx, mctx->inst->name, always_xlat, FR_TYPE_STRING);
+       xlat_func_args_set(xlat, always_xlat_args);
 
        return 0;
 }

diff --git a/src/modules/rlm_cache/rlm_cache.c b/src/modules/rlm_cache/rlm_cache.c
index 6075eaffab528565cb1b82d4702abf00fee7c460..b854f8ecb28ffc2bf4a965a2365628fffd7d7305 100644 (file)
--- a/src/modules/rlm_cache/rlm_cache.c
+++ b/src/modules/rlm_cache/rlm_cache.c
@@ -971,8 +971,8 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        /*
         *      Register the cache xlat function
         */
-       xlat = xlat_register_module(inst, mctx, mctx->inst->name, cache_xlat, FR_TYPE_VOID, 0);
-       xlat_func_args(xlat, cache_xlat_args);
+       xlat = xlat_register_module(inst, mctx, mctx->inst->name, cache_xlat, FR_TYPE_VOID);
+       xlat_func_args_set(xlat, cache_xlat_args);
 
        return 0;
 }

diff --git a/src/modules/rlm_chap/rlm_chap.c b/src/modules/rlm_chap/rlm_chap.c
index 0de20ca71959a602cfaba12e456e35dbad78e66d..127b928a599d7729e42f0821937f71b8558948bb 100644 (file)
--- a/src/modules/rlm_chap/rlm_chap.c
+++ b/src/modules/rlm_chap/rlm_chap.c
@@ -292,9 +292,9 @@ static int mod_load(void)
 {
        xlat_t  *xlat;
 
-       xlat = xlat_register(NULL, "chap_password", xlat_func_chap_password, FR_TYPE_OCTETS, NULL);
+       xlat = xlat_register(NULL, "chap_password", xlat_func_chap_password, FR_TYPE_OCTETS);
        if (!xlat) return -1;
-       xlat_func_args(xlat, xlat_func_chap_password_args);
+       xlat_func_args_set(xlat, xlat_func_chap_password_args);
 
        return 0;
 }

diff --git a/src/modules/rlm_cipher/rlm_cipher.c b/src/modules/rlm_cipher/rlm_cipher.c
index c8b8674545cc8de5cbfe65a14fd525c8d6d37e2e..8f6bc673266b9a36e32bdf75b0e6d96b0a634473 100644 (file)
--- a/src/modules/rlm_cipher/rlm_cipher.c
+++ b/src/modules/rlm_cipher/rlm_cipher.c
@@ -1299,16 +1299,16 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
                         *      Register decrypt xlat
                         */
                        xlat_name = talloc_asprintf(inst, "%s_decrypt", mctx->inst->name);
-                       xlat = xlat_register_module(inst, mctx, xlat_name, cipher_rsa_decrypt_xlat, FR_TYPE_STRING, NULL);
-                       xlat_func_mono(xlat, cipher_rsa_decrypt_xlat_arg);
+                       xlat = xlat_register_module(inst, mctx, xlat_name, cipher_rsa_decrypt_xlat, FR_TYPE_STRING);
+                       xlat_func_mono_set(xlat, cipher_rsa_decrypt_xlat_arg);
                        talloc_free(xlat_name);
 
                        /*
                         *      Verify sign xlat
                         */
                        xlat_name = talloc_asprintf(inst, "%s_verify", mctx->inst->name);
-                       xlat = xlat_register_module(inst, mctx, xlat_name, cipher_rsa_verify_xlat, FR_TYPE_BOOL, NULL);
-                       xlat_func_args(xlat, cipher_rsa_verify_xlat_arg);
+                       xlat = xlat_register_module(inst, mctx, xlat_name, cipher_rsa_verify_xlat, FR_TYPE_BOOL);
+                       xlat_func_args_set(xlat, cipher_rsa_verify_xlat_arg);
                        talloc_free(xlat_name);
                }
 
@@ -1336,16 +1336,16 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
                         *      Register encrypt xlat
                         */
                        xlat_name = talloc_asprintf(inst, "%s_encrypt", mctx->inst->name);
-                       xlat = xlat_register_module(inst, mctx, xlat_name, cipher_rsa_encrypt_xlat, FR_TYPE_OCTETS, NULL);
-                       xlat_func_mono(xlat, cipher_rsa_encrypt_xlat_arg);
+                       xlat = xlat_register_module(inst, mctx, xlat_name, cipher_rsa_encrypt_xlat, FR_TYPE_OCTETS);
+                       xlat_func_mono_set(xlat, cipher_rsa_encrypt_xlat_arg);
                        talloc_free(xlat_name);
 
                        /*
                         *      Register sign xlat
                         */
                        xlat_name = talloc_asprintf(inst, "%s_sign", mctx->inst->name);
-                       xlat = xlat_register_module(inst, mctx, xlat_name, cipher_rsa_sign_xlat, FR_TYPE_OCTETS, NULL);
-                       xlat_func_mono(xlat, cipher_rsa_sign_xlat_arg);
+                       xlat = xlat_register_module(inst, mctx, xlat_name, cipher_rsa_sign_xlat, FR_TYPE_OCTETS);
+                       xlat_func_mono_set(xlat, cipher_rsa_sign_xlat_arg);
                        talloc_free(xlat_name);
 
                        /*
@@ -1353,8 +1353,8 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
                         *      so we can optimise for return types.
                         */
                        xlat_name = talloc_asprintf(inst, "%s_certificate", mctx->inst->name);
-                       xlat = xlat_register_module(inst, mctx, xlat_name, cipher_certificate_xlat, FR_TYPE_VOID, NULL);
-                       xlat_func_args(xlat, cipher_certificate_xlat_args);
+                       xlat = xlat_register_module(inst, mctx, xlat_name, cipher_certificate_xlat, FR_TYPE_VOID);
+                       xlat_func_args_set(xlat, cipher_certificate_xlat_args);
 
                        talloc_free(xlat_name);
                }

diff --git a/src/modules/rlm_client/rlm_client.c b/src/modules/rlm_client/rlm_client.c
index b99b6b5bbc58c78f858083118313c9af31c712f7..ed62e5145d05403cfadcc4f64fe8ec1372c523c2 100644 (file)
--- a/src/modules/rlm_client/rlm_client.c
+++ b/src/modules/rlm_client/rlm_client.c
@@ -352,9 +352,9 @@ static int mod_load(void)
 {
        xlat_t  *xlat;
 
-       xlat = xlat_register(NULL, "client", xlat_client, FR_TYPE_STRING, NULL);
+       xlat = xlat_register(NULL, "client", xlat_client, FR_TYPE_STRING);
        if (!xlat) return -1;
-       xlat_func_args(xlat, xlat_client_args);
+       xlat_func_args_set(xlat, xlat_client_args);
 
        map_proc_register(NULL, "client", map_proc_client, NULL, 0);
 

diff --git a/src/modules/rlm_date/rlm_date.c b/src/modules/rlm_date/rlm_date.c
index 77cda9bbeb2a32a06fa584f792ab4442d491da49..65007aed4aa3477b8000f8a173e75719d7787a0a 100644 (file)
--- a/src/modules/rlm_date/rlm_date.c
+++ b/src/modules/rlm_date/rlm_date.c
@@ -234,8 +234,8 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        rlm_date_t      *inst = talloc_get_type_abort(mctx->inst->data, rlm_date_t );
        xlat_t          *xlat;
 
-       xlat = xlat_register_module(inst, mctx, mctx->inst->name, xlat_date_convert, FR_TYPE_VOID, NULL);
-       xlat_func_args(xlat, xlat_date_convert_args);
+       xlat = xlat_register_module(inst, mctx, mctx->inst->name, xlat_date_convert, FR_TYPE_VOID);
+       xlat_func_args_set(xlat, xlat_date_convert_args);
 
        return 0;
 }

diff --git a/src/modules/rlm_delay/rlm_delay.c b/src/modules/rlm_delay/rlm_delay.c
index 286c9898c62b12eb25c8705ad882c7d7e9bb0258..d12254f5fd5da5d990711ccd3cf8cd27420c2aa3 100644 (file)
--- a/src/modules/rlm_delay/rlm_delay.c
+++ b/src/modules/rlm_delay/rlm_delay.c
@@ -268,8 +268,8 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        rlm_delay_t     *inst = talloc_get_type_abort(mctx->inst->data, rlm_delay_t);
        xlat_t          *xlat;
 
-       xlat = xlat_register_module(inst, mctx, mctx->inst->name, xlat_delay, FR_TYPE_TIME_DELTA, 0);
-       xlat_func_args(xlat, xlat_delay_args);
+       xlat = xlat_register_module(inst, mctx, mctx->inst->name, xlat_delay, FR_TYPE_TIME_DELTA);
+       xlat_func_args_set(xlat, xlat_delay_args);
        return 0;
 }
 

diff --git a/src/modules/rlm_dict/rlm_dict.c b/src/modules/rlm_dict/rlm_dict.c
index 561915734b6f33747696b35f07dfa527937ede12..7df7a36b2f75bd75cec46c5481910f0c95f04680 100644 (file)
--- a/src/modules/rlm_dict/rlm_dict.c
+++ b/src/modules/rlm_dict/rlm_dict.c
@@ -236,18 +236,18 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
         */
        if (cf_section_name2(mctx->inst->conf) != NULL) return 0;
 
-       xlat = xlat_register_module(inst, mctx, "attr_by_num", xlat_dict_attr_by_num, FR_TYPE_STRING, NULL);
-       xlat_func_args(xlat, xlat_dict_attr_by_num_args);
-       xlat = xlat_register_module(inst, mctx, "attr_by_oid", xlat_dict_attr_by_oid, FR_TYPE_STRING, NULL);
-       xlat_func_args(xlat, xlat_dict_attr_by_oid_args);
-       xlat = xlat_register_module(inst, mctx, "vendor", xlat_vendor, FR_TYPE_STRING, NULL);
-       xlat_func_args(xlat, xlat_vendor_args);
-       xlat = xlat_register_module(inst, mctx, "vendor_num", xlat_vendor_num, FR_TYPE_UINT32, NULL);
-       xlat_func_args(xlat, xlat_vendor_num_args);
-       xlat = xlat_register_module(inst, mctx, "attr", xlat_attr, FR_TYPE_STRING, NULL);
-       xlat_func_args(xlat, xlat_attr_args);
-       xlat = xlat_register_module(inst, mctx, "attr_num", xlat_attr_num, FR_TYPE_UINT32, NULL);
-       xlat_func_args(xlat, xlat_attr_num_args);
+       xlat = xlat_register_module(inst, mctx, "attr_by_num", xlat_dict_attr_by_num, FR_TYPE_STRING);
+       xlat_func_args_set(xlat, xlat_dict_attr_by_num_args);
+       xlat = xlat_register_module(inst, mctx, "attr_by_oid", xlat_dict_attr_by_oid, FR_TYPE_STRING);
+       xlat_func_args_set(xlat, xlat_dict_attr_by_oid_args);
+       xlat = xlat_register_module(inst, mctx, "vendor", xlat_vendor, FR_TYPE_STRING);
+       xlat_func_args_set(xlat, xlat_vendor_args);
+       xlat = xlat_register_module(inst, mctx, "vendor_num", xlat_vendor_num, FR_TYPE_UINT32);
+       xlat_func_args_set(xlat, xlat_vendor_num_args);
+       xlat = xlat_register_module(inst, mctx, "attr", xlat_attr, FR_TYPE_STRING);
+       xlat_func_args_set(xlat, xlat_attr_args);
+       xlat = xlat_register_module(inst, mctx, "attr_num", xlat_attr_num, FR_TYPE_UINT32);
+       xlat_func_args_set(xlat, xlat_attr_num_args);
 
        return 0;
 }

diff --git a/src/modules/rlm_escape/rlm_escape.c b/src/modules/rlm_escape/rlm_escape.c
index 1fcee457018142e5190286214f1f089e47c582aa..eb103a6067dbde7346f5b0512e2a75f68b9b31bb 100644 (file)
--- a/src/modules/rlm_escape/rlm_escape.c
+++ b/src/modules/rlm_escape/rlm_escape.c
@@ -196,11 +196,13 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        xlat_t          *xlat;
 
        MEM(unescape = talloc_asprintf(NULL, "un%s", mctx->inst->name));
-       xlat = xlat_register_module(NULL, mctx, mctx->inst->name, escape_xlat, FR_TYPE_STRING, XLAT_FLAG_PURE);
-       xlat_func_mono(xlat, escape_xlat_arg);
+       xlat = xlat_register_module(NULL, mctx, mctx->inst->name, escape_xlat, FR_TYPE_STRING);
+       xlat_func_mono_set(xlat, escape_xlat_arg);
+       xlat_func_flags_set(xlat, XLAT_FLAG_PURE);
 
-       xlat = xlat_register_module(NULL, mctx, unescape, unescape_xlat, FR_TYPE_STRING, XLAT_FLAG_PURE);
-       xlat_func_mono(xlat, unescape_xlat_arg);
+       xlat = xlat_register_module(NULL, mctx, unescape, unescape_xlat, FR_TYPE_STRING);
+       xlat_func_mono_set(xlat, unescape_xlat_arg);
+       xlat_func_flags_set(xlat, XLAT_FLAG_PURE);
        talloc_free(unescape);
 
        return 0;

diff --git a/src/modules/rlm_exec/rlm_exec.c b/src/modules/rlm_exec/rlm_exec.c
index 6284b769402562c653e0c6076f457713d7c61877..7d5671a2423fb86be3b1c32cc3ad0cfc4432f931 100644 (file)
--- a/src/modules/rlm_exec/rlm_exec.c
+++ b/src/modules/rlm_exec/rlm_exec.c
@@ -172,8 +172,8 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
                }
        };
 
-       xlat = xlat_register_module(NULL, mctx, mctx->inst->name, exec_xlat, FR_TYPE_STRING, 0);
-       xlat_func_args(xlat, exec_xlat_args);
+       xlat = xlat_register_module(NULL, mctx, mctx->inst->name, exec_xlat, FR_TYPE_STRING);
+       xlat_func_args_set(xlat, exec_xlat_args);
 
        if (inst->input) {
                if ((tmpl_afrom_attr_substr(inst, NULL, &inst->input_list,

diff --git a/src/modules/rlm_icmp/rlm_icmp.c b/src/modules/rlm_icmp/rlm_icmp.c
index 87fd3cb36b32b23c4dd83304cc31f89cff16b252..8eac48013fd9d34c78161c15ddfde684cfce0d56 100644 (file)
--- a/src/modules/rlm_icmp/rlm_icmp.c
+++ b/src/modules/rlm_icmp/rlm_icmp.c
@@ -497,8 +497,8 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        rlm_icmp_t      *inst = talloc_get_type_abort(mctx->inst->data, rlm_icmp_t);
        xlat_t          *xlat;
 
-       xlat = xlat_register_module(inst, mctx, mctx->inst->name, xlat_icmp, FR_TYPE_BOOL, 0);
-       xlat_func_args(xlat, xlat_icmp_args);
+       xlat = xlat_register_module(inst, mctx, mctx->inst->name, xlat_icmp, FR_TYPE_BOOL);
+       xlat_func_args_set(xlat, xlat_icmp_args);
 
        FR_TIME_DELTA_BOUND_CHECK("timeout", inst->timeout, >=, fr_time_delta_from_msec(100)); /* 1/10s minimum timeout */
        FR_TIME_DELTA_BOUND_CHECK("timeout", inst->timeout, <=, fr_time_delta_from_sec(10));

diff --git a/src/modules/rlm_idn/rlm_idn.c b/src/modules/rlm_idn/rlm_idn.c
index 7caff0b7486bce876f20ae6e0310475c565743f9..256d9831d4af425f38b4e1d3bdb74e21deaa9082 100644 (file)
--- a/src/modules/rlm_idn/rlm_idn.c
+++ b/src/modules/rlm_idn/rlm_idn.c
@@ -152,8 +152,9 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        rlm_idn_t       *inst = talloc_get_type_abort(mctx->inst->data, rlm_idn_t);
        xlat_t          *xlat;
 
-       xlat = xlat_register_module(inst, mctx, mctx->inst->name, xlat_idna, FR_TYPE_STRING, XLAT_FLAG_PURE);
-       xlat_func_mono(xlat, xlat_idna_arg);
+       xlat = xlat_register_module(inst, mctx, mctx->inst->name, xlat_idna, FR_TYPE_STRING);
+       xlat_func_mono_set(xlat, xlat_idna_arg);
+       xlat_func_flags_set(xlat, XLAT_FLAG_PURE);
 
        return 0;
 }

diff --git a/src/modules/rlm_json/rlm_json.c b/src/modules/rlm_json/rlm_json.c
index ec392a2dd7a5e91a267960dfaa41e77286257d5f..e4755a3e857e7afcd50e6632233527909a18a0e1 100644 (file)
--- a/src/modules/rlm_json/rlm_json.c
+++ b/src/modules/rlm_json/rlm_json.c
@@ -529,14 +529,14 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        char                    *name;
        fr_json_format_t        *format = inst->format;
 
-       xlat = xlat_register_module(inst, mctx, "jsonquote", json_quote_xlat, FR_TYPE_STRING, NULL);
-       if (xlat) xlat_func_mono(xlat, json_quote_xlat_arg);
-       xlat = xlat_register_module(inst, mctx, "jpathvalidate", jpath_validate_xlat, FR_TYPE_STRING, NULL);
-       if (xlat) xlat_func_mono(xlat, jpath_validate_xlat_arg);
+       xlat = xlat_register_module(inst, mctx, "jsonquote", json_quote_xlat, FR_TYPE_STRING);
+       if (xlat) xlat_func_mono_set(xlat, json_quote_xlat_arg);
+       xlat = xlat_register_module(inst, mctx, "jpathvalidate", jpath_validate_xlat, FR_TYPE_STRING);
+       if (xlat) xlat_func_mono_set(xlat, jpath_validate_xlat_arg);
 
        name = talloc_asprintf(inst, "%s_encode", mctx->inst->name);
-       xlat = xlat_register_module(inst, mctx, name, json_encode_xlat, FR_TYPE_STRING, NULL);
-       xlat_func_mono(xlat, json_encode_xlat_arg);
+       xlat = xlat_register_module(inst, mctx, name, json_encode_xlat, FR_TYPE_STRING);
+       xlat_func_mono_set(xlat, json_encode_xlat_arg);
        talloc_free(name);
 
        /*

diff --git a/src/modules/rlm_ldap/rlm_ldap.c b/src/modules/rlm_ldap/rlm_ldap.c
index 23249cb48a549968882ac80546be5f1c86f9da4b..75c91c5d6774f580dc4c04b4fa7244614d0afb73 100644 (file)
--- a/src/modules/rlm_ldap/rlm_ldap.c
+++ b/src/modules/rlm_ldap/rlm_ldap.c
@@ -1770,13 +1770,19 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
                inst->cache_da = inst->group_da;        /* Default to the group_da */
        }
 
-       xlat = xlat_register_module(NULL, mctx, mctx->inst->name, ldap_xlat, FR_TYPE_STRING, NULL);
-       xlat_func_mono(xlat, ldap_xlat_arg);
+       xlat = xlat_register_module(NULL, mctx, mctx->inst->name, ldap_xlat, FR_TYPE_STRING);
+       xlat_func_mono_set(xlat, ldap_xlat_arg);
 
-       xlat = xlat_register_module(NULL, mctx, "ldap_escape", ldap_escape_xlat, FR_TYPE_STRING, XLAT_FLAG_PURE);
-       if (xlat) xlat_func_mono(xlat, ldap_escape_xlat_arg);
-       xlat = xlat_register_module(NULL, mctx, "ldap_unescape", ldap_unescape_xlat, FR_TYPE_STRING, XLAT_FLAG_PURE);
-       if (xlat) xlat_func_mono(xlat, ldap_escape_xlat_arg);
+       xlat = xlat_register_module(NULL, mctx, "ldap_escape", ldap_escape_xlat, FR_TYPE_STRING);
+       if (xlat) {
+               xlat_func_mono_set(xlat, ldap_escape_xlat_arg);
+               xlat_func_flags_set(xlat, XLAT_FLAG_PURE);
+       }
+       xlat = xlat_register_module(NULL, mctx, "ldap_unescape", ldap_unescape_xlat, FR_TYPE_STRING);
+       if (xlat) {
+               xlat_func_mono_set(xlat, ldap_escape_xlat_arg);
+               xlat_func_flags_set(xlat, XLAT_FLAG_PURE);
+       }
 
        map_proc_register(inst, mctx->inst->name, mod_map_proc, ldap_map_verify, 0);
 

diff --git a/src/modules/rlm_linelog/rlm_linelog.c b/src/modules/rlm_linelog/rlm_linelog.c
index da5b80747bd65d2882f36619aebbac0774e85dbd..a6ec31073fe087373c026884ca1745edcc7d3e72 100644 (file)
--- a/src/modules/rlm_linelog/rlm_linelog.c
+++ b/src/modules/rlm_linelog/rlm_linelog.c
@@ -905,8 +905,8 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
                XLAT_ARG_PARSER_TERMINATOR
        };
 
-       xlat = xlat_register_module(inst, mctx, mctx->inst->name, linelog_xlat, FR_TYPE_SIZE, 0);
-       xlat_func_mono(xlat, linelog_xlat_args);
+       xlat = xlat_register_module(inst, mctx, mctx->inst->name, linelog_xlat, FR_TYPE_SIZE);
+       xlat_func_mono_set(xlat, linelog_xlat_args);
 
        return 0;
 }

diff --git a/src/modules/rlm_mschap/rlm_mschap.c b/src/modules/rlm_mschap/rlm_mschap.c
index 60d29507f3140018626851bd0031e841f379d5e7..d423fbc0c49704db44bf125ba2d2c59fe18bd2cd 100644 (file)
--- a/src/modules/rlm_mschap/rlm_mschap.c
+++ b/src/modules/rlm_mschap/rlm_mschap.c
@@ -2277,8 +2277,8 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        rlm_mschap_t            *inst = talloc_get_type_abort(mctx->inst->data, rlm_mschap_t);
        xlat_t                  *xlat;
 
-       xlat = xlat_register_module(inst, mctx, mctx->inst->name, mschap_xlat, FR_TYPE_VOID, NULL);
-       xlat_func_args(xlat, mschap_xlat_args);
+       xlat = xlat_register_module(inst, mctx, mctx->inst->name, mschap_xlat, FR_TYPE_VOID);
+       xlat_func_args_set(xlat, mschap_xlat_args);
 
        return 0;
 }

diff --git a/src/modules/rlm_perl/rlm_perl.c b/src/modules/rlm_perl/rlm_perl.c
index 63c7a8dd3cabdd0e23ef958a92225e192ca3220f..3199aaf02c1be9c71a42b81b7bff49a60a559c8e 100644 (file)
--- a/src/modules/rlm_perl/rlm_perl.c
+++ b/src/modules/rlm_perl/rlm_perl.c
@@ -580,8 +580,8 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
 {
        xlat_t          *xlat;
 
-       xlat = xlat_register_module(NULL, mctx, mctx->inst->name, perl_xlat, FR_TYPE_VOID, NULL);
-       xlat_func_args(xlat, perl_xlat_args);
+       xlat = xlat_register_module(NULL, mctx, mctx->inst->name, perl_xlat, FR_TYPE_VOID);
+       xlat_func_args_set(xlat, perl_xlat_args);
 
        return 0;
 }

diff --git a/src/modules/rlm_redis/rlm_redis.c b/src/modules/rlm_redis/rlm_redis.c
index 6c5c786fbe8379e31de3e9335a46df1f9987edef..a596b6d78fe43f3db26970dfdd59557714455d90 100644 (file)
--- a/src/modules/rlm_redis/rlm_redis.c
+++ b/src/modules/rlm_redis/rlm_redis.c
@@ -452,20 +452,20 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        char            *name;
        xlat_t          *xlat;
 
-       xlat = xlat_register_module(inst, mctx, mctx->inst->name, redis_xlat, FR_TYPE_VOID, NULL);
-       xlat_func_args(xlat, redis_args);
+       xlat = xlat_register_module(inst, mctx, mctx->inst->name, redis_xlat, FR_TYPE_VOID);
+       xlat_func_args_set(xlat, redis_args);
 
        /*
         *      %(redis_node:<key>[ idx])
         */
        name = talloc_asprintf(NULL, "%s_node", mctx->inst->name);
-       xlat = xlat_register_module(inst, mctx, name, redis_node_xlat, FR_TYPE_STRING, NULL);
-       xlat_func_args(xlat, redis_node_xlat_args);
+       xlat = xlat_register_module(inst, mctx, name, redis_node_xlat, FR_TYPE_STRING);
+       xlat_func_args_set(xlat, redis_node_xlat_args);
        talloc_free(name);
 
        name = talloc_asprintf(NULL, "%s_remap", mctx->inst->name);
-       xlat = xlat_register_module(inst, mctx, name, redis_remap_xlat, FR_TYPE_STRING, NULL);
-       xlat_func_args(xlat, redis_remap_xlat_args);
+       xlat = xlat_register_module(inst, mctx, name, redis_remap_xlat, FR_TYPE_STRING);
+       xlat_func_args_set(xlat, redis_remap_xlat_args);
        talloc_free(name);
 
        return 0;

diff --git a/src/modules/rlm_rest/rlm_rest.c b/src/modules/rlm_rest/rlm_rest.c
index c0ad3cf5b4a4049428f98801f69e4a2013b52404..07a64501c1c5376d2dec18d4027f9ee857f8289a 100644 (file)
--- a/src/modules/rlm_rest/rlm_rest.c
+++ b/src/modules/rlm_rest/rlm_rest.c
@@ -1244,8 +1244,8 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        rlm_rest_t      *inst = talloc_get_type_abort(mctx->inst->data, rlm_rest_t);
        xlat_t          *xlat;
 
-       xlat = xlat_register_module(inst, mctx, mctx->inst->name, rest_xlat, FR_TYPE_STRING, 0);
-       xlat_func_args(xlat, rest_xlat_args);
+       xlat = xlat_register_module(inst, mctx, mctx->inst->name, rest_xlat, FR_TYPE_STRING);
+       xlat_func_args_set(xlat, rest_xlat_args);
 
        return 0;
 }

diff --git a/src/modules/rlm_soh/rlm_soh.c b/src/modules/rlm_soh/rlm_soh.c
index 52ea25d15fed96a0cfde747b431226b0f58a80ed..fac9349083e9f83c2c2209a7975fde3796a1b41a 100644 (file)
--- a/src/modules/rlm_soh/rlm_soh.c
+++ b/src/modules/rlm_soh/rlm_soh.c
@@ -273,8 +273,8 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        rlm_soh_t       *inst = talloc_get_type_abort(mctx->inst->data, rlm_soh_t);
        xlat_t          *xlat;
 
-       xlat = xlat_register_module(inst, mctx, mctx->inst->name, soh_xlat, FR_TYPE_STRING, NULL);
-       xlat_func_args(xlat, soh_xlat_args);
+       xlat = xlat_register_module(inst, mctx, mctx->inst->name, soh_xlat, FR_TYPE_STRING);
+       xlat_func_args_set(xlat, soh_xlat_args);
 
        return 0;
 }

diff --git a/src/modules/rlm_sql/rlm_sql.c b/src/modules/rlm_sql/rlm_sql.c
index 33cfa4ea4f2033f065e9bc669fd31ef682891413..c98ddcd61c679ae4b3a5bc8cfd30aa54672846d0 100644 (file)
--- a/src/modules/rlm_sql/rlm_sql.c
+++ b/src/modules/rlm_sql/rlm_sql.c
@@ -1058,7 +1058,7 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        /*
         *      Register the SQL xlat function
         */
-       xlat = xlat_register_module(inst, mctx, mctx->inst->name, sql_xlat, FR_TYPE_VOID, NULL);        /* Returns an integer sometimes */
+       xlat = xlat_register_module(inst, mctx, mctx->inst->name, sql_xlat, FR_TYPE_VOID);      /* Returns an integer sometimes */
 
        /*
         *      The xlat escape function needs access to inst - so
@@ -1072,7 +1072,7 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        sql_xlat_arg[0].uctx = inst;
        sql_xlat_arg[1] = (xlat_arg_parser_t)XLAT_ARG_PARSER_TERMINATOR;
 
-       xlat_func_mono(xlat, sql_xlat_arg);
+       xlat_func_mono_set(xlat, sql_xlat_arg);
 
        /*
         *      Register the SQL map processor function

diff --git a/src/modules/rlm_test/rlm_test.c b/src/modules/rlm_test/rlm_test.c
index 274ad5ae8139fe50c34acf2cc62cc146b44d856c..c84667e8bf9380ddd4abe9198fbd5a1b0cf44906 100644 (file)
--- a/src/modules/rlm_test/rlm_test.c
+++ b/src/modules/rlm_test/rlm_test.c
@@ -483,15 +483,15 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        }
 
        if (!cf_section_name2(mctx->inst->conf)) {
-               if (!(xlat = xlat_register_module(inst, mctx, "test_trigger", trigger_test_xlat, FR_TYPE_BOOL, NULL))) return -1;
-               xlat_func_args(xlat, trigger_test_xlat_args);
+               if (!(xlat = xlat_register_module(inst, mctx, "test_trigger", trigger_test_xlat, FR_TYPE_BOOL))) return -1;
+               xlat_func_args_set(xlat, trigger_test_xlat_args);
 
-               if (!(xlat = xlat_register_module(inst, mctx, "test", test_xlat, FR_TYPE_STRING, NULL))) return -1;
-               xlat_func_args(xlat, test_xlat_args);
+               if (!(xlat = xlat_register_module(inst, mctx, "test", test_xlat, FR_TYPE_STRING))) return -1;
+               xlat_func_args_set(xlat, test_xlat_args);
 
        } else {
-               if (!(xlat = xlat_register_module(inst, mctx, mctx->inst->name, test_xlat, FR_TYPE_VOID, NULL))) return -1;
-               xlat_func_args(xlat, test_xlat_args);
+               if (!(xlat = xlat_register_module(inst, mctx, mctx->inst->name, test_xlat, FR_TYPE_VOID))) return -1;
+               xlat_func_args_set(xlat, test_xlat_args);
        }
 
        return 0;

diff --git a/src/modules/rlm_unbound/rlm_unbound.c b/src/modules/rlm_unbound/rlm_unbound.c
index ee006a3393c115604baaf9b2883287008b2a792d..4a93d3d58d91c62558e117ba16a0fbe35669ccdf 100644 (file)
--- a/src/modules/rlm_unbound/rlm_unbound.c
+++ b/src/modules/rlm_unbound/rlm_unbound.c
@@ -490,8 +490,8 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
                return -1;
        }
 
-       if(!(xlat = xlat_register_module(NULL, mctx, mctx->inst->name, xlat_unbound, FR_TYPE_VOID, 0))) return -1;
-       xlat_func_args(xlat, xlat_unbound_args);
+       if(!(xlat = xlat_register_module(NULL, mctx, mctx->inst->name, xlat_unbound, FR_TYPE_VOID))) return -1;
+       xlat_func_args_set(xlat, xlat_unbound_args);
 
        return 0;
 }

diff --git a/src/modules/rlm_unpack/rlm_unpack.c b/src/modules/rlm_unpack/rlm_unpack.c
index 0c0148af2797c819c1dd6293afdb9bee6cca85c7..34164038dbfc6acb93e9cc9efda983fd46e54237 100644 (file)
--- a/src/modules/rlm_unpack/rlm_unpack.c
+++ b/src/modules/rlm_unpack/rlm_unpack.c
@@ -134,8 +134,11 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
 {
        xlat_t  *xlat;
 
-       xlat = xlat_register_module(NULL, mctx, "unpack", unpack_xlat, FR_TYPE_VOID, XLAT_FLAG_PURE);
-       if (xlat) xlat_func_args(xlat, unpack_xlat_args);
+       xlat = xlat_register_module(NULL, mctx, "unpack", unpack_xlat, FR_TYPE_VOID);
+       if (xlat) {
+               xlat_func_args_set(xlat, unpack_xlat_args);
+               xlat_func_flags_set(xlat, XLAT_FLAG_PURE);
+       }
 
        return 0;
 }

diff --git a/src/modules/rlm_yubikey/rlm_yubikey.c b/src/modules/rlm_yubikey/rlm_yubikey.c
index 51a5e184d38ff72cd8448d71b52664cd70ef0a9e..ccb82b546b2afd556a43f3d8cf56a474e9f7c419 100644 (file)
--- a/src/modules/rlm_yubikey/rlm_yubikey.c
+++ b/src/modules/rlm_yubikey/rlm_yubikey.c
@@ -196,9 +196,11 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        }
 #endif
 
-       xlat = xlat_register_module(inst, mctx, "modhextohex", modhex_to_hex_xlat, FR_TYPE_STRING, XLAT_FLAG_PURE);
-       if (xlat) xlat_func_mono(xlat, modhex_to_hex_xlat_arg);
-
+       xlat = xlat_register_module(inst, mctx, "modhextohex", modhex_to_hex_xlat, FR_TYPE_STRING);
+       if (xlat) {
+               xlat_func_mono_set(xlat, modhex_to_hex_xlat_arg);
+               xlat_func_flags_set(xlat, XLAT_FLAG_PURE);
+       }
        return 0;
 }