Add seperate registration function for xlats tied to modules

diff --git a/src/lib/unlang/xlat.h b/src/lib/unlang/xlat.h
index c1a8ea9be5d6edc820aef3d2b97d93bd4ee534fb..a0d1845260414056548e3c3a58d753faef1652ac 100644 (file)
--- a/src/lib/unlang/xlat.h
+++ b/src/lib/unlang/xlat.h
@@ -381,6 +381,8 @@ 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_module(TALLOC_CTX *ctx, module_inst_ctx_t const *mctx,
+                                     char const *name, xlat_func_t func, xlat_flags_t const *flags);
 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 f6a00e80bb892e583f9d2ab9363f1e7506445eb0..1edeab6aec9db4e2598c739f59713ffbd40e6271 100644 (file)
--- a/src/lib/unlang/xlat_builtin.c
+++ b/src/lib/unlang/xlat_builtin.c
@@ -227,9 +227,11 @@ xlat_t *xlat_register_legacy(void *mod_inst, char const *name,
 }
 
 
-/** Register an xlat function
+/** Register an xlat function for a module
  *
  * @param[in] ctx              Used to automate deregistration of the xlat fnction.
+ * @param[in] mctx             Instantiation context from the module.
+ *                             Will be duplicated and passed to future xlat calls.
  * @param[in] name             of the xlat.
  * @param[in] func             to register.
  * @param[in] flags            various function flags
@@ -237,10 +239,12 @@ xlat_t *xlat_register_legacy(void *mod_inst, char const *name,
  *     - 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, xlat_flags_t const *flags)
+xlat_t *xlat_register_module(TALLOC_CTX *ctx, module_inst_ctx_t const *mctx,
+                            char const *name, xlat_func_t func, xlat_flags_t const *flags)
 {
+       static const xlat_flags_t default_flags;
        xlat_t  *c;
-       static const xlat_flags_t my_flags = (xlat_flags_t) { 0 };
+       module_inst_ctx_t *our_mctx = NULL;
 
        if (!xlat_root) xlat_init();
 
@@ -249,7 +253,7 @@ xlat_t *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, xlat_
                return NULL;
        }
 
-       if (!flags) flags = &my_flags;
+       if (!flags) flags = &default_flags;
 
        /*
         *      If it already exists, replace the instance.
@@ -278,11 +282,16 @@ xlat_t *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, xlat_
         *      Doesn't exist.  Create it.
         */
        MEM(c = talloc(ctx, xlat_t));
+       if (mctx) {
+               MEM(our_mctx = talloc_zero(c, module_inst_ctx_t));      /* Original won't stick around */
+               memcpy(our_mctx, mctx, sizeof(*our_mctx));
+       }
        *c = (xlat_t){
                .name = talloc_typed_strdup(c, name),
                .func = {
                        .async = func
                },
+               .mctx = our_mctx,
                .type = XLAT_FUNC_NORMAL,
                .flags = *flags,
                .input_type = XLAT_INPUT_UNPROCESSED    /* set default - will be overridden if args are registered */
@@ -306,6 +315,20 @@ xlat_t *xlat_register(TALLOC_CTX *ctx, char const *name, xlat_func_t func, xlat_
        return c;
 }
 
+/** Register an xlat function
+ *
+ * @param[in] ctx              Used to automate deregistration of the xlat fnction.
+ * @param[in] name             of the xlat.
+ * @param[in] func             to register.
+ * @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, xlat_flags_t const *flags)
+{
+       return xlat_register_module(ctx, NULL, name, func, flags);
+}
 
 /** Verify xlat arg specifications are valid
  *

diff --git a/src/lib/unlang/xlat_priv.h b/src/lib/unlang/xlat_priv.h
index bd0dd408b493f2d455a97108c614e492ecbc3551..7b99208a06eec391cb98f2039bf94ecf99c55ec3 100644 (file)
--- a/src/lib/unlang/xlat_priv.h
+++ b/src/lib/unlang/xlat_priv.h
@@ -56,6 +56,9 @@ typedef struct xlat_s {
 
        bool                    internal;               //!< If true, cannot be redefined.
 
+       module_inst_ctx_t const *mctx;                  //!< Original module instantiation ctx if this
+                                                       ///< xlat was registered by a module.
+
        xlat_instantiate_t      instantiate;            //!< Instantiation function.
        xlat_detach_t           detach;                 //!< Destructor for when xlat instances are freed.
        char const              *inst_type;             //!< C type of instance structure.

diff --git a/src/modules/rlm_always/rlm_always.c b/src/modules/rlm_always/rlm_always.c
index 0d6c75136bfeb824db071bffc249d25642844a51..a819074b8a46185ecc0a5c55ff60ba3fbe99cb90 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, NULL);
+       xlat = xlat_register_module(inst, mctx, 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 63e991f8fb62d90f53220f382685b132aca20931..0a7e221866ab389a0ce3f89ecef47bcaea516364 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, XLAT_FLAG_NEEDS_ASYNC);
+       xlat = xlat_register_module(inst, mctx, 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_cipher/rlm_cipher.c b/src/modules/rlm_cipher/rlm_cipher.c
index 2cc29a4949bab12dceba790d0f261be8f1264a10..4d8f5d409541385a047ca6ecb004bc5d5e14608d 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, NULL);
+                       xlat = xlat_register_module(inst, mctx, 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, NULL);
+                       xlat = xlat_register_module(inst, mctx, 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, NULL);
+                       xlat = xlat_register_module(inst, mctx, 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, NULL);
+                       xlat = xlat_register_module(inst, mctx, 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, NULL);
+                       xlat = xlat_register_module(inst, mctx, 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_date/rlm_date.c b/src/modules/rlm_date/rlm_date.c
index 543e673f1acfd5e5be75cc92ffdfd3546caaf530..e4fe6585447c15a032fa664a10d9af366e994cf9 100644 (file)
--- a/src/modules/rlm_date/rlm_date.c
+++ b/src/modules/rlm_date/rlm_date.c
@@ -235,9 +235,9 @@ 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, NULL);
-       xlat_func_args(xlat,xlat_date_convert_args);
+       xlat = xlat_register_module(inst, mctx, mctx->inst->name, xlat_date_convert, NULL);
        xlat_async_instantiate_set(xlat, mod_xlat_instantiate, rlm_date_t *, NULL, inst);
+       xlat_func_args(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 e5b719c2268481d9049bdabe1a3cdd6cea171182..06a20a1cbd744978679505ed927d799017143001 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, XLAT_FLAG_NEEDS_ASYNC);
+       xlat = xlat_register_module(inst, mctx, 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 0399846d228731a100fb85ea1641aa7c35736b9f..4a5a8cc5d688bb81cbeda2936903f2c299c6fb13 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, NULL);
+       xlat = xlat_register_module(inst, mctx, "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, NULL);
+       xlat = xlat_register_module(inst, mctx, "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, NULL);
+       xlat = xlat_register_module(inst, mctx, "vendor", xlat_vendor, NULL);
        xlat_func_args(xlat, xlat_vendor_args);
-       xlat = xlat_register(inst, "vendor_num", xlat_vendor_num, NULL);
+       xlat = xlat_register_module(inst, mctx, "vendor_num", xlat_vendor_num, NULL);
        xlat_func_args(xlat, xlat_vendor_num_args);
-       xlat = xlat_register(inst, "attr", xlat_attr, NULL);
+       xlat = xlat_register_module(inst, mctx, "attr", xlat_attr, NULL);
        xlat_func_args(xlat, xlat_attr_args);
-       xlat = xlat_register(inst, "attr_num", xlat_attr_num, NULL);
+       xlat = xlat_register_module(inst, mctx, "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 5badcb1f6346aab04c51f2c9e395f9b989e407c8..b480cd7fb97ec794f5f5b65a05509b3fd5eeeb75 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, XLAT_FLAG_PURE);
+       xlat = xlat_register_module(NULL, mctx, mctx->inst->name, escape_xlat, XLAT_FLAG_PURE);
        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, XLAT_FLAG_PURE);
+       xlat = xlat_register_module(NULL, mctx, unescape, unescape_xlat, XLAT_FLAG_PURE);
        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 7839518cf362f61f35949792acaa543919fccdbf..43d2c4c75c0292aeb7535d1685174f251554201f 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, XLAT_FLAG_NEEDS_ASYNC);
+       xlat = xlat_register_module(NULL, mctx, 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 aedf639eed298f6ef83f8358f9017dbe5e36d40d..42492eadbfa73b5d608ac8f3d3387c95c4e4b592 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, NULL);
+       xlat = xlat_register_module(mctx->inst->data, mctx, 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 7ef7876550f81964641ff346ad3f07c377799074..5b4f6149adc14fc9857b59dae0a49c1d22373693 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, XLAT_FLAG_NEEDS_ASYNC);
+       xlat = xlat_register_module(inst, mctx, 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 4e7cb45f73a8c4edd99bc1b27b84745ea7aa33c5..7d6b7308e8863892a5deae3f2f033e0ebf2b1263 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, XLAT_FLAG_PURE);
+       xlat = xlat_register_module(inst, mctx, mctx->inst->name, xlat_idna, XLAT_FLAG_PURE);
        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 eb1682587ffc021fdafefac5ff5e6a074ad6985f..77869a877de89b7676a9d689139bb5a1720c672b 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, NULL);
+       xlat = xlat_register_module(inst, mctx, "jsonquote", json_quote_xlat, NULL);
        if (xlat) xlat_func_mono(xlat, &json_quote_xlat_arg);
-       xlat = xlat_register(inst, "jpathvalidate", jpath_validate_xlat, NULL);
+       xlat = xlat_register_module(inst, mctx, "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, NULL);
+       xlat = xlat_register_module(inst, mctx, 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 e7e5abcec6efa17adacd10e941d8b4ad4215b7a5..f3f6ee6d28edbaaf2d690e18845c759f877546bb 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, NULL);
+       xlat = xlat_register_module(NULL, mctx, 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, XLAT_FLAG_PURE);
+       xlat = xlat_register_module(NULL, mctx, "ldap_escape", ldap_escape_xlat, XLAT_FLAG_PURE);
        if (xlat) xlat_func_mono(xlat, &ldap_escape_xlat_arg);
-       xlat = xlat_register(NULL, "ldap_unescape", ldap_unescape_xlat, XLAT_FLAG_PURE);
+       xlat = xlat_register_module(NULL, mctx, "ldap_unescape", ldap_unescape_xlat, XLAT_FLAG_PURE);
        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 ee39f67915a068fccb1de68687f209f9e99c3ab3..43b19687812a04c67628683293821166d03a2e64 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, NULL);
+       xlat = xlat_register_module(inst, mctx, 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 7653fd35cdf3c9b7e7fa558db4b7968eced8ce72..27534698e607c5c9f14d748d8771531a0ac31142 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, NULL);
+       xlat = xlat_register_module(NULL, mctx, 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 1a8f98097a60b2ce5f1c8aea1d76e5912cc5f6df..3c0c0fcdb2f10d1958dab34d0e6294b6c672d6f9 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, NULL);
+       xlat = xlat_register_module(inst, mctx, 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, NULL);
+       xlat = xlat_register_module(inst, mctx, 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, NULL);
+       xlat = xlat_register_module(inst, mctx, 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 a545b542d51a799b9c0c4d586d9db4298e6079b0..ceb5e07ac09cce0b04eb6cd4a1360512e57e298f 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, XLAT_FLAG_NEEDS_ASYNC);
+       xlat = xlat_register_module(inst, mctx, 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 5254ff1c439bfc7f49aa8f4c2298f6fb3de7ff64..5c88dadad17170ee2b86e9959c1c7310c2688ed2 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, NULL);
+       xlat = xlat_register_module(inst, mctx, 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 2bf437d6622e307778fa92aa1d43d3c33f235cca..f5c7416f9afdaaff25588b2bf1943961ef65b992 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, NULL);
+       xlat = xlat_register_module(inst, mctx, 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 b89c1797b02f165f0937e6ccb66b901ebcc9b919..a3b48dc2af5f3b70add9c163a467f2f1a98c6d8a 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, NULL))) return -1;
+               if (!(xlat = xlat_register_module(inst, mctx, "test_trigger", trigger_test_xlat, NULL))) return -1;
                xlat_func_args(xlat, trigger_test_xlat_args);
 
-               if (!(xlat = xlat_register(inst, "test", test_xlat, NULL))) return -1;
+               if (!(xlat = xlat_register_module(inst, mctx, "test", test_xlat, NULL))) return -1;
                xlat_func_args(xlat, test_xlat_args);
 
        } else {
-               if (!(xlat = xlat_register(inst, mctx->inst->name, test_xlat, NULL))) return -1;
+               if (!(xlat = xlat_register_module(inst, mctx, 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 d5aa31fccc4f72b13ca149d51aa283d8de2dd3c9..3e5a82001a2bb354bde31dc745c9e4612d28d504 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, XLAT_FLAG_NEEDS_ASYNC))) return -1;
+       if(!(xlat = xlat_register_module(NULL, mctx, 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 af50a33a49c9ee68106bcd3bd0a3b2d29245dc30..e7901a20ddf478fcf9c3468b00eac7f3b5e7d6aa 100644 (file)
--- a/src/modules/rlm_unpack/rlm_unpack.c
+++ b/src/modules/rlm_unpack/rlm_unpack.c
@@ -145,11 +145,11 @@ static xlat_action_t unpack_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out, request_t *
 /*
  *     Register the xlats
  */
-static int mod_bootstrap(UNUSED module_inst_ctx_t const *mctx)
+static int mod_bootstrap(module_inst_ctx_t const *mctx)
 {
        xlat_t  *xlat;
 
-       xlat = xlat_register(NULL, "unpack", unpack_xlat, XLAT_FLAG_PURE);
+       xlat = xlat_register_module(NULL, mctx, "unpack", unpack_xlat, XLAT_FLAG_PURE);
        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 5497586ce25f0c3e4f01d7675a240cd20625288d..2f6252f38360a924cbc1e302261a66f36b2d4566 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, XLAT_FLAG_PURE);
+       xlat = xlat_register_module(inst, mctx, "modhextohex", modhex_to_hex_xlat, XLAT_FLAG_PURE);
        if (xlat) xlat_func_mono(xlat, &modhex_to_hex_xlat_arg);
 
        return 0;