xlat: Rename xlat_register to xlat_func and give all functions a common prefix

diff --git a/src/bin/unit_test_attribute.c b/src/bin/unit_test_attribute.c
index e85b7a73040cd7c1ff14730db6385261cdc4eca3..22ffc410da30c1f743a77acfa3fa82fbc81b9492 100644 (file)
--- a/src/bin/unit_test_attribute.c
+++ b/src/bin/unit_test_attribute.c
@@ -42,7 +42,7 @@ typedef struct request_s request_t;
 #endif
 #include <freeradius-devel/unlang/base.h>
 #include <freeradius-devel/unlang/xlat.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 #include <freeradius-devel/util/atexit.h>
 #include <freeradius-devel/util/base64.h>
 #include <freeradius-devel/util/calc.h>
@@ -3851,7 +3851,7 @@ int main(int argc, char *argv[])
 
        unlang_thread_instantiate(thread_ctx);
 
-       if (!xlat_register(NULL, "test", xlat_test, FR_TYPE_NULL)) {
+       if (!xlat_func_register(NULL, "test", xlat_test, FR_TYPE_NULL)) {
                ERROR("Failed registering xlat");
                EXIT_WITH_FAILURE;
        }

diff --git a/src/lib/eap_aka_sim/base.h b/src/lib/eap_aka_sim/base.h
index b8295be7f079c04682edf030080217c08036a36f..8818175d650786ec551965fd5a089b793c266b4b 100644 (file)
--- a/src/lib/eap_aka_sim/base.h
+++ b/src/lib/eap_aka_sim/base.h
@@ -346,5 +346,5 @@ void                fr_aka_sim_fips186_2prf(uint8_t out[static 160], uint8_t mk[static 20]);
 /*
  *     xlat.c
  */
-void           fr_aka_sim_xlat_register(void);
-void           fr_aka_sim_xlat_unregister(void);
+void           fr_aka_sim_xlat_func_register(void);
+void           fr_aka_sim_xlat_func_unregister(void);

diff --git a/src/lib/eap_aka_sim/xlat.c b/src/lib/eap_aka_sim/xlat.c
index 9597a1a510ff0d4bb6d69ffbb0aea34bca9bb134..30ecdf2da71269ea5b43d2ee6ef0dd6b086ce6dd 100644 (file)
--- a/src/lib/eap_aka_sim/xlat.c
+++ b/src/lib/eap_aka_sim/xlat.c
@@ -25,7 +25,7 @@
  */
 
 #include <freeradius-devel/server/base.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 #include "base.h"
 #include "attrs.h"
@@ -496,7 +496,7 @@ static xlat_action_t aka_sim_3gpp_temporary_id_encrypt_xlat(TALLOC_CTX *ctx, fr_
        return XLAT_ACTION_DONE;
 }
 
-void fr_aka_sim_xlat_register(void)
+void fr_aka_sim_xlat_func_register(void)
 {
        xlat_t  *xlat;
 
@@ -505,30 +505,30 @@ 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);
+       xlat = xlat_func_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 = xlat_func_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 = xlat_func_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 = xlat_func_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 = xlat_func_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;
 }
 
-void fr_aka_sim_xlat_unregister(void)
+void fr_aka_sim_xlat_func_unregister(void)
 {
        if (aka_sim_xlat_refs > 1) {
                aka_sim_xlat_refs--;
                return;
        }
 
-       xlat_unregister("aka_sim_id_method");
-       xlat_unregister("aka_sim_id_type");
-       xlat_unregister("3gpp_pseudonym_key_index");
-       xlat_unregister("3gpp_pseudonym_decrypt");
-       xlat_unregister("3gpp_pseudonym_encrypt");
+       xlat_func_unregister("aka_sim_id_method");
+       xlat_func_unregister("aka_sim_id_type");
+       xlat_func_unregister("3gpp_pseudonym_key_index");
+       xlat_func_unregister("3gpp_pseudonym_decrypt");
+       xlat_func_unregister("3gpp_pseudonym_encrypt");
        aka_sim_xlat_refs = 0;
 }

diff --git a/src/lib/server/main_config.c b/src/lib/server/main_config.c
index 8ce5d90f3a5eefd0a809919e9ab3db92f62ad70d..bd08a747f755782154657680dfaaa8bdadbaa938 100644 (file)
--- a/src/lib/server/main_config.c
+++ b/src/lib/server/main_config.c
@@ -45,7 +45,7 @@ RCSID("$Id$")
 #include <freeradius-devel/util/perm.h>
 #include <freeradius-devel/util/sem.h>
 
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 #include <sys/stat.h>
 #include <pwd.h>
@@ -1020,9 +1020,10 @@ int main_config_init(main_config_t *config)
        xlat_t          *xlat;
 
        /*
-        *      Initialize the xlats before we load the configuration files, so that we can later call xlat_register().
+        *      Initialize the xlats before we load the configuration files,
+        *      so that we can later call xlat_func_register().
         */
-       xlat_register_init();
+       xlat_func_init();
 
        if (stat(config->raddb_dir, &statbuf) < 0) {
                ERROR("Error checking raddb_dir \"%s\": %s", config->raddb_dir, fr_syserror(errno));
@@ -1367,9 +1368,9 @@ do {\
        /*
         *      Register the %(config:section.subsection) xlat function.
         */
-       xlat = xlat_register(NULL, "config", xlat_config, FR_TYPE_STRING);
+       xlat = xlat_func_register(NULL, "config", xlat_config, FR_TYPE_STRING);
        xlat_func_args_set(xlat, xlat_config_args);
-       xlat_func_flags_set(xlat, XLAT_FLAG_PURE);
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE);
 
        /*
         *      Ensure cwd is inside the chroot.

diff --git a/src/lib/server/module.c b/src/lib/server/module.c
index 4551f646f6d6fc50fcceba70283ac5e8f40e2291..ccf95e710681196d53067e64c89002c8c75c57d1 100644 (file)
--- a/src/lib/server/module.c
+++ b/src/lib/server/module.c
@@ -35,7 +35,7 @@ RCSID("$Id$")
 #include <freeradius-devel/server/module_rlm.h>
 #include <freeradius-devel/server/radmin.h>
 #include <freeradius-devel/server/request_data.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 /** Heap of all lists/modules used to get a common index with module_thread_inst_list
  *
@@ -886,12 +886,12 @@ static int _module_instance_free(module_instance_t *mi)
         *      Remove all xlat's registered to module instance.
         */
        if (mi->dl_inst && mi->dl_inst->data) {
-               xlat_unregister(mi->name);
+               xlat_func_unregister(mi->name);
                /*
                 *      Remove any registered paircmps.
                 */
                paircmp_unregister_instance(mi->dl_inst->data);
-               xlat_unregister_module(mi->dl_inst);
+               xlat_func_unregister_module(mi->dl_inst);
        }
 
        /*

diff --git a/src/lib/server/module_rlm.c b/src/lib/server/module_rlm.c
index be8ee64af33ea2c573097a8dc7ba4b3072d52e61..3b8807fb6bb91fc4d28f2a2510b2f2c67bfbaa4e 100644 (file)
--- a/src/lib/server/module_rlm.c
+++ b/src/lib/server/module_rlm.c
@@ -35,7 +35,7 @@ RCSID("$Id$")
 #include <freeradius-devel/server/pair.h>
 #include <freeradius-devel/server/virtual_servers.h>
 #include <freeradius-devel/util/atexit.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 #include <freeradius-devel/unlang/xlat_redundant.h>
 
 /** Lookup virtual module by name

diff --git a/src/lib/unlang/all.mk b/src/lib/unlang/all.mk
index 0c548276025eed1718328528cdd91253e86b3ff9..460c3dc32ff3069883666b7e8a94e32fc6c4f52a 100644 (file)
--- a/src/lib/unlang/all.mk
+++ b/src/lib/unlang/all.mk
@@ -30,11 +30,11 @@ SOURCES     :=      base.c \
                xlat_builtin.c \
                xlat_eval.c \
                xlat_expr.c \
+               xlat_func.c \
                xlat_inst.c \
                xlat_pair.c \
                xlat_purify.c \
                xlat_redundant.c \
-               xlat_register.c \
                xlat_tokenize.c
 
 HEADERS                := $(subst src/lib/,,$(wildcard src/lib/unlang/*.h))

diff --git a/src/lib/unlang/foreach.c b/src/lib/unlang/foreach.c
index 1de5aabf681a75dd9748a9864204638dc555f300..39ad19be8a9e42a2d9bdfb5a1d3643c030a94f05 100644 (file)
--- a/src/lib/unlang/foreach.c
+++ b/src/lib/unlang/foreach.c
@@ -25,7 +25,7 @@
 RCSID("$Id$")
 
 #include <freeradius-devel/server/request_data.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 #include "foreach_priv.h"
 #include "return_priv.h"
@@ -275,7 +275,7 @@ void unlang_foreach_init(void)
        for (i = 0; i < NUM_ELEMENTS(xlat_foreach_names); i++) {
                xlat_t *x;
 
-               x = xlat_register(NULL, xlat_foreach_names[i],
+               x = xlat_func_register(NULL, xlat_foreach_names[i],
                                  unlang_foreach_xlat, FR_TYPE_VOID);
                fr_assert(x);
                x->uctx = &xlat_foreach_inst[i];
@@ -301,6 +301,6 @@ void unlang_foreach_free(void)
        size_t  i;
 
        for (i = 0; i < NUM_ELEMENTS(xlat_foreach_names); i++) {
-               xlat_unregister(xlat_foreach_names[i]);
+               xlat_func_unregister(xlat_foreach_names[i]);
        }
 }

diff --git a/src/lib/unlang/interpret.c b/src/lib/unlang/interpret.c
index 93a0079cf55887a953ceabb619cdc3abd3593e8e..9af403d6cd11fbce8eba27debb4b2ade6fea07ff 100644 (file)
--- a/src/lib/unlang/interpret.c
+++ b/src/lib/unlang/interpret.c
@@ -26,7 +26,7 @@ RCSID("$Id$")
 
 #include <freeradius-devel/server/base.h>
 #include <freeradius-devel/server/modpriv.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 #include "interpret_priv.h"
 #include "module_priv.h"
@@ -1129,7 +1129,7 @@ void unlang_interpret_signal(request_t *request, fr_state_signal_t action)
        switch (action) {
        case FR_SIGNAL_CANCEL:
                /*
-                *      Detach the request from the parent to cleanup 
+                *      Detach the request from the parent to cleanup
                 *      any cross-request pointers.  This is a noop
                 *      if the request is not detachable.
                 */
@@ -1648,9 +1648,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);
+       xlat = xlat_func_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);
+       xlat = xlat_func_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 0a6eeb10d4cb35537da788b2cd4f751483c2e093..7b15c691c99a475d79a94e831b8dbae81e71727a 100644 (file)
--- a/src/lib/unlang/xlat.h
+++ b/src/lib/unlang/xlat.h
@@ -114,13 +114,6 @@ typedef struct {
        bool                    constant;       //!< xlat is just tmpl_attr_tail_data, or XLAT_BOX
 } xlat_flags_t;
 
-/*
- *     Simplify many use-cases
- *
- *     We can't set "needs_resolving" here, and async functions can't be pure.
- */
-#define XLAT_FLAG_PURE &(xlat_flags_t) { .pure = true, }
-
 extern fr_table_num_sorted_t const xlat_action_table[];
 extern size_t xlat_action_table_len;
 

diff --git a/src/lib/unlang/xlat_builtin.c b/src/lib/unlang/xlat_builtin.c
index 2bccd8b62e65d535d2427f040edf97f3d68c8e74..ff048675e402205ec740896faadc9249c88de647 100644 (file)
--- a/src/lib/unlang/xlat_builtin.c
+++ b/src/lib/unlang/xlat_builtin.c
@@ -33,7 +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_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 #include <freeradius-devel/unlang/xlat.h>
 
 #include <freeradius-devel/io/test_point.h>
@@ -3191,11 +3191,11 @@ 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);
+               xlat = xlat_func_register(NULL, buffer, protocol_decode_xlat, FR_TYPE_UINT32);
                if (!xlat) return -1;
                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_func_async_instantiate_set(xlat, protocol_xlat_instantiate, fr_test_point_pair_decode_t *, NULL, tp_decode);
                xlat_internal(xlat);
        }
 
@@ -3207,11 +3207,11 @@ 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);
+               xlat = xlat_func_register(NULL, buffer, protocol_encode_xlat, FR_TYPE_OCTETS);
                if (!xlat) return -1;
                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_func_async_instantiate_set(xlat, protocol_xlat_instantiate, fr_test_point_pair_encode_t *, NULL, tp_encode);
                xlat_internal(xlat);
        }
 
@@ -3252,7 +3252,7 @@ int xlat_init(void)
 {
        xlat_t *xlat;
 
-       if (xlat_register_init() < 0) return -1;
+       if (xlat_func_init() < 0) return -1;
 
        /*
         *      Lookup attributes used by virtual xlat expansions.
@@ -3274,9 +3274,9 @@ int xlat_init(void)
         */
 #define XLAT_REGISTER_ARGS(_xlat, _func, _return_type, _args) \
 do { \
-       if (!(xlat = xlat_register(NULL, _xlat, _func, _return_type))) return -1; \
+       if (!(xlat = xlat_func_register(NULL, _xlat, _func, _return_type))) return -1; \
        xlat_func_args_set(xlat, _args); \
-       xlat_func_flags_set(xlat, XLAT_FLAG_PURE); \
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE); \
        xlat_internal(xlat); \
 } while (0)
 
@@ -3298,7 +3298,7 @@ do { \
 #undef XLAT_REGISTER_ARGS
 #define XLAT_REGISTER_ARGS(_xlat, _func, _return_type, _args) \
 do { \
-       if (!(xlat = xlat_register(NULL, _xlat, _func, _return_type))) return -1; \
+       if (!(xlat = xlat_func_register(NULL, _xlat, _func, _return_type))) return -1; \
        xlat_func_args_set(xlat, _args); \
        xlat_internal(xlat); \
 } while (0)
@@ -3317,9 +3317,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);
+       xlat = xlat_func_register(NULL, "untaint", xlat_func_untaint, FR_TYPE_VOID);
        xlat_internal(xlat);
-       xlat = xlat_register(NULL, "taint", xlat_func_taint, FR_TYPE_VOID);
+       xlat = xlat_func_register(NULL, "taint", xlat_func_taint, FR_TYPE_VOID);
        xlat_internal(xlat);
 
        /*
@@ -3327,9 +3327,9 @@ do { \
         */
 #define XLAT_REGISTER_MONO(_xlat, _func, _return_type, _arg) \
 do { \
-       if (!(xlat = xlat_register(NULL, _xlat, _func, _return_type))) return -1; \
+       if (!(xlat = xlat_func_register(NULL, _xlat, _func, _return_type))) return -1; \
        xlat_func_mono_set(xlat, _arg); \
-       xlat_func_flags_set(xlat, XLAT_FLAG_PURE); \
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE); \
        xlat_internal(xlat); \
 } while (0)
 
@@ -3342,7 +3342,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);
+       xlat = xlat_func_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);
@@ -3376,7 +3376,7 @@ do { \
 #undef XLAT_REGISTER_MONO
 #define XLAT_REGISTER_MONO(_xlat, _func, _return_type, _arg) \
 do { \
-       if (!(xlat = xlat_register(NULL, _xlat, _func, _return_type))) return -1; \
+       if (!(xlat = xlat_func_register(NULL, _xlat, _func, _return_type))) return -1; \
        xlat_func_mono_set(xlat, _arg); \
        xlat_internal(xlat); \
 } while (0)
@@ -3384,7 +3384,7 @@ do { \
        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);
+       xlat = xlat_func_register(NULL, "module", xlat_func_module, FR_TYPE_STRING);
        xlat_internal(xlat);
 
        return xlat_register_expressions();
@@ -3395,7 +3395,7 @@ do { \
  */
 void xlat_free(void)
 {
-       xlat_register_free();
+       xlat_func_free();
 
        xlat_eval_free();
 }

diff --git a/src/lib/unlang/xlat_expr.c b/src/lib/unlang/xlat_expr.c
index 6ae560812a61ea9bdae60fd21e4267e16b77b788..e5d1ecdfdf0f9997932a37119aa33b4a0b6f138c 100644 (file)
--- a/src/lib/unlang/xlat_expr.c
+++ b/src/lib/unlang/xlat_expr.c
@@ -30,7 +30,7 @@ RCSID("$Id$")
 #include <freeradius-devel/unlang/xlat_priv.h>
 #include <freeradius-devel/util/calc.h>
 #include <freeradius-devel/server/tmpl_dcursor.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 #undef XLAT_DEBUG
 #ifdef DEBUG_XLAT
@@ -1627,21 +1627,21 @@ 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))) return -1; \
+       if (!(xlat = xlat_func_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_func_flags_set(xlat, XLAT_FUNC_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); \
+       xlat_func_async_instantiate_set(xlat, xlat_function_args_to_tmpl, NULL, NULL, NULL); \
        xlat->token = _op; \
 } while (0)
 
 #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))) return -1; \
+       if (!(xlat = xlat_func_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_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE); \
        xlat_internal(xlat); \
        xlat_print_set(xlat, xlat_expr_print_binary); \
        xlat_resolve_set(xlat, xlat_expr_resolve_binary); \
@@ -1651,9 +1651,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))) 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); \
+       if (!(xlat = xlat_func_register(NULL, STRINGIFY(_name), xlat_func_ ## _func_name, FR_TYPE_VOID))) return -1; \
+       xlat_func_async_instantiate_set(xlat, xlat_instantiate_ ## _func_name, xlat_ ## _func_name ## _inst_t, NULL, NULL); \
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE); \
        xlat_internal(xlat); \
        xlat_print_set(xlat, xlat_expr_print_ ## _func_name); \
        xlat_purify_set(xlat, xlat_expr_logical_purify); \
@@ -1663,10 +1663,10 @@ 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))) return -1; \
+       if (!(xlat = xlat_func_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_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE); \
+       xlat_func_async_instantiate_set(xlat, xlat_instantiate_regex, xlat_regex_inst_t, NULL, NULL); \
        xlat_print_set(xlat, xlat_expr_print_regex); \
        xlat_internal(xlat); \
        xlat->token = _op; \
@@ -1674,16 +1674,16 @@ do { \
 
 #define XLAT_REGISTER_MONO(_xlat, _func, _arg) \
 do { \
-       if (!(xlat = xlat_register(NULL, _xlat, _func, FR_TYPE_VOID))) return -1; \
+       if (!(xlat = xlat_func_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))) return -1; \
+       if (!(xlat = xlat_func_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_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE); \
        xlat_internal(xlat); \
        xlat_print_set(xlat, xlat_expr_print_unary); \
        xlat->token = _op; \
@@ -1727,7 +1727,7 @@ int xlat_register_expressions(void)
 
        XLAT_REGISTER_MONO("rcode", xlat_func_rcode, xlat_func_rcode_arg);
        XLAT_REGISTER_MONO("exists", xlat_func_exists, xlat_func_exists_arg);
-       xlat_async_instantiate_set(xlat, xlat_instantiate_exists, xlat_exists_inst_t, NULL, NULL);
+       xlat_func_async_instantiate_set(xlat, xlat_instantiate_exists, xlat_exists_inst_t, NULL, NULL);
        xlat_print_set(xlat, xlat_expr_print_exists);
 
        /*
@@ -1742,7 +1742,7 @@ int xlat_register_expressions(void)
        /*
         *      Callback wrapper around old paircmp() API.
         */
-       if (!(xlat = xlat_register(NULL, "paircmp", xlat_paircmp_func, FR_TYPE_VOID))) return -1; /* never pure! */
+       if (!(xlat = xlat_func_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);
 

diff --git a/src/lib/unlang/xlat_register.c b/src/lib/unlang/xlat_func.c
similarity index 93%
rename from src/lib/unlang/xlat_register.c
rename to src/lib/unlang/xlat_func.c
index 92bc251347e1e5bd9cd3d2047530dd07205e3f8d..38a5fadba39a2d932559e49b16d1ee16f891aa0c 100644 (file)
--- a/src/lib/unlang/xlat_register.c
+++ b/src/lib/unlang/xlat_func.c
@@ -27,7 +27,7 @@ RCSID("$Id$")
 
 #include <freeradius-devel/unlang/xlat_priv.h>
 #include <freeradius-devel/unlang/xlat.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 static fr_rb_tree_t *xlat_root = NULL;
 
@@ -168,7 +168,7 @@ static int xlat_arg_cmp_list_no_escape(xlat_arg_parser_t const a[], xlat_arg_par
  *     - 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,
+xlat_t *xlat_func_register_module(TALLOC_CTX *ctx, module_inst_ctx_t const *mctx,
                             char const *name, xlat_func_t func, fr_type_t return_type)
 {
        xlat_t  *c;
@@ -236,9 +236,9 @@ xlat_t *xlat_register_module(TALLOC_CTX *ctx, module_inst_ctx_t const *mctx,
  *     - 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_t *xlat_func_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, fr_type_t return_type)
 {
-       return xlat_register_module(ctx, NULL, name, func, return_type);
+       return xlat_func_register_module(ctx, NULL, name, func, return_type);
 }
 
 /** Verify xlat arg specifications are valid
@@ -339,15 +339,9 @@ int xlat_func_mono_set(xlat_t *x, xlat_arg_parser_t const args[])
  * @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)
+void xlat_func_flags_set(xlat_t *x, xlat_func_flags_t 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;
+       x->flags.pure = flags & XLAT_FUNC_FLAG_PURE;
 }
 
 /** Set global instantiation/detach callbacks
@@ -362,7 +356,7 @@ void xlat_func_flags_set(xlat_t *x, xlat_flags_t const *flags)
  * @param[in] detach           Called when an xlat_exp_t is freed.
  * @param[in] uctx             Passed to the instantiation function.
  */
-void _xlat_async_instantiate_set(xlat_t const *xlat,
+void _xlat_func_async_instantiate_set(xlat_t const *xlat,
                                 xlat_instantiate_t instantiate, char const *inst_type, size_t inst_size,
                                 xlat_detach_t detach,
                                 void *uctx)
@@ -390,7 +384,7 @@ void _xlat_async_instantiate_set(xlat_t const *xlat,
  * @param[in] thread_detach            Called when the thread is freed.
  * @param[in] uctx                     Passed to the thread instantiate function.
  */
-void _xlat_async_thread_instantiate_set(xlat_t const *xlat,
+void _xlat_func_async_thread_instantiate_set(xlat_t const *xlat,
                                        xlat_thread_instantiate_t thread_instantiate,
                                        char const *thread_inst_type, size_t thread_inst_size,
                                        xlat_thread_detach_t thread_detach,
@@ -420,7 +414,7 @@ void _xlat_async_thread_instantiate_set(xlat_t const *xlat,
  *
  * @param[in] name xlat to unregister.
  */
-void xlat_unregister(char const *name)
+void xlat_func_unregister(char const *name)
 {
        xlat_t  *c;
 
@@ -434,7 +428,7 @@ void xlat_unregister(char const *name)
        talloc_free(c); /* Should also remove from tree */
 }
 
-void xlat_unregister_module(dl_module_inst_t const *inst)
+void xlat_func_unregister_module(dl_module_inst_t const *inst)
 {
        xlat_t                          *c;
        fr_rb_iter_inorder_t    iter;
@@ -451,7 +445,7 @@ void xlat_unregister_module(dl_module_inst_t const *inst)
        }
 }
 
-int xlat_register_init(void)
+int xlat_func_init(void)
 {
        if (xlat_root) return 0;
 
@@ -467,7 +461,7 @@ int xlat_register_init(void)
        return 0;
 }
 
-void xlat_register_free(void)
+void xlat_func_free(void)
 {
        fr_rb_tree_t *xr = xlat_root;           /* Make sure the tree can't be freed multiple times */
 

diff --git a/src/lib/unlang/xlat_register.h b/src/lib/unlang/xlat_func.h
similarity index 53%
rename from src/lib/unlang/xlat_register.h
rename to src/lib/unlang/xlat_func.h
index 794e2a4b6b5268d27d18957b1453ede987cdee27..ea61661276307379e96e00fc92b951c8b1a1f6f4 100644 (file)
--- a/src/lib/unlang/xlat_register.h
+++ b/src/lib/unlang/xlat_func.h
@@ -18,7 +18,7 @@
 /**
  * $Id$
  *
- * @file lib/unlang/xlat_register.h
+ * @file lib/unlang/xlat_func.h
  * @brief Registration API for xlat functions.
  *
  * @copyright 2023 Arran Cudbard-Bell (a.cudbardb@freeradius.org)
@@ -27,15 +27,27 @@ RCSIDH(xlat_register_h, "$Id$")
 
 #include <freeradius-devel/unlang/xlat.h>
 
-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_t         *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, fr_type_t return_type) CC_HINT(nonnull(2));
+/*
+ * GCC doesn't support flag_enum (yet)
+ *
+ * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81665
+ */
+DIAG_OFF(attributes)
+typedef enum CC_HINT(flag_enum) {
+       XLAT_FUNC_FLAG_NONE = 0x00,
+       XLAT_FUNC_FLAG_PURE = 0x01
+} xlat_func_flags_t;
+DIAG_ON(attributes)
+
+xlat_t         *xlat_func_register_module(TALLOC_CTX *ctx, module_inst_ctx_t const *mctx,
+                                          char const *name, xlat_func_t func, fr_type_t return_type);
+xlat_t         *xlat_func_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, fr_type_t return_type) CC_HINT(nonnull(2));
 
 int            xlat_func_args_set(xlat_t *xlat, xlat_arg_parser_t const args[]) CC_HINT(nonnull);
 
 int            xlat_func_mono_set(xlat_t *xlat, xlat_arg_parser_t const *arg) CC_HINT(nonnull);
 
-void           xlat_func_flags_set(xlat_t *x, xlat_flags_t const *flags) CC_HINT(nonnull);
+void           xlat_func_flags_set(xlat_t *x, xlat_func_flags_t flags) CC_HINT(nonnull);
 
 /** Set a callback for global instantiation of xlat functions
  *
@@ -45,12 +57,12 @@ void                xlat_func_flags_set(xlat_t *x, xlat_flags_t const *flags) CC_HINT(nonnull)
  * @param[in] _detach          A destructor callback.
  * @param[in] _uctx            to pass to _instantiate and _detach callbacks.
  */
-#define        xlat_async_instantiate_set(_xlat, _instantiate, _inst_struct, _detach, _uctx) \
-       _xlat_async_instantiate_set(_xlat, _instantiate, #_inst_struct, sizeof(_inst_struct), _detach, _uctx)
-void _xlat_async_instantiate_set(xlat_t const *xlat,
-                                       xlat_instantiate_t instantiate, char const *inst_type, size_t inst_size,
-                                       xlat_detach_t detach,
-                                       void *uctx);
+#define        xlat_func_async_instantiate_set(_xlat, _instantiate, _inst_struct, _detach, _uctx) \
+       _xlat_func_async_instantiate_set(_xlat, _instantiate, #_inst_struct, sizeof(_inst_struct), _detach, _uctx)
+void _xlat_func_async_instantiate_set(xlat_t const *xlat,
+                                     xlat_instantiate_t instantiate, char const *inst_type, size_t inst_size,
+                                     xlat_detach_t detach,
+                                     void *uctx);
 
 /** Set a callback for thread-specific instantiation of xlat functions
  *
@@ -60,17 +72,17 @@ void _xlat_async_instantiate_set(xlat_t const *xlat,
  * @param[in] _detach          A destructor callback.
  * @param[in] _uctx            to pass to _instantiate and _detach callbacks.
  */
-#define        xlat_async_thread_instantiate_set(_xlat, _instantiate, _inst_struct, _detach, _uctx) \
-       _xlat_async_thread_instantiate_set(_xlat, _instantiate, #_inst_struct, sizeof(_inst_struct), _detach, _uctx)
-void _xlat_async_thread_instantiate_set(xlat_t const *xlat,
-                                       xlat_thread_instantiate_t thread_instantiate,
-                                       char const *thread_inst_type, size_t thread_inst_size,
-                                       xlat_thread_detach_t thread_detach,
-                                       void *uctx);
+#define        xlat_func_async_thread_instantiate_set(_xlat, _instantiate, _inst_struct, _detach, _uctx) \
+       _xlat_func_async_thread_instantiate_set(_xlat, _instantiate, #_inst_struct, sizeof(_inst_struct), _detach, _uctx)
+void _xlat_func_async_thread_instantiate_set(xlat_t const *xlat,
+                                            xlat_thread_instantiate_t thread_instantiate,
+                                            char const *thread_inst_type, size_t thread_inst_size,
+                                            xlat_thread_detach_t thread_detach,
+                                            void *uctx);
 
-void           xlat_unregister(char const *name);
-void           xlat_unregister_module(dl_module_inst_t const *inst);
+void           xlat_func_unregister(char const *name);
+void           xlat_func_unregister_module(dl_module_inst_t const *inst);
 /** @hidecallgraph */
 
-int            xlat_register_init(void);
-void           xlat_register_free(void);
+int            xlat_func_init(void);
+void           xlat_func_free(void);

diff --git a/src/lib/unlang/xlat_redundant.c b/src/lib/unlang/xlat_redundant.c
index 03449b51d41bca7f1c050f10241e095504e96204..da1bfd5b727ab448d91058abd552a836577e41ca 100644 (file)
--- a/src/lib/unlang/xlat_redundant.c
+++ b/src/lib/unlang/xlat_redundant.c
@@ -27,7 +27,7 @@ RCSID("$Id$")
 
 #include <freeradius-devel/unlang/interpret.h>
 #include <freeradius-devel/unlang/xlat_redundant.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 #include <freeradius-devel/unlang/xlat_priv.h>
 #include <freeradius-devel/util/rand.h>
 
@@ -450,7 +450,7 @@ int xlat_register_redundant(CONF_SECTION *cs)
                return 1;
        }
 
-       xlat = xlat_register(NULL, name2, xlat_redundant, return_type);
+       xlat = xlat_func_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>"));
@@ -458,7 +458,7 @@ int xlat_register_redundant(CONF_SECTION *cs)
                return -1;
        }
        xlat_func_flags_set(xlat, &flags);
-       xlat_async_instantiate_set(xlat, xlat_redundant_instantiate, xlat_redundant_inst_t, NULL, xr);
+       xlat_func_async_instantiate_set(xlat, xlat_redundant_instantiate, xlat_redundant_inst_t, NULL, xr);
        if (args) xlat_func_args_set(xlat, xlat_redundant_args);
 
        return 0;

diff --git a/src/modules/rlm_always/rlm_always.c b/src/modules/rlm_always/rlm_always.c
index 7b858532bd1a988ef1071f6be9e7af899ba0e373..b30f0fa65426f08e96b5f101cef200e9050dd16c 100644 (file)
--- a/src/modules/rlm_always/rlm_always.c
+++ b/src/modules/rlm_always/rlm_always.c
@@ -28,7 +28,7 @@ RCSID("$Id$")
 
 #include <freeradius-devel/server/base.h>
 #include <freeradius-devel/server/module_rlm.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 /*
  *     The instance data for rlm_always is the list of fake values we are
@@ -126,7 +126,7 @@ 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);
+       xlat = xlat_func_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 9caaf926ee01c83fb0637296d46d3ec172b5f6da..03de1e5e0fcb492124eb5878389a72247f92325a 100644 (file)
--- a/src/modules/rlm_cache/rlm_cache.c
+++ b/src/modules/rlm_cache/rlm_cache.c
@@ -30,7 +30,7 @@ RCSID("$Id$")
 #include <freeradius-devel/server/modpriv.h>
 #include <freeradius-devel/server/dl_module.h>
 #include <freeradius-devel/util/debug.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 #include "rlm_cache.h"
 
@@ -972,7 +972,7 @@ 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);
+       xlat = xlat_func_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 a08e31916fd966550f678a6afaebda12dca14de7..20717abe57c1c70d1e0794e3ff758b6737c5bd0f 100644 (file)
--- a/src/modules/rlm_chap/rlm_chap.c
+++ b/src/modules/rlm_chap/rlm_chap.c
@@ -29,7 +29,7 @@ RCSID("$Id$")
 #include <freeradius-devel/server/password.h>
 #include <freeradius-devel/server/module_rlm.h>
 #include <freeradius-devel/radius/radius.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 typedef struct {
        fr_dict_enum_value_t            *auth_type;
@@ -293,7 +293,7 @@ static int mod_load(void)
 {
        xlat_t  *xlat;
 
-       xlat = xlat_register(NULL, "chap_password", xlat_func_chap_password, FR_TYPE_OCTETS);
+       xlat = xlat_func_register(NULL, "chap_password", xlat_func_chap_password, FR_TYPE_OCTETS);
        if (!xlat) return -1;
        xlat_func_args_set(xlat, xlat_func_chap_password_args);
 
@@ -302,7 +302,7 @@ static int mod_load(void)
 
 static void mod_unload(void)
 {
-       xlat_unregister("chap_password");
+       xlat_func_unregister("chap_password");
 }
 
 /*

diff --git a/src/modules/rlm_cipher/rlm_cipher.c b/src/modules/rlm_cipher/rlm_cipher.c
index 4a4dc49faa510d06cbd1cae3a2e554163411c5d3..d1d5c96cc3dd7cd513bc5825213414e3bdca4cc8 100644 (file)
--- a/src/modules/rlm_cipher/rlm_cipher.c
+++ b/src/modules/rlm_cipher/rlm_cipher.c
@@ -34,7 +34,7 @@ RCSID("$Id$")
 #include <freeradius-devel/tls/log.h>
 #include <freeradius-devel/tls/strerror.h>
 #include <freeradius-devel/util/debug.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 #include <freeradius-devel/tls/openssl_user_macros.h>
 #include <openssl/crypto.h>
@@ -1300,7 +1300,7 @@ 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);
+                       xlat = xlat_func_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);
 
@@ -1308,7 +1308,7 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
                         *      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);
+                       xlat = xlat_func_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);
                }
@@ -1337,7 +1337,7 @@ 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);
+                       xlat = xlat_func_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);
 
@@ -1345,7 +1345,7 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
                         *      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);
+                       xlat = xlat_func_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);
 
@@ -1354,7 +1354,7 @@ 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);
+                       xlat = xlat_func_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 9a30b6c3bd431347dec38b4f732667237e14012e..2bd1fd2bb07c5df88ec60aa5667f945487b5c557 100644 (file)
--- a/src/modules/rlm_client/rlm_client.c
+++ b/src/modules/rlm_client/rlm_client.c
@@ -30,7 +30,7 @@ RCSID("$Id$")
 #include <freeradius-devel/server/module_rlm.h>
 #include <freeradius-devel/server/map_proc.h>
 #include <freeradius-devel/util/debug.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 /** Client field
  *
@@ -353,7 +353,7 @@ static int mod_load(void)
 {
        xlat_t  *xlat;
 
-       xlat = xlat_register(NULL, "client", xlat_client, FR_TYPE_STRING);
+       xlat = xlat_func_register(NULL, "client", xlat_client, FR_TYPE_STRING);
        if (!xlat) return -1;
        xlat_func_args_set(xlat, xlat_client_args);
 
@@ -364,7 +364,7 @@ static int mod_load(void)
 
 static void mod_unload(void)
 {
-       xlat_unregister("client");
+       xlat_func_unregister("client");
 }
 
 /*

diff --git a/src/modules/rlm_date/rlm_date.c b/src/modules/rlm_date/rlm_date.c
index 3841f7b684fae153980bb137efb6ccf11c4a3d5f..d04333ed6032097004504337dc1a5c724eeb51fc 100644 (file)
--- a/src/modules/rlm_date/rlm_date.c
+++ b/src/modules/rlm_date/rlm_date.c
@@ -26,7 +26,7 @@
 
 #include <freeradius-devel/server/base.h>
 #include <freeradius-devel/server/module_rlm.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 #include <ctype.h>
 #include <time.h>
 
@@ -235,7 +235,7 @@ 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);
+       xlat = xlat_func_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 f53b32770b2bd8f9cde48aa05112e94925a2ce15..d735fa66657dd8e73b92d5f4152b756f5976d469 100644 (file)
--- a/src/modules/rlm_delay/rlm_delay.c
+++ b/src/modules/rlm_delay/rlm_delay.c
@@ -29,7 +29,7 @@ RCSID("$Id$")
 #include <freeradius-devel/util/debug.h>
 #include <freeradius-devel/server/map_proc.h>
 #include <freeradius-devel/util/time.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 typedef struct {
        tmpl_t          *delay;                 //!< How long we delay for.
@@ -269,7 +269,7 @@ 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);
+       xlat = xlat_func_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 020b6fd29a97b58bc8620aee0a4c769b06c950cf..f4d1345750061be0b2c857e51db2566165b3bc0e 100644 (file)
--- a/src/modules/rlm_dict/rlm_dict.c
+++ b/src/modules/rlm_dict/rlm_dict.c
@@ -26,7 +26,7 @@ RCSID("$Id$")
 #include <freeradius-devel/server/base.h>
 #include <freeradius-devel/server/module_rlm.h>
 #include <freeradius-devel/util/debug.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 static xlat_arg_parser_t const xlat_dict_attr_by_num_args[] = {
        { .required = true, .single = true, .type = FR_TYPE_UINT32 },
@@ -237,17 +237,17 @@ 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);
+       xlat = xlat_func_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 = xlat_func_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 = xlat_func_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 = xlat_func_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 = xlat_func_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 = xlat_func_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_eap/types/rlm_eap_aka/rlm_eap_aka.c b/src/modules/rlm_eap/types/rlm_eap_aka/rlm_eap_aka.c
index 59b3571513c5c336d87441efdb0dcf6b2528619c..35a6e83cab31bac354f853aea8c2ff122a2f082f 100644 (file)
--- a/src/modules/rlm_eap/types/rlm_eap_aka/rlm_eap_aka.c
+++ b/src/modules/rlm_eap/types/rlm_eap_aka/rlm_eap_aka.c
@@ -100,14 +100,14 @@ static int mod_load(void)
 {
        if (fr_aka_sim_init() < 0) return -1;
 
-       fr_aka_sim_xlat_register();
+       fr_aka_sim_xlat_func_register();
 
        return 0;
 }
 
 static void mod_unload(void)
 {
-       fr_aka_sim_xlat_unregister();
+       fr_aka_sim_xlat_func_unregister();
 
        fr_aka_sim_free();
 }

diff --git a/src/modules/rlm_eap/types/rlm_eap_aka_prime/rlm_eap_aka_prime.c b/src/modules/rlm_eap/types/rlm_eap_aka_prime/rlm_eap_aka_prime.c
index 96fb5d5f295ff188041b011ebf563bf685949878..a17172cfca62a117e48a2c323b8494a96eb599fd 100644 (file)
--- a/src/modules/rlm_eap/types/rlm_eap_aka_prime/rlm_eap_aka_prime.c
+++ b/src/modules/rlm_eap/types/rlm_eap_aka_prime/rlm_eap_aka_prime.c
@@ -78,14 +78,14 @@ static int mod_load(void)
 {
        if (fr_aka_sim_init() < 0) return -1;
 
-       fr_aka_sim_xlat_register();
+       fr_aka_sim_xlat_func_register();
 
        return 0;
 }
 
 static void mod_unload(void)
 {
-       fr_aka_sim_xlat_unregister();
+       fr_aka_sim_xlat_func_unregister();
 
        fr_aka_sim_free();
 }

diff --git a/src/modules/rlm_eap/types/rlm_eap_sim/rlm_eap_sim.c b/src/modules/rlm_eap/types/rlm_eap_sim/rlm_eap_sim.c
index 2170eb431343e5880e5c61da8cb58c33521aa4f5..ac39e79745bf94994185e2c1201d8709d7c2fbfc 100644 (file)
--- a/src/modules/rlm_eap/types/rlm_eap_sim/rlm_eap_sim.c
+++ b/src/modules/rlm_eap/types/rlm_eap_sim/rlm_eap_sim.c
@@ -77,14 +77,14 @@ static int mod_load(void)
 {
        if (fr_aka_sim_init() < 0) return -1;
 
-       fr_aka_sim_xlat_register();
+       fr_aka_sim_xlat_func_register();
 
        return 0;
 }
 
 static void mod_unload(void)
 {
-       fr_aka_sim_xlat_unregister();
+       fr_aka_sim_xlat_func_unregister();
 
        fr_aka_sim_free();
 }

diff --git a/src/modules/rlm_escape/rlm_escape.c b/src/modules/rlm_escape/rlm_escape.c
index ce4a8f5d9463cec3a3962eee03a458aacf53d6de..dc1cc5c5ffe04bcabaf2d1a45b81f13cb66a366a 100644 (file)
--- a/src/modules/rlm_escape/rlm_escape.c
+++ b/src/modules/rlm_escape/rlm_escape.c
@@ -29,7 +29,7 @@ USES_APPLE_DEPRECATED_API
 
 #include <freeradius-devel/server/module_rlm.h>
 #include <freeradius-devel/util/debug.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 #include <ctype.h>
 
@@ -197,13 +197,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 = xlat_func_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_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE);
 
-       xlat = xlat_register_module(NULL, mctx, unescape, unescape_xlat, FR_TYPE_STRING);
+       xlat = xlat_func_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);
+       xlat_func_flags_set(xlat, XLAT_FUNC_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 6f65e60541d6830804ad56543e1f6e4be67df540..a956a9aa62412ae98b48d155fa23fce8c193202d 100644 (file)
--- a/src/modules/rlm_exec/rlm_exec.c
+++ b/src/modules/rlm_exec/rlm_exec.c
@@ -32,7 +32,7 @@ RCSID("$Id$")
 #include <freeradius-devel/server/tmpl.h>
 #include <freeradius-devel/unlang/interpret.h>
 #include <freeradius-devel/util/debug.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 /*
  *     Define a structure for our module configuration.
@@ -173,7 +173,7 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
                }
        };
 
-       xlat = xlat_register_module(NULL, mctx, mctx->inst->name, exec_xlat, FR_TYPE_STRING);
+       xlat = xlat_func_register_module(NULL, mctx, mctx->inst->name, exec_xlat, FR_TYPE_STRING);
        xlat_func_args_set(xlat, exec_xlat_args);
 
        if (inst->input) {

diff --git a/src/modules/rlm_icmp/rlm_icmp.c b/src/modules/rlm_icmp/rlm_icmp.c
index 15d946fd96bb4767918c0f616ec17e837fb4c0a5..d6c1a099b99ba6c058ef6511503410b6d4caab75 100644 (file)
--- a/src/modules/rlm_icmp/rlm_icmp.c
+++ b/src/modules/rlm_icmp/rlm_icmp.c
@@ -29,7 +29,7 @@ RCSID("$Id$")
 #include <freeradius-devel/server/module_rlm.h>
 #include <freeradius-devel/util/cap.h>
 #include <freeradius-devel/util/debug.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 #include <fcntl.h>
 #include <unistd.h>
@@ -498,7 +498,7 @@ 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);
+       xlat = xlat_func_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 */

diff --git a/src/modules/rlm_idn/rlm_idn.c b/src/modules/rlm_idn/rlm_idn.c
index 646eb42488c672713a337e8555be5dce0265c979..56a68c245cb91288fb0b9778992e2fce7e511fb9 100644 (file)
--- a/src/modules/rlm_idn/rlm_idn.c
+++ b/src/modules/rlm_idn/rlm_idn.c
@@ -25,7 +25,7 @@ RCSID("$Id$")
 
 #include <freeradius-devel/server/base.h>
 #include <freeradius-devel/server/module_rlm.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 #include <idna.h>
 
@@ -153,9 +153,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 = xlat_func_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);
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE);
 
        return 0;
 }

diff --git a/src/modules/rlm_json/rlm_json.c b/src/modules/rlm_json/rlm_json.c
index 3bd6c16aa06e11b20e71834846d57a8ef346789b..d21d867e609b4afd3532c29a36f2ad919da631b1 100644 (file)
--- a/src/modules/rlm_json/rlm_json.c
+++ b/src/modules/rlm_json/rlm_json.c
@@ -32,7 +32,7 @@ RCSID("$Id$")
 #include <freeradius-devel/server/module_rlm.h>
 #include <freeradius-devel/server/map_proc.h>
 #include <freeradius-devel/util/debug.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 #include <freeradius-devel/json/base.h>
 
 #include <ctype.h>
@@ -530,13 +530,13 @@ 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);
+       xlat = xlat_func_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);
+       xlat = xlat_func_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);
+       xlat = xlat_func_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 c99782047fbac91e90132cd39c90456d9ac1d291..89c07ad1101a81a53788fa11b299ef0bf66c7392 100644 (file)
--- a/src/modules/rlm_ldap/rlm_ldap.c
+++ b/src/modules/rlm_ldap/rlm_ldap.c
@@ -40,7 +40,7 @@ USES_APPLE_DEPRECATED_API
 #include <freeradius-devel/server/map_proc.h>
 #include <freeradius-devel/server/module_rlm.h>
 
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 static CONF_PARSER sasl_mech_dynamic[] = {
        { FR_CONF_OFFSET("mech", FR_TYPE_TMPL | FR_TYPE_NOT_EMPTY, fr_ldap_sasl_t_dynamic_t, mech) },
@@ -1772,18 +1772,18 @@ 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);
+       xlat = xlat_func_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 = xlat_func_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_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE);
        }
-       xlat = xlat_register_module(NULL, mctx, "ldap_unescape", ldap_unescape_xlat, FR_TYPE_STRING);
+       xlat = xlat_func_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);
+               xlat_func_flags_set(xlat, XLAT_FUNC_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 24208b08f8fa5d8fe665f0d6ae63c52f777112c6..7acda9ffddf73750ad7dd8e2a91d857bdca01172 100644 (file)
--- a/src/modules/rlm_linelog/rlm_linelog.c
+++ b/src/modules/rlm_linelog/rlm_linelog.c
@@ -31,7 +31,7 @@ RCSID("$Id$")
 #include <freeradius-devel/util/iovec.h>
 #include <freeradius-devel/util/perm.h>
 
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 #ifdef HAVE_FCNTL_H
 #  include <fcntl.h>
@@ -907,7 +907,7 @@ 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);
+       xlat = xlat_func_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 ecbbc7f6ee02dbfbb92928454a7867b8e126edeb..65c2e8d4ea9d6c53e517eaf3366fe4c4adffddaa 100644 (file)
--- a/src/modules/rlm_mschap/rlm_mschap.c
+++ b/src/modules/rlm_mschap/rlm_mschap.c
@@ -41,7 +41,7 @@ RCSID("$Id$")
 #include <freeradius-devel/util/misc.h>
 #include <freeradius-devel/util/sha1.h>
 
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 #include <sys/wait.h>
 #include <ctype.h>
@@ -2279,7 +2279,7 @@ 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);
+       xlat = xlat_func_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 2b246b0db549c46c25602da61023b8ae61cf3df0..ddd999c009433a077b8a50878b8f68333d258c4f 100644 (file)
--- a/src/modules/rlm_perl/rlm_perl.c
+++ b/src/modules/rlm_perl/rlm_perl.c
@@ -29,7 +29,7 @@ RCSID("$Id$")
 #include <freeradius-devel/server/base.h>
 #include <freeradius-devel/server/module_rlm.h>
 #include <freeradius-devel/util/debug.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 #include <freeradius-devel/radius/radius.h>
 
 DIAG_OFF(DIAG_UNKNOWN_PRAGMAS)
@@ -581,7 +581,7 @@ 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);
+       xlat = xlat_func_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 1c61528b3fafd6053d2525216fd20a53b6142c8d..043cb86632213964f2aae8a85857e4cbd0f1b99a 100644 (file)
--- a/src/modules/rlm_redis/rlm_redis.c
+++ b/src/modules/rlm_redis/rlm_redis.c
@@ -32,7 +32,7 @@ RCSID("$Id$")
 #include <freeradius-devel/server/module_rlm.h>
 #include <freeradius-devel/server/modpriv.h>
 #include <freeradius-devel/util/debug.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 #include <freeradius-devel/redis/base.h>
 #include <freeradius-devel/redis/cluster.h>
@@ -453,19 +453,19 @@ 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);
+       xlat = xlat_func_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);
+       xlat = xlat_func_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);
+       xlat = xlat_func_register_module(inst, mctx, name, redis_remap_xlat, FR_TYPE_STRING);
        xlat_func_args_set(xlat, redis_remap_xlat_args);
        talloc_free(name);
 

diff --git a/src/modules/rlm_rest/rlm_rest.c b/src/modules/rlm_rest/rlm_rest.c
index 56f15bab14c395f36433be51959b7f6b6fe92eff..1df7adca6f2ded678f62bc55cbe7e06abeb941a2 100644 (file)
--- a/src/modules/rlm_rest/rlm_rest.c
+++ b/src/modules/rlm_rest/rlm_rest.c
@@ -33,7 +33,7 @@ RCSID("$Id$")
 #include <freeradius-devel/util/debug.h>
 #include <freeradius-devel/util/table.h>
 #include <freeradius-devel/util/uri.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 #include <ctype.h>
 #include "rest.h"
@@ -1245,7 +1245,7 @@ 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);
+       xlat = xlat_func_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 105627097e4ccc708a363d28111e2c8d72d74019..b6cf4d61598e70d82ba2e271b8a5b05c3b1938a3 100644 (file)
--- a/src/modules/rlm_soh/rlm_soh.c
+++ b/src/modules/rlm_soh/rlm_soh.c
@@ -26,7 +26,7 @@ RCSID("$Id$")
 #include <freeradius-devel/server/base.h>
 #include <freeradius-devel/server/module_rlm.h>
 #include <freeradius-devel/soh/base.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 typedef struct {
        bool dhcp;
@@ -274,7 +274,7 @@ 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);
+       xlat = xlat_func_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 b6a06d82cd34e425a316e1d08e380becee6f8b70..a20a73707645b7b2cdb1ff5962d7769f750733a0 100644 (file)
--- a/src/modules/rlm_sql/rlm_sql.c
+++ b/src/modules/rlm_sql/rlm_sql.c
@@ -37,7 +37,7 @@ RCSID("$Id$")
 #include <freeradius-devel/server/pairmove.h>
 #include <freeradius-devel/util/debug.h>
 #include <freeradius-devel/util/table.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 #include <sys/stat.h>
 
@@ -1059,7 +1059,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);      /* Returns an integer sometimes */
+       xlat = xlat_func_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

diff --git a/src/modules/rlm_test/rlm_test.c b/src/modules/rlm_test/rlm_test.c
index 2fcff357dfd2a4b79eb6076c70c3732e6d062e9b..3dd12809efab794a0db4f0825590e4ab501b9589 100644 (file)
--- a/src/modules/rlm_test/rlm_test.c
+++ b/src/modules/rlm_test/rlm_test.c
@@ -30,7 +30,7 @@ RCSID("$Id$")
 #include <freeradius-devel/server/module_rlm.h>
 #include <freeradius-devel/server/tmpl.h>
 #include <freeradius-devel/util/debug.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 
 /*
  *     Define a structure for our module configuration.
@@ -484,14 +484,14 @@ 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))) return -1;
+               if (!(xlat = xlat_func_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))) return -1;
+               if (!(xlat = xlat_func_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))) return -1;
+               if (!(xlat = xlat_func_register_module(inst, mctx, mctx->inst->name, test_xlat, FR_TYPE_VOID))) return -1;
                xlat_func_args_set(xlat, test_xlat_args);
        }
 

diff --git a/src/modules/rlm_unbound/rlm_unbound.c b/src/modules/rlm_unbound/rlm_unbound.c
index 1d773b21aecd887a1599e0f8ea276bbcf122abc1..319860a1e7597deb8a1bbdfcd3da7dc2dbbeca37 100644 (file)
--- a/src/modules/rlm_unbound/rlm_unbound.c
+++ b/src/modules/rlm_unbound/rlm_unbound.c
@@ -29,7 +29,7 @@ RCSID("$Id$")
 #include <freeradius-devel/server/base.h>
 #include <freeradius-devel/server/module_rlm.h>
 #include <freeradius-devel/server/log.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 #include <fcntl.h>
 
 #include "io.h"
@@ -491,7 +491,7 @@ 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))) return -1;
+       if(!(xlat = xlat_func_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 92d8567b382c19826c33dd85b0e83f92b8d8251e..5a0ba45024c6ea5d5763facae85bd90aa1a11556 100644 (file)
--- a/src/modules/rlm_unpack/rlm_unpack.c
+++ b/src/modules/rlm_unpack/rlm_unpack.c
@@ -26,7 +26,7 @@ RCSID("$Id$")
 
 #include <freeradius-devel/server/base.h>
 #include <freeradius-devel/server/module_rlm.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 #include <freeradius-devel/util/base16.h>
 
 #include <ctype.h>
@@ -134,10 +134,10 @@ 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 = xlat_func_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);
+               xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE);
        }
 
        return 0;

diff --git a/src/modules/rlm_yubikey/rlm_yubikey.c b/src/modules/rlm_yubikey/rlm_yubikey.c
index ff7e60c36b537c02c83ce8015849f364405283bf..81d5bea1c7afa76484acf6de99feb6275ddcae46 100644 (file)
--- a/src/modules/rlm_yubikey/rlm_yubikey.c
+++ b/src/modules/rlm_yubikey/rlm_yubikey.c
@@ -26,7 +26,7 @@
 RCSID("$Id$")
 
 #include <freeradius-devel/radius/radius.h>
-#include <freeradius-devel/unlang/xlat_register.h>
+#include <freeradius-devel/unlang/xlat_func.h>
 #include "rlm_yubikey.h"
 
 #ifdef HAVE_YKCLIENT
@@ -197,10 +197,10 @@ 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 = xlat_func_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);
+               xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE);
        }
        return 0;
 }

diff --git a/src/process/eap_aka/base.c b/src/process/eap_aka/base.c
index 0d9a08b2f3cc9fbaf83acb2ce924b7566abbd203..22c970851815f18f8bc7509671e44c7d1672ebca 100644 (file)
--- a/src/process/eap_aka/base.c
+++ b/src/process/eap_aka/base.c
@@ -251,14 +251,14 @@ static int mod_load(void)
 {
        if (unlikely(fr_aka_sim_init() < 0)) return -1;
 
-       fr_aka_sim_xlat_register();
+       fr_aka_sim_xlat_func_register();
 
        return 0;
 }
 
 static void mod_unload(void)
 {
-       fr_aka_sim_xlat_unregister();
+       fr_aka_sim_xlat_func_unregister();
 
        fr_aka_sim_free();
 }

diff --git a/src/process/eap_aka_prime/base.c b/src/process/eap_aka_prime/base.c
index 4f665a1d034d49690bc9388a080853879b44e66d..c4d6bbc28a767dd74beb356c2b0b30f92121a0f1 100644 (file)
--- a/src/process/eap_aka_prime/base.c
+++ b/src/process/eap_aka_prime/base.c
@@ -252,14 +252,14 @@ static int mod_load(void)
 {
        if (unlikely(fr_aka_sim_init() < 0)) return -1;
 
-       fr_aka_sim_xlat_register();
+       fr_aka_sim_xlat_func_register();
 
        return 0;
 }
 
 static void mod_unload(void)
 {
-       fr_aka_sim_xlat_unregister();
+       fr_aka_sim_xlat_func_unregister();
 
        fr_aka_sim_free();
 }

diff --git a/src/process/eap_sim/base.c b/src/process/eap_sim/base.c
index d98ec6d44e7f7969469d24bf65101e761f70e642..1101707830f09979417ae7bb50c699e8cbdeb2d7 100644 (file)
--- a/src/process/eap_sim/base.c
+++ b/src/process/eap_sim/base.c
@@ -239,14 +239,14 @@ static int mod_load(void)
 {
        if (unlikely(fr_aka_sim_init() < 0)) return -1;
 
-       fr_aka_sim_xlat_register();
+       fr_aka_sim_xlat_func_register();
 
        return 0;
 }
 
 static void mod_unload(void)
 {
-       fr_aka_sim_xlat_unregister();
+       fr_aka_sim_xlat_func_unregister();
 
        fr_aka_sim_free();
 }