From: Arran Cudbard-Bell Date: Tue, 28 Mar 2023 23:58:36 +0000 (-0600) Subject: xlat: Set func flags using a separate function as the majority of registrations don... X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=34144ea47b3585c8280aa72909d9594492c5608e;p=thirdparty%2Ffreeradius-server.git xlat: Set func flags using a separate function as the majority of registrations don't have flags set --- diff --git a/src/bin/unit_test_attribute.c b/src/bin/unit_test_attribute.c index 1f5dbc86581..2e18b63ee5c 100644 --- 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 c3d55f3097d..6714130cc33 100644 --- 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 537b8e14a98..d13057bf744 100644 --- 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 @@ -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 8eaddbbc584..37ea16d3ddd 100644 --- 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 22bb514cd4a..06e69c5b9a4 100644 --- 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 b44c0aa80ef..1fca1b13eb6 100644 --- 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 a0c936c1e7e..9359831aab3 100644 --- a/src/lib/unlang/xlat_builtin.c +++ b/src/lib/unlang/xlat_builtin.c @@ -33,6 +33,7 @@ RCSID("$Id$") #include #include #include +#include #include @@ -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, "")); 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 710daed2d0d..7ffd3a86ccb 100644 --- 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 42803cb6209..5f68d7d45ee 100644 --- 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 0cc551339ee..7c9d4835e1c 100644 --- 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 6075eaffab5..b854f8ecb28 100644 --- 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 0de20ca7195..127b928a599 100644 --- 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 c8b8674545c..8f6bc673266 100644 --- 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 b99b6b5bbc5..ed62e5145d0 100644 --- 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 77cda9bbeb2..65007aed4aa 100644 --- 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 286c9898c62..d12254f5fd5 100644 --- 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 561915734b6..7df7a36b2f7 100644 --- 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 1fcee457018..eb103a6067d 100644 --- 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 6284b769402..7d5671a2423 100644 --- 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 87fd3cb36b3..8eac48013fd 100644 --- 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 7caff0b7486..256d9831d4a 100644 --- 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 ec392a2dd7a..e4755a3e857 100644 --- 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 23249cb48a5..75c91c5d677 100644 --- 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 da5b80747bd..a6ec31073fe 100644 --- 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 60d29507f31..d423fbc0c49 100644 --- 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 63c7a8dd3ca..3199aaf02c1 100644 --- 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 6c5c786fbe8..a596b6d78fe 100644 --- 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:[ 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 c0ad3cf5b4a..07a64501c1c 100644 --- 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 52ea25d15fe..fac9349083e 100644 --- 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 33cfa4ea4f2..c98ddcd61c6 100644 --- 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 274ad5ae813..c84667e8bf9 100644 --- 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 ee006a3393c..4a93d3d58d9 100644 --- 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 0c0148af279..34164038dbf 100644 --- 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 51a5e184d38..ccb82b546b2 100644 --- 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; }