pass xlat_flags_t to xlat_register()

so that we can pass both needs_async && pure

diff --git a/src/bin/unit_test_attribute.c b/src/bin/unit_test_attribute.c
index f11bdad709894aa73335816f9dd72230b649e726..b6e332770f9279d0a93d39f61089edefc48ad4c6 100644 (file)
--- a/src/bin/unit_test_attribute.c
+++ b/src/bin/unit_test_attribute.c
@@ -3494,7 +3494,7 @@ int main(int argc, char *argv[])
 
        unlang_thread_instantiate(autofree);
 
-       if (!xlat_register(NULL, "test", xlat_test, false)) {
+       if (!xlat_register(NULL, "test", xlat_test, 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 247f3a007103566f768d8b6f40b88b7333521695..af7fd3715a08caa113c7959a4bedc687056c6ea2 100644 (file)
--- a/src/lib/eap_aka_sim/xlat.c
+++ b/src/lib/eap_aka_sim/xlat.c
@@ -500,15 +500,15 @@ void fr_aka_sim_xlat_register(void)
                return;
        }
 
-       xlat = xlat_register(NULL, "aka_sim_id_method", aka_sim_xlat_id_method_xlat, false);
+       xlat = xlat_register(NULL, "aka_sim_id_method", aka_sim_xlat_id_method_xlat, 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, false);
+       xlat = xlat_register(NULL, "aka_sim_id_type", aka_sim_xlat_id_type_xlat, 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, false);
+       xlat = xlat_register(NULL, "3gpp_temporary_id_key_index", aka_sim_id_3gpp_temporary_id_key_index_xlat, 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, false);
+       xlat = xlat_register(NULL, "3gpp_temporary_id_decrypt", aka_sim_3gpp_temporary_id_decrypt_xlat, 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, false);
+       xlat = xlat_register(NULL, "3gpp_temporary_id_encrypt", aka_sim_3gpp_temporary_id_encrypt_xlat, NULL);
        xlat_func_args(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 6fa282a5656ca616b02ab6d371fa8e732c19e2b8..66d1252384674ea5f1cf0b2e8ae632da61ae6ffa 100644 (file)
--- a/src/lib/server/main_config.c
+++ b/src/lib/server/main_config.c
@@ -1288,7 +1288,7 @@ do {\
        /*
         *      Register the %(config:section.subsection) xlat function.
         */
-       xlat = xlat_register(NULL, "config", xlat_config, false);
+       xlat = xlat_register(NULL, "config", xlat_config, NULL);
        xlat_func_args(xlat, xlat_config_args);
 
        /*

diff --git a/src/lib/unlang/foreach.c b/src/lib/unlang/foreach.c
index 0b5706b4858983214cd9a87bd02e4b5c4443adb1..d10b80177e83789bf60425e4a417f27c5106190a 100644 (file)
--- a/src/lib/unlang/foreach.c
+++ b/src/lib/unlang/foreach.c
@@ -221,7 +221,7 @@ void unlang_foreach_init(void)
                xlat_t *x;
 
                x = xlat_register(NULL, xlat_foreach_names[i],
-                                 unlang_foreach_xlat, true);
+                                 unlang_foreach_xlat, XLAT_FLAG_NEEDS_ASYNC);
                x->uctx = &xlat_foreach_inst[i];
                fr_assert(x);
                xlat_internal(x);

diff --git a/src/lib/unlang/interpret.c b/src/lib/unlang/interpret.c
index dc280a98c47ab757115fb33c9b5fd7f8e87eb7d1..e2d3248743c0ef727089e7a19dedbaaf7167aed5 100644 (file)
--- a/src/lib/unlang/interpret.c
+++ b/src/lib/unlang/interpret.c
@@ -1444,6 +1444,6 @@ unlang_interpret_t *unlang_interpret_get_thread_default(void)
 void unlang_interpret_init_global(void)
 {
        xlat_t  *xlat;
-       xlat = xlat_register(NULL, "interpreter", unlang_interpret_xlat, false);
+       xlat = xlat_register(NULL, "interpreter", unlang_interpret_xlat, NULL);
        xlat_func_args(xlat, unlang_interpret_xlat_args);
 }

diff --git a/src/lib/unlang/xlat.h b/src/lib/unlang/xlat.h
index 287a394f13b87fe0aed804a5e280f4366fea992e..fc77f4e56dead24b95aaf7ae3c89422a5a1616b3 100644 (file)
--- a/src/lib/unlang/xlat.h
+++ b/src/lib/unlang/xlat.h
@@ -94,6 +94,14 @@ typedef struct {
        bool                    pure;           //!< has no external side effects
 } xlat_flags_t;
 
+/*
+ *     Simplify many use-cases
+ *
+ *     We can't set "needs_resolving" here, and async functions can't be pure.
+ */
+#define XLAT_FLAG_NEEDS_ASYNC &(xlat_flags_t) { .needs_async = true, }
+#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;
 
@@ -369,7 +377,7 @@ xlat_t              *xlat_register_legacy(void *mod_inst, char const *name,
                                      xlat_instantiate_t instantiate, size_t inst_size,
                                      size_t buf_len);
 
-xlat_t         *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, bool needs_async) CC_HINT(nonnull(2));
+xlat_t         *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, xlat_flags_t const *flags) CC_HINT(nonnull(2));
 
 int            xlat_func_args(xlat_t *xlat, xlat_arg_parser_t const args[]) CC_HINT(nonnull);
 

diff --git a/src/lib/unlang/xlat_builtin.c b/src/lib/unlang/xlat_builtin.c
index 167ec2b741d7ce0d3fbf1ae41d29e12fbb5ad225..579cbdca03077bf0325099be0de85322d9533382 100644 (file)
--- a/src/lib/unlang/xlat_builtin.c
+++ b/src/lib/unlang/xlat_builtin.c
@@ -213,7 +213,6 @@ xlat_t *xlat_register_legacy(void *mod_inst, char const *name,
        c->mod_inst = mod_inst;
        c->instantiate = instantiate;
        c->inst_size = inst_size;
-       c->needs_async = false;
 
        DEBUG3("%s: %s", __FUNCTION__, c->name);
 
@@ -233,12 +232,12 @@ xlat_t *xlat_register_legacy(void *mod_inst, char const *name,
  * @param[in] ctx              Used to automate deregistration of the xlat fnction.
  * @param[in] name             of the xlat.
  * @param[in] func             to register.
- * @param[in] needs_async      Requires asynchronous evaluation.
+ * @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, bool needs_async)
+xlat_t *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, xlat_flags_t const *flags)
 {
        xlat_t  *c;
 
@@ -249,6 +248,8 @@ xlat_t *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, bool
                return NULL;
        }
 
+       if (!flags) flags = &(xlat_flags_t) { 0 };
+
        /*
         *      If it already exists, replace the instance.
         */
@@ -259,7 +260,7 @@ xlat_t *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, bool
                        return NULL;
                }
 
-               if ((c->type != XLAT_FUNC_NORMAL) || (c->needs_async != needs_async)) {
+               if ((c->type != XLAT_FUNC_NORMAL) || (c->flags.needs_async != flags->needs_async)) {
                        ERROR("%s: Cannot change async capability of %s", __FUNCTION__, name);
                        return NULL;
                }
@@ -282,7 +283,7 @@ xlat_t *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, bool
                        .async = func
                },
                .type = XLAT_FUNC_NORMAL,
-               .needs_async = needs_async,             /* this function may yield */
+               .flags = *flags,
                .input_type = XLAT_INPUT_UNPROCESSED    /* set default - will be overridden if args are registered */
        };
        talloc_set_destructor(c, _xlat_func_talloc_free);
@@ -294,6 +295,13 @@ xlat_t *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, bool
                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_async || !flags->pure);
+       fr_assert(!flags->needs_resolving);
+
        return c;
 }
 
@@ -452,6 +460,14 @@ void _xlat_async_thread_instantiate_set(xlat_t const *xlat,
 {
        xlat_t *c = UNCONST(xlat_t *, xlat);
 
+       /*
+        *      Pure functions can't use any thread-local
+        *      variables. They MUST operate only on constant
+        *      instantiation data, and on their (possibly constant)
+        *      inputs.
+        */
+       fr_assert(!c->flags.pure);
+
        c->thread_instantiate = thread_instantiate;
        c->thread_inst_type = thread_inst_type;
        c->thread_inst_size = thread_inst_size;
@@ -750,7 +766,7 @@ int xlat_register_redundant(CONF_SECTION *cs)
         */
        if (!old) return 1;
 
-       xlat = xlat_register(NULL, name2, func, old->needs_async);
+       xlat = xlat_register(NULL, name2, func, &old->flags);
        if (!xlat) {
                ERROR("Registering xlat for load-balance section failed");
                talloc_free(xr);
@@ -3242,7 +3258,7 @@ 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, false);
+               xlat = xlat_register(NULL, buffer, protocol_decode_xlat, NULL);
                xlat_func_args(xlat, protocol_decode_xlat_args);
                xlat_async_instantiate_set(xlat, protocol_xlat_instantiate, fr_test_point_pair_decode_t *, NULL, tp_decode);
        }
@@ -3255,7 +3271,7 @@ 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, false);
+               xlat = xlat_register(NULL, buffer, protocol_encode_xlat, NULL);
                xlat_func_args(xlat, protocol_encode_xlat_args);
                xlat_async_instantiate_set(xlat, protocol_xlat_instantiate, fr_test_point_pair_encode_t *, NULL, tp_encode);
        }
@@ -3328,7 +3344,7 @@ int xlat_init(void)
 
 #define XLAT_REGISTER_ARGS(_xlat, _func, _args) \
 do { \
-       if (!(xlat = xlat_register(NULL, _xlat, _func, false))) return -1; \
+       if (!(xlat = xlat_register(NULL, _xlat, _func, NULL))) return -1; \
        xlat_func_args(xlat, _args); \
 } while (0)
 
@@ -3349,7 +3365,7 @@ do { \
 
 #define XLAT_REGISTER_MONO(_xlat, _func, _arg) \
 do { \
-       if (!(xlat = xlat_register(NULL, _xlat, _func, false))) return -1; \
+       if (!(xlat = xlat_register(NULL, _xlat, _func, NULL))) return -1; \
        xlat_func_mono(xlat, &_arg); \
 } while (0)
 
@@ -3360,12 +3376,12 @@ do { \
        XLAT_REGISTER_MONO("map", xlat_func_map, xlat_func_map_arg);
        XLAT_REGISTER_MONO("md4", xlat_func_md4, xlat_func_md4_arg);
        XLAT_REGISTER_MONO("md5", xlat_func_md5, xlat_func_md5_arg);
-       xlat_register(NULL, "module", xlat_func_module, false);
+       xlat_register(NULL, "module", xlat_func_module, NULL);
        XLAT_REGISTER_MONO("pack", xlat_func_pack, xlat_func_pack_arg);
        XLAT_REGISTER_MONO("rand", xlat_func_rand, xlat_func_rand_arg);
        XLAT_REGISTER_MONO("randstr", xlat_func_randstr, xlat_func_randstr_arg);
 #if defined(HAVE_REGEX_PCRE) || defined(HAVE_REGEX_PCRE2)
-       xlat_register(NULL, "regex", xlat_func_regex, false);
+       xlat_register(NULL, "regex", xlat_func_regex, NULL);
 #endif
        XLAT_REGISTER_MONO("sha1", xlat_func_sha1, xlat_func_sha_arg);
 

diff --git a/src/lib/unlang/xlat_priv.h b/src/lib/unlang/xlat_priv.h
index 743be8c92e5e94c1febde4dc583270616ea3a396..b0447cb72a53fce98af933c1bc4adbc65e173055 100644 (file)
--- a/src/lib/unlang/xlat_priv.h
+++ b/src/lib/unlang/xlat_priv.h
@@ -69,7 +69,7 @@ typedef struct xlat_s {
        size_t                  thread_inst_size;       //!< Size of the thread instance data to pre-allocate.
        void                    *thread_uctx;           //!< uctx to pass to instantiation functions.
 
-       bool                    needs_async;            //!< If true, then it requires async operation
+       xlat_flags_t            flags;                  //!< various flags
 
        size_t                  buf_len;                //!< Length of output buffer to pre-allocate.
        void                    *mod_inst;              //!< Module instance passed to xlat

diff --git a/src/lib/unlang/xlat_tokenize.c b/src/lib/unlang/xlat_tokenize.c
index ff2ab693af8d0ff211c35fe213a02069a0d40562..6e881bc944a4e7d2f43e59e7164ddec445652539 100644 (file)
--- a/src/lib/unlang/xlat_tokenize.c
+++ b/src/lib/unlang/xlat_tokenize.c
@@ -425,7 +425,7 @@ static inline int xlat_tokenize_function_mono(TALLOC_CTX *ctx, xlat_exp_t **head
                        return -1;
                }
                node->call.func = func;
-               node->flags.needs_async = func->needs_async;
+               node->flags = func->flags;
        }
 
        fr_sbuff_next(in);                      /* Skip the ':' */
@@ -552,7 +552,7 @@ static inline int xlat_tokenize_function_args(TALLOC_CTX *ctx, xlat_exp_t **head
                        return -1;
                }
                node->call.func = func;
-               node->flags.needs_async = func->needs_async;
+               node->flags = func->flags;
        }
 
        fr_sbuff_next(in);                      /* Skip the ':' */
@@ -602,7 +602,7 @@ static int xlat_resolve_virtual_attribute(xlat_exp_t *node, tmpl_t *vpt)
        XLAT_DEBUG("VIRTUAL <-- %pV",
                   fr_box_strvalue_len(vpt->name, vpt->len));
        node->call.func = func;
-       node->flags.needs_async = func->needs_async;
+       node->flags = func->flags;
 
        return 0;
 }
@@ -1712,7 +1712,7 @@ int xlat_resolve(xlat_exp_t **head, xlat_flags_t *flags, xlat_res_rules_t const
                        /*
                         *      Reset node flags
                         */
-                       node->flags = (xlat_flags_t){ .needs_async = func->needs_async };
+                       node->flags = func->flags;
 
                        /*
                         *      Merge the result of trying to resolve
@@ -1862,8 +1862,9 @@ int xlat_from_tmpl_attr(TALLOC_CTX *ctx, xlat_exp_t **head, xlat_flags_t *flags,
                        node = xlat_exp_alloc(ctx, XLAT_VIRTUAL, vpt->name, vpt->len);
                        node->attr = talloc_move(node, vpt_p);
                        node->call.func = func;
+                       node->flags = func->flags;
+
                        *head = node;
-                       node->flags = (xlat_flags_t) { .needs_async = func->needs_async };
                } else if (tmpl_is_attr_unresolved(vpt)) {
                        func = xlat_func_find(tmpl_attr_unresolved(vpt), -1);
                        if (!func) goto unresolved;

diff --git a/src/modules/rlm_always/rlm_always.c b/src/modules/rlm_always/rlm_always.c
index fd7b0460d97f6042d3124687adb697b9bdc7a921..0d6c75136bfeb824db071bffc249d25642844a51 100644 (file)
--- a/src/modules/rlm_always/rlm_always.c
+++ b/src/modules/rlm_always/rlm_always.c
@@ -133,7 +133,7 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
                return -1;
        }
 
-       xlat = xlat_register(inst, mctx->inst->name, always_xlat, false);
+       xlat = xlat_register(inst, mctx->inst->name, always_xlat, NULL);
        xlat_func_args(xlat, always_xlat_args);
        xlat_async_instantiate_set(xlat, always_xlat_instantiate, rlm_always_t *, NULL, inst);
 

diff --git a/src/modules/rlm_cache/rlm_cache.c b/src/modules/rlm_cache/rlm_cache.c
index 551719136306c71f8602531448cf2c97bb02351b..63e991f8fb62d90f53220f382685b132aca20931 100644 (file)
--- a/src/modules/rlm_cache/rlm_cache.c
+++ b/src/modules/rlm_cache/rlm_cache.c
@@ -1008,7 +1008,7 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        /*
         *      Register the cache xlat function
         */
-       xlat = xlat_register(inst, mctx->inst->name, cache_xlat, true);
+       xlat = xlat_register(inst, mctx->inst->name, cache_xlat, XLAT_FLAG_NEEDS_ASYNC);
        xlat_func_args(xlat, cache_xlat_args);
        xlat_async_thread_instantiate_set(xlat, mod_xlat_thread_instantiate, cache_xlat_thread_inst_t, NULL, inst);
 

diff --git a/src/modules/rlm_chap/rlm_chap.c b/src/modules/rlm_chap/rlm_chap.c
index 7fb8be57f578a0d5df41ee3888a9af967c91dfcd..66199917db5ffb57aa29dff10ce6ad3460c2e018 100644 (file)
--- a/src/modules/rlm_chap/rlm_chap.c
+++ b/src/modules/rlm_chap/rlm_chap.c
@@ -293,7 +293,7 @@ static int mod_load(void)
 {
        xlat_t  *xlat;
 
-       xlat = xlat_register(NULL, "chap_password", xlat_func_chap_password, false);
+       xlat = xlat_register(NULL, "chap_password", xlat_func_chap_password, NULL);
        if (!xlat) return -1;
        xlat_func_args(xlat, xlat_func_chap_password_args);
 

diff --git a/src/modules/rlm_cipher/rlm_cipher.c b/src/modules/rlm_cipher/rlm_cipher.c
index ef24da4b6bf95fc9f044a9f0f53f52ccf8b2908d..2cc29a4949bab12dceba790d0f261be8f1264a10 100644 (file)
--- a/src/modules/rlm_cipher/rlm_cipher.c
+++ b/src/modules/rlm_cipher/rlm_cipher.c
@@ -1330,7 +1330,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(inst, xlat_name, cipher_rsa_decrypt_xlat, false);
+                       xlat = xlat_register(inst, xlat_name, cipher_rsa_decrypt_xlat, NULL);
                        xlat_func_mono(xlat, &cipher_rsa_decrypt_xlat_arg);
                        xlat_async_instantiate_set(xlat, cipher_xlat_instantiate,
                                                   rlm_cipher_t *,
@@ -1347,7 +1347,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(inst, xlat_name, cipher_rsa_verify_xlat, false);
+                       xlat = xlat_register(inst, xlat_name, cipher_rsa_verify_xlat, NULL);
                        xlat_func_args(xlat, cipher_rsa_verify_xlat_arg);
                        xlat_async_instantiate_set(xlat, cipher_xlat_instantiate,
                                                   rlm_cipher_t *,
@@ -1385,7 +1385,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(inst, xlat_name, cipher_rsa_encrypt_xlat, false);
+                       xlat = xlat_register(inst, xlat_name, cipher_rsa_encrypt_xlat, NULL);
                        xlat_func_mono(xlat, &cipher_rsa_encrypt_xlat_arg);
                        xlat_async_instantiate_set(xlat, cipher_xlat_instantiate,
                                                   rlm_cipher_t *,
@@ -1401,7 +1401,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(inst, xlat_name, cipher_rsa_sign_xlat, false);
+                       xlat = xlat_register(inst, xlat_name, cipher_rsa_sign_xlat, NULL);
                        xlat_func_mono(xlat, &cipher_rsa_sign_xlat_arg);
                        xlat_async_instantiate_set(xlat, cipher_xlat_instantiate,
                                                   rlm_cipher_t *,
@@ -1414,7 +1414,7 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
                        talloc_free(xlat_name);
 
                        xlat_name = talloc_asprintf(inst, "%s_certificate", mctx->inst->name);
-                       xlat = xlat_register(inst, xlat_name, cipher_certificate_xlat, false);
+                       xlat = xlat_register(inst, xlat_name, cipher_certificate_xlat, NULL);
                        xlat_func_args(xlat, cipher_certificate_xlat_args);
                        xlat_async_instantiate_set(xlat, cipher_xlat_instantiate,
                                                   rlm_cipher_t *,

diff --git a/src/modules/rlm_client/rlm_client.c b/src/modules/rlm_client/rlm_client.c
index 53b9260cf300069943aac8428f2c557bad34a6cf..9f3dafea6045105f2df7863dfee0c8b558ed0f79 100644 (file)
--- a/src/modules/rlm_client/rlm_client.c
+++ b/src/modules/rlm_client/rlm_client.c
@@ -365,7 +365,7 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
 
        if (cf_section_name2(conf)) return 0;
 
-       xlat = xlat_register(mctx->inst->data, "client", xlat_client, false);
+       xlat = xlat_register(mctx->inst->data, "client", xlat_client, NULL);
        xlat_func_args(xlat, xlat_client_args);
        map_proc_register(mctx->inst->data, "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 adaf24dfc8c56fecc266a38d6c1f9f9670646a5e..740f18a5120f4a4737c9001d598a7d5585ead6fe 100644 (file)
--- a/src/modules/rlm_date/rlm_date.c
+++ b/src/modules/rlm_date/rlm_date.c
@@ -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(inst, mctx->inst->name, xlat_date_convert, false);
+       xlat = xlat_register(inst, mctx->inst->name, xlat_date_convert, NULL);
        xlat_func_args(xlat,xlat_date_convert_args);
        xlat_async_instantiate_set(xlat, mod_xlat_instantiate, rlm_date_t *, NULL, inst);
 

diff --git a/src/modules/rlm_delay/rlm_delay.c b/src/modules/rlm_delay/rlm_delay.c
index 6e0eab9d57ec728baefafb32420429f9e633d11d..e5b719c2268481d9049bdabe1a3cdd6cea171182 100644 (file)
--- a/src/modules/rlm_delay/rlm_delay.c
+++ b/src/modules/rlm_delay/rlm_delay.c
@@ -279,7 +279,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(inst, mctx->inst->name, xlat_delay, true);
+       xlat = xlat_register(inst, mctx->inst->name, xlat_delay, XLAT_FLAG_NEEDS_ASYNC);
        xlat_func_args(xlat, xlat_delay_args);
        xlat_async_instantiate_set(xlat, mod_xlat_instantiate, rlm_delay_t *, NULL, inst);
        return 0;

diff --git a/src/modules/rlm_dict/rlm_dict.c b/src/modules/rlm_dict/rlm_dict.c
index 2b1e6f1d1bac14344ca1891b8d01797aedb25e3e..0399846d228731a100fb85ea1641aa7c35736b9f 100644 (file)
--- a/src/modules/rlm_dict/rlm_dict.c
+++ b/src/modules/rlm_dict/rlm_dict.c
@@ -236,17 +236,17 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
         */
        if (cf_section_name2(mctx->inst->conf) != NULL) return 0;
 
-       xlat = xlat_register(inst, "attr_by_num", xlat_dict_attr_by_num, false);
+       xlat = xlat_register(inst, "attr_by_num", xlat_dict_attr_by_num, NULL);
        xlat_func_args(xlat, xlat_dict_attr_by_num_args);
-       xlat = xlat_register(inst, "attr_by_oid", xlat_dict_attr_by_oid, false);
+       xlat = xlat_register(inst, "attr_by_oid", xlat_dict_attr_by_oid, NULL);
        xlat_func_args(xlat, xlat_dict_attr_by_oid_args);
-       xlat = xlat_register(inst, "vendor", xlat_vendor, false);
+       xlat = xlat_register(inst, "vendor", xlat_vendor, NULL);
        xlat_func_args(xlat, xlat_vendor_args);
-       xlat = xlat_register(inst, "vendor_num", xlat_vendor_num, false);
+       xlat = xlat_register(inst, "vendor_num", xlat_vendor_num, NULL);
        xlat_func_args(xlat, xlat_vendor_num_args);
-       xlat = xlat_register(inst, "attr", xlat_attr, false);
+       xlat = xlat_register(inst, "attr", xlat_attr, NULL);
        xlat_func_args(xlat, xlat_attr_args);
-       xlat = xlat_register(inst, "attr_num", xlat_attr_num, false);
+       xlat = xlat_register(inst, "attr_num", xlat_attr_num, NULL);
        xlat_func_args(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 3379a6ce23df943d42f994fa9f2c365ba52cdd13..c9dfcc6221a8e1afc516209deb42d1ec7d53269a 100644 (file)
--- a/src/modules/rlm_escape/rlm_escape.c
+++ b/src/modules/rlm_escape/rlm_escape.c
@@ -199,11 +199,11 @@ 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(NULL, mctx->inst->name, escape_xlat, false);
+       xlat = xlat_register(NULL, mctx->inst->name, escape_xlat, NULL);
        xlat_func_mono(xlat, &escape_xlat_arg);
        xlat_async_instantiate_set(xlat, mod_xlat_instantiate, rlm_escape_t *, NULL, inst);
 
-       xlat = xlat_register(NULL, unescape, unescape_xlat, false);
+       xlat = xlat_register(NULL, unescape, unescape_xlat, NULL);
        xlat_func_mono(xlat, &unescape_xlat_arg);
        talloc_free(unescape);
 

diff --git a/src/modules/rlm_exec/rlm_exec.c b/src/modules/rlm_exec/rlm_exec.c
index 4a1420d50eee58738d776d9f298b9f4aad2aeccc..7839518cf362f61f35949792acaa543919fccdbf 100644 (file)
--- a/src/modules/rlm_exec/rlm_exec.c
+++ b/src/modules/rlm_exec/rlm_exec.c
@@ -170,7 +170,7 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        xlat_t          *xlat;
        char const      *p;
 
-       xlat = xlat_register(NULL, mctx->inst->name, exec_xlat, true);
+       xlat = xlat_register(NULL, mctx->inst->name, exec_xlat, XLAT_FLAG_NEEDS_ASYNC);
        xlat_func_args(xlat, exec_xlat_args);
        xlat_async_instantiate_set(xlat, mod_xlat_instantiate, rlm_exec_t *, NULL, inst);
 

diff --git a/src/modules/rlm_expr/rlm_expr.c b/src/modules/rlm_expr/rlm_expr.c
index a3fb60ae6f4266471254cb58994d6103f68572d2..aedf639eed298f6ef83f8358f9017dbe5e36d40d 100644 (file)
--- a/src/modules/rlm_expr/rlm_expr.c
+++ b/src/modules/rlm_expr/rlm_expr.c
@@ -602,7 +602,7 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
 {
        xlat_t          *xlat;
 
-       xlat = xlat_register(mctx->inst->data, mctx->inst->name, expr_xlat, false);
+       xlat = xlat_register(mctx->inst->data, mctx->inst->name, expr_xlat, NULL);
        xlat_func_mono(xlat, &expr_xlat_arg);
 
        return 0;

diff --git a/src/modules/rlm_icmp/rlm_icmp.c b/src/modules/rlm_icmp/rlm_icmp.c
index d57710ae53549e487392f35cdd045dcc72bec3fe..7ef7876550f81964641ff346ad3f07c377799074 100644 (file)
--- a/src/modules/rlm_icmp/rlm_icmp.c
+++ b/src/modules/rlm_icmp/rlm_icmp.c
@@ -541,7 +541,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(inst, mctx->inst->name, xlat_icmp, true);
+       xlat = xlat_register(inst, mctx->inst->name, xlat_icmp, XLAT_FLAG_NEEDS_ASYNC);
        xlat_func_args(xlat, xlat_icmp_args);
        xlat_async_instantiate_set(xlat, mod_xlat_instantiate, rlm_icmp_t *, NULL, inst);
        xlat_async_thread_instantiate_set(xlat, mod_xlat_thread_instantiate, xlat_icmp_thread_inst_t, NULL, inst);

diff --git a/src/modules/rlm_idn/rlm_idn.c b/src/modules/rlm_idn/rlm_idn.c
index dca0b56f83d9cd7db0b7993d3462f0b09d749250..738e832e1220ca01ebf7354e837cfe0b45f16aae 100644 (file)
--- a/src/modules/rlm_idn/rlm_idn.c
+++ b/src/modules/rlm_idn/rlm_idn.c
@@ -160,7 +160,7 @@ 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(inst, mctx->inst->name, xlat_idna, false);
+       xlat = xlat_register(inst, mctx->inst->name, xlat_idna, NULL);
        xlat_func_mono(xlat, &xlat_idna_arg);
        xlat_async_instantiate_set(xlat, mod_xlat_instantiate, rlm_idn_t *, NULL, inst);
 

diff --git a/src/modules/rlm_json/rlm_json.c b/src/modules/rlm_json/rlm_json.c
index a97fdc0dd2dc4a3ceb952914a135e81f47d4fb65..eb1682587ffc021fdafefac5ff5e6a074ad6985f 100644 (file)
--- a/src/modules/rlm_json/rlm_json.c
+++ b/src/modules/rlm_json/rlm_json.c
@@ -557,13 +557,13 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        char                    *name;
        fr_json_format_t        *format = inst->format;
 
-       xlat = xlat_register(inst, "jsonquote", json_quote_xlat, false);
+       xlat = xlat_register(inst, "jsonquote", json_quote_xlat, NULL);
        if (xlat) xlat_func_mono(xlat, &json_quote_xlat_arg);
-       xlat = xlat_register(inst, "jpathvalidate", jpath_validate_xlat, false);
+       xlat = xlat_register(inst, "jpathvalidate", jpath_validate_xlat, NULL);
        if (xlat) xlat_func_mono(xlat, &jpath_validate_xlat_arg);
 
        name = talloc_asprintf(inst, "%s_encode", mctx->inst->name);
-       xlat = xlat_register(inst, name, json_encode_xlat, false);
+       xlat = xlat_register(inst, name, json_encode_xlat, NULL);
        xlat_func_mono(xlat, &json_encode_xlat_arg);
        xlat_async_instantiate_set(xlat, json_xlat_instantiate,
                                   rlm_json_t *, NULL, inst);

diff --git a/src/modules/rlm_ldap/rlm_ldap.c b/src/modules/rlm_ldap/rlm_ldap.c
index d633a06a2003c96194ebd986ade75019ede9c192..722975e40a6291bb0159f988409bfd46a80754ec 100644 (file)
--- a/src/modules/rlm_ldap/rlm_ldap.c
+++ b/src/modules/rlm_ldap/rlm_ldap.c
@@ -1876,13 +1876,13 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
                inst->cache_da = inst->group_da;        /* Default to the group_da */
        }
 
-       xlat = xlat_register(NULL, mctx->inst->name, ldap_xlat, false);
+       xlat = xlat_register(NULL, mctx->inst->name, ldap_xlat, NULL);
        xlat_func_mono(xlat, &ldap_xlat_arg);
        xlat_async_thread_instantiate_set(xlat, mod_xlat_thread_instantiate, ldap_xlat_thread_inst_t, NULL, inst);
 
-       xlat = xlat_register(NULL, "ldap_escape", ldap_escape_xlat, false);
+       xlat = xlat_register(NULL, "ldap_escape", ldap_escape_xlat, NULL);
        if (xlat) xlat_func_mono(xlat, &ldap_escape_xlat_arg);
-       xlat = xlat_register(NULL, "ldap_unescape", ldap_unescape_xlat, false);
+       xlat = xlat_register(NULL, "ldap_unescape", ldap_unescape_xlat, NULL);
        if (xlat) xlat_func_mono(xlat, &ldap_escape_xlat_arg);
 
        map_proc_register(inst, mctx->inst->name, mod_map_proc, ldap_map_verify, 0);

diff --git a/src/modules/rlm_mschap/rlm_mschap.c b/src/modules/rlm_mschap/rlm_mschap.c
index 1da95a5dbcd4bed127b9ed6a78106c50e1f31470..ee39f67915a068fccb1de68687f209f9e99c3ab3 100644 (file)
--- a/src/modules/rlm_mschap/rlm_mschap.c
+++ b/src/modules/rlm_mschap/rlm_mschap.c
@@ -2267,7 +2267,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(inst, mctx->inst->name, mschap_xlat, false);
+       xlat = xlat_register(inst, mctx->inst->name, mschap_xlat, NULL);
        xlat_func_args(xlat, mschap_xlat_args);
        xlat_async_instantiate_set(xlat, mod_xlat_instantiate, rlm_mschap_t *, NULL, inst);
 

diff --git a/src/modules/rlm_perl/rlm_perl.c b/src/modules/rlm_perl/rlm_perl.c
index d59d0c85798407da7fbf95ad422b3b503486680a..7653fd35cdf3c9b7e7fa558db4b7968eced8ce72 100644 (file)
--- a/src/modules/rlm_perl/rlm_perl.c
+++ b/src/modules/rlm_perl/rlm_perl.c
@@ -639,7 +639,7 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        rlm_perl_t      *inst = talloc_get_type_abort(mctx->inst->data, rlm_perl_t);
        xlat_t          *xlat;
 
-       xlat = xlat_register(NULL, mctx->inst->name, perl_xlat, false);
+       xlat = xlat_register(NULL, mctx->inst->name, perl_xlat, NULL);
        xlat_func_args(xlat, perl_xlat_args);
 
        xlat_async_instantiate_set(xlat, mod_xlat_instantiate, rlm_perl_xlat_t, NULL, inst);

diff --git a/src/modules/rlm_redis/rlm_redis.c b/src/modules/rlm_redis/rlm_redis.c
index 1b15081e4bca4f1fa6a3e6e41807830d588fcba9..1a8f98097a60b2ce5f1c8aea1d76e5912cc5f6df 100644 (file)
--- a/src/modules/rlm_redis/rlm_redis.c
+++ b/src/modules/rlm_redis/rlm_redis.c
@@ -465,7 +465,7 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        char            *name;
        xlat_t          *xlat;
 
-       xlat = xlat_register(inst, mctx->inst->name, redis_xlat, false);
+       xlat = xlat_register(inst, mctx->inst->name, redis_xlat, NULL);
        xlat_func_args(xlat, redis_args);
        xlat_async_instantiate_set(xlat, redis_xlat_instantiate, rlm_redis_t *, NULL, inst);
 
@@ -473,13 +473,13 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
         *      %(redis_node:<key>[ idx])
         */
        name = talloc_asprintf(NULL, "%s_node", mctx->inst->name);
-       xlat = xlat_register(inst, name, redis_node_xlat, false);
+       xlat = xlat_register(inst, name, redis_node_xlat, NULL);
        xlat_func_args(xlat, redis_node_xlat_args);
        xlat_async_instantiate_set(xlat, redis_xlat_instantiate, rlm_redis_t *, NULL, inst);
        talloc_free(name);
 
        name = talloc_asprintf(NULL, "%s_remap", mctx->inst->name);
-       xlat = xlat_register(inst, name, redis_remap_xlat, false);
+       xlat = xlat_register(inst, name, redis_remap_xlat, NULL);
        xlat_func_args(xlat, redis_remap_xlat_args);
        xlat_async_instantiate_set(xlat, redis_xlat_instantiate, rlm_redis_t *, NULL, inst);
        talloc_free(name);

diff --git a/src/modules/rlm_rest/rlm_rest.c b/src/modules/rlm_rest/rlm_rest.c
index 26d66825e3120223012918687ece293ef45c7007..a545b542d51a799b9c0c4d586d9db4298e6079b0 100644 (file)
--- a/src/modules/rlm_rest/rlm_rest.c
+++ b/src/modules/rlm_rest/rlm_rest.c
@@ -1209,7 +1209,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(inst, mctx->inst->name, rest_xlat, true);
+       xlat = xlat_register(inst, mctx->inst->name, rest_xlat, XLAT_FLAG_NEEDS_ASYNC);
        xlat_func_args(xlat, rest_xlat_args);
        xlat_async_thread_instantiate_set(xlat, mod_xlat_thread_instantiate, rest_xlat_thread_inst_t, NULL, inst);
 

diff --git a/src/modules/rlm_soh/rlm_soh.c b/src/modules/rlm_soh/rlm_soh.c
index 8377dd05c8bee2277d00d1c957d3f52e579cd67c..5254ff1c439bfc7f49aa8f4c2298f6fb3de7ff64 100644 (file)
--- a/src/modules/rlm_soh/rlm_soh.c
+++ b/src/modules/rlm_soh/rlm_soh.c
@@ -273,7 +273,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(inst, mctx->inst->name, soh_xlat, false);
+       xlat = xlat_register(inst, mctx->inst->name, soh_xlat, NULL);
        xlat_func_args(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 09145e2bed3fb8211906f460ab8ac1cc65007a4e..2bf437d6622e307778fa92aa1d43d3c33f235cca 100644 (file)
--- a/src/modules/rlm_sql/rlm_sql.c
+++ b/src/modules/rlm_sql/rlm_sql.c
@@ -1120,7 +1120,7 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        /*
         *      Register the SQL xlat function
         */
-       xlat = xlat_register(inst, inst->name, sql_xlat, false);
+       xlat = xlat_register(inst, inst->name, sql_xlat, NULL);
 
        /*
         *      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 dcd6089ec61dd8d955aa1f7313d050a3fe07c3e6..b89c1797b02f165f0937e6ccb66b901ebcc9b919 100644 (file)
--- a/src/modules/rlm_test/rlm_test.c
+++ b/src/modules/rlm_test/rlm_test.c
@@ -482,14 +482,14 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        }
 
        if (!cf_section_name2(mctx->inst->conf)) {
-               if (!(xlat = xlat_register(inst, "test_trigger", trigger_test_xlat, false))) return -1;
+               if (!(xlat = xlat_register(inst, "test_trigger", trigger_test_xlat, NULL))) return -1;
                xlat_func_args(xlat, trigger_test_xlat_args);
 
-               if (!(xlat = xlat_register(inst, "test", test_xlat, false))) return -1;
+               if (!(xlat = xlat_register(inst, "test", test_xlat, NULL))) return -1;
                xlat_func_args(xlat, test_xlat_args);
 
        } else {
-               if (!(xlat = xlat_register(inst, mctx->inst->name, test_xlat, false))) return -1;
+               if (!(xlat = xlat_register(inst, mctx->inst->name, test_xlat, NULL))) return -1;
                xlat_func_args(xlat, test_xlat_args);
        }
 

diff --git a/src/modules/rlm_unbound/rlm_unbound.c b/src/modules/rlm_unbound/rlm_unbound.c
index bc81125a7cfc4c79bdd3ebf6926822b49c65ae82..d5aa31fccc4f72b13ca149d51aa283d8de2dd3c9 100644 (file)
--- a/src/modules/rlm_unbound/rlm_unbound.c
+++ b/src/modules/rlm_unbound/rlm_unbound.c
@@ -500,7 +500,7 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
                return -1;
        }
 
-       if(!(xlat = xlat_register(NULL, mctx->inst->name, xlat_unbound, true))) return -1;
+       if(!(xlat = xlat_register(NULL, mctx->inst->name, xlat_unbound, XLAT_FLAG_NEEDS_ASYNC))) return -1;
        xlat_func_args(xlat, xlat_unbound_args);
        xlat_async_thread_instantiate_set(xlat, mod_xlat_thread_instantiate, unbound_xlat_thread_inst_t, NULL, inst);
 

diff --git a/src/modules/rlm_unpack/rlm_unpack.c b/src/modules/rlm_unpack/rlm_unpack.c
index ada5e205c9c21f23c324ee62c54953e8ed87bf06..13afbfbcd5fce0ab3a2c79b9b7dd5cdf0c45020b 100644 (file)
--- a/src/modules/rlm_unpack/rlm_unpack.c
+++ b/src/modules/rlm_unpack/rlm_unpack.c
@@ -149,7 +149,7 @@ static int mod_bootstrap(UNUSED module_inst_ctx_t const *mctx)
 {
        xlat_t  *xlat;
 
-       xlat = xlat_register(NULL, "unpack", unpack_xlat, false);
+       xlat = xlat_register(NULL, "unpack", unpack_xlat, NULL);
        if (xlat) xlat_func_args(xlat, unpack_xlat_args);
 
        return 0;

diff --git a/src/modules/rlm_yubikey/rlm_yubikey.c b/src/modules/rlm_yubikey/rlm_yubikey.c
index 5a7bbc590a5076844bb6aa668f6d8c3c7b7b0ac2..73028e0db931dc3b66b2507c7e35dc013b2c9137 100644 (file)
--- a/src/modules/rlm_yubikey/rlm_yubikey.c
+++ b/src/modules/rlm_yubikey/rlm_yubikey.c
@@ -195,7 +195,7 @@ static int mod_bootstrap(module_inst_ctx_t const *mctx)
        }
 #endif
 
-       xlat = xlat_register(inst, "modhextohex", modhex_to_hex_xlat, false);
+       xlat = xlat_register(inst, "modhextohex", modhex_to_hex_xlat, NULL);
        if (xlat) xlat_func_mono(xlat, &modhex_to_hex_xlat_arg);
 
        return 0;