From: Alan T. DeKok <aland@freeradius.org>
Date: Tue, 23 Nov 2021 17:30:36 +0000 (-0500)
Subject: pass xlat_flags_t to xlat_register()
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=23fd6017b6e843f1be6c0d38ae10d69050e7696a;p=thirdparty%2Ffreeradius-server.git

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 f11bdad7098..b6e332770f9 100644
--- 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 247f3a00710..af7fd3715a0 100644
--- 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 6fa282a5656..66d12523846 100644
--- 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 0b5706b4858..d10b80177e8 100644
--- 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 dc280a98c47..e2d3248743c 100644
--- 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 287a394f13b..fc77f4e56de 100644
--- 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 167ec2b741d..579cbdca030 100644
--- 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 743be8c92e5..b0447cb72a5 100644
--- 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 ff2ab693af8..6e881bc944a 100644
--- 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 fd7b0460d97..0d6c75136bf 100644
--- 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 55171913630..63e991f8fb6 100644
--- 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 7fb8be57f57..66199917db5 100644
--- 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 ef24da4b6bf..2cc29a4949b 100644
--- 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 53b9260cf30..9f3dafea604 100644
--- 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 adaf24dfc8c..740f18a5120 100644
--- 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 6e0eab9d57e..e5b719c2268 100644
--- 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 2b1e6f1d1ba..0399846d228 100644
--- 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 3379a6ce23d..c9dfcc6221a 100644
--- 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 4a1420d50ee..7839518cf36 100644
--- 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 a3fb60ae6f4..aedf639eed2 100644
--- 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 d57710ae535..7ef7876550f 100644
--- 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 dca0b56f83d..738e832e122 100644
--- 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 a97fdc0dd2d..eb1682587ff 100644
--- 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 d633a06a200..722975e40a6 100644
--- 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 1da95a5dbcd..ee39f67915a 100644
--- 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 d59d0c85798..7653fd35cdf 100644
--- 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 1b15081e4bc..1a8f98097a6 100644
--- 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 26d66825e31..a545b542d51 100644
--- 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 8377dd05c8b..5254ff1c439 100644
--- 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 09145e2bed3..2bf437d6622 100644
--- 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 dcd6089ec61..b89c1797b02 100644
--- 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 bc81125a7cf..d5aa31fccc4 100644
--- 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 ada5e205c9c..13afbfbcd5f 100644
--- 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 5a7bbc590a5..73028e0db93 100644
--- 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;