xlat: Add an internal flag for marking xlats as internal

diff --git a/src/lib/unlang/foreach.c b/src/lib/unlang/foreach.c
index 39ad19be8a9e42a2d9bdfb5a1d3643c030a94f05..743eb19038c716ed6eef0cf1882e8b362beef7af 100644 (file)
--- a/src/lib/unlang/foreach.c
+++ b/src/lib/unlang/foreach.c
@@ -278,8 +278,8 @@ void unlang_foreach_init(void)
                x = xlat_func_register(NULL, xlat_foreach_names[i],
                                  unlang_foreach_xlat, FR_TYPE_VOID);
                fr_assert(x);
+               xlat_func_flags_set(x, XLAT_FUNC_FLAG_INTERNAL);
                x->uctx = &xlat_foreach_inst[i];
-               xlat_internal(x);
        }
 
        unlang_register(UNLANG_TYPE_FOREACH,

diff --git a/src/lib/unlang/xlat_builtin.c b/src/lib/unlang/xlat_builtin.c
index 4f24950ab5fad637544f8e99b43926b2ef0b102c..65225f0508aa596753ff9c32c416b8590201292b 100644 (file)
--- a/src/lib/unlang/xlat_builtin.c
+++ b/src/lib/unlang/xlat_builtin.c
@@ -3191,12 +3191,11 @@ static int xlat_protocol_register(fr_dict_t const *dict)
        if (tp_decode) {
                snprintf(buffer, sizeof(buffer), "decode.%s", name);
 
-               xlat = xlat_func_register(NULL, buffer, protocol_decode_xlat, FR_TYPE_UINT32);
-               if (!xlat) return -1;
+               if (unlikely((xlat = xlat_func_register(NULL, buffer, protocol_decode_xlat, FR_TYPE_UINT32)) == NULL)) return -1;
                xlat_func_args_set(xlat, protocol_decode_xlat_args);
                /* coverity[suspicious_sizeof] */
                xlat_func_async_instantiate_set(xlat, protocol_xlat_instantiate, fr_test_point_pair_decode_t *, NULL, tp_decode);
-               xlat_internal(xlat);
+               xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL);
        }
 
        /*
@@ -3207,12 +3206,11 @@ static int xlat_protocol_register(fr_dict_t const *dict)
        if (tp_encode) {
                snprintf(buffer, sizeof(buffer), "encode.%s", name);
 
-               xlat = xlat_func_register(NULL, buffer, protocol_encode_xlat, FR_TYPE_OCTETS);
-               if (!xlat) return -1;
+               if (unlikely((xlat = xlat_func_register(NULL, buffer, protocol_encode_xlat, FR_TYPE_OCTETS)) == NULL)) return -1;
                xlat_func_args_set(xlat, protocol_encode_xlat_args);
                /* coverity[suspicious_sizeof] */
                xlat_func_async_instantiate_set(xlat, protocol_xlat_instantiate, fr_test_point_pair_encode_t *, NULL, tp_encode);
-               xlat_internal(xlat);
+               xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL);
        }
 
        return 0;
@@ -3274,10 +3272,9 @@ int xlat_init(void)
         */
 #define XLAT_REGISTER_ARGS(_xlat, _func, _return_type, _args) \
 do { \
-       if (!(xlat = xlat_func_register(NULL, _xlat, _func, _return_type))) return -1; \
+       if (unlikely((xlat = xlat_func_register(NULL, _xlat, _func, _return_type)) == NULL)) return -1; \
        xlat_func_args_set(xlat, _args); \
-       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE); \
-       xlat_internal(xlat); \
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL); \
 } while (0)
 
        XLAT_REGISTER_ARGS("cast", xlat_func_cast, FR_TYPE_VOID, xlat_func_cast_args);
@@ -3298,9 +3295,9 @@ do { \
 #undef XLAT_REGISTER_ARGS
 #define XLAT_REGISTER_ARGS(_xlat, _func, _return_type, _args) \
 do { \
-       if (!(xlat = xlat_func_register(NULL, _xlat, _func, _return_type))) return -1; \
+       if (unlikely((xlat = xlat_func_register(NULL, _xlat, _func, _return_type)) == NULL)) return -1; \
        xlat_func_args_set(xlat, _args); \
-       xlat_internal(xlat); \
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL); \
 } while (0)
 
        XLAT_REGISTER_ARGS("debug", xlat_func_debug, FR_TYPE_INT8, xlat_func_debug_args);
@@ -3317,20 +3314,20 @@ do { \
        XLAT_REGISTER_ARGS("flatten", xlat_func_flatten, FR_TYPE_NULL, xlat_func_debug_attr_args); /* takes an attribute reference */
        XLAT_REGISTER_ARGS("unflatten", xlat_func_unflatten, FR_TYPE_NULL, xlat_func_debug_attr_args); /* takes an attribute reference */
 
-       xlat = xlat_func_register(NULL, "untaint", xlat_func_untaint, FR_TYPE_VOID);
-       xlat_internal(xlat);
-       xlat = xlat_func_register(NULL, "taint", xlat_func_taint, FR_TYPE_VOID);
-       xlat_internal(xlat);
+       if (unlikely((xlat = xlat_func_register(NULL, "untaint", xlat_func_untaint, FR_TYPE_VOID)) == NULL)) return -1;
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL);
+
+       if (unlikely((xlat = xlat_func_register(NULL, "taint", xlat_func_taint, FR_TYPE_VOID)) == NULL)) return -1;
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL);
 
        /*
         *      All of these functions are pure.
         */
 #define XLAT_REGISTER_MONO(_xlat, _func, _return_type, _arg) \
 do { \
-       if (!(xlat = xlat_func_register(NULL, _xlat, _func, _return_type))) return -1; \
+       if (unlikely((xlat = xlat_func_register(NULL, _xlat, _func, _return_type)) == NULL)) return -1; \
        xlat_func_mono_set(xlat, _arg); \
-       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE); \
-       xlat_internal(xlat); \
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL); \
 } while (0)
 
        XLAT_REGISTER_MONO("base64", xlat_func_base64_encode, FR_TYPE_STRING, xlat_func_base64_encode_arg);
@@ -3342,8 +3339,8 @@ do { \
        XLAT_REGISTER_MONO("md5", xlat_func_md5, FR_TYPE_OCTETS, xlat_func_md5_arg);
        XLAT_REGISTER_MONO("pack", xlat_func_pack, FR_TYPE_OCTETS, xlat_func_pack_arg);
 #if defined(HAVE_REGEX_PCRE) || defined(HAVE_REGEX_PCRE2)
-       xlat = xlat_func_register(NULL, "regex", xlat_func_regex, FR_TYPE_STRING);
-       xlat_internal(xlat);
+       if (unlikely((xlat = xlat_func_register(NULL, "regex", xlat_func_regex, FR_TYPE_STRING)) == NULL)) return -1;
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL);
 #endif
        XLAT_REGISTER_MONO("sha1", xlat_func_sha1, FR_TYPE_OCTETS, xlat_func_sha_arg);
 
@@ -3376,16 +3373,16 @@ do { \
 #undef XLAT_REGISTER_MONO
 #define XLAT_REGISTER_MONO(_xlat, _func, _return_type, _arg) \
 do { \
-       if (!(xlat = xlat_func_register(NULL, _xlat, _func, _return_type))) return -1; \
+       if (unlikely((xlat = xlat_func_register(NULL, _xlat, _func, _return_type)) == NULL)) return -1; \
        xlat_func_mono_set(xlat, _arg); \
-       xlat_internal(xlat); \
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL); \
 } while (0)
 
        XLAT_REGISTER_MONO("rand", xlat_func_rand, FR_TYPE_UINT64, xlat_func_rand_arg);
        XLAT_REGISTER_MONO("randstr", xlat_func_randstr, FR_TYPE_STRING, xlat_func_randstr_arg);
 
        xlat = xlat_func_register(NULL, "module", xlat_func_module, FR_TYPE_STRING);
-       xlat_internal(xlat);
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL);
 
        return xlat_register_expressions();
 }

diff --git a/src/lib/unlang/xlat_expr.c b/src/lib/unlang/xlat_expr.c
index 4b8b0531a5f0e5dc32e0366f64b2480f5e94eb24..0a78c4845ef1c057f362e08e92d471d8ecb15b81 100644 (file)
--- a/src/lib/unlang/xlat_expr.c
+++ b/src/lib/unlang/xlat_expr.c
@@ -1629,8 +1629,7 @@ static xlat_action_t xlat_func_exists(TALLOC_CTX *ctx, fr_dcursor_t *out,
 do { \
        if (!(xlat = xlat_func_register(NULL, "op_" STRINGIFY(_name), xlat_func_op_ ## _name, FR_TYPE_VOID))) return -1; \
        xlat_func_args_set(xlat, binary_op_xlat_args); \
-       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE); \
-       xlat_internal(xlat); \
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL); \
        xlat_print_set(xlat, xlat_expr_print_binary); \
        xlat_func_async_instantiate_set(xlat, xlat_function_args_to_tmpl, NULL, NULL, NULL); \
        xlat->token = _op; \
@@ -1641,8 +1640,7 @@ do { \
 do { \
        if (!(xlat = xlat_func_register(NULL, "cmp_" STRINGIFY(_name), xlat_func_cmp_ ## _name, FR_TYPE_VOID))) return -1; \
        xlat_func_args_set(xlat, binary_op_xlat_args); \
-       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE); \
-       xlat_internal(xlat); \
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL); \
        xlat_print_set(xlat, xlat_expr_print_binary); \
        xlat_resolve_set(xlat, xlat_expr_resolve_binary); \
        xlat->token = _op; \
@@ -1653,8 +1651,7 @@ do { \
 do { \
        if (!(xlat = xlat_func_register(NULL, STRINGIFY(_name), xlat_func_ ## _func_name, FR_TYPE_VOID))) return -1; \
        xlat_func_async_instantiate_set(xlat, xlat_instantiate_ ## _func_name, xlat_ ## _func_name ## _inst_t, NULL, NULL); \
-       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE); \
-       xlat_internal(xlat); \
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL); \
        xlat_print_set(xlat, xlat_expr_print_ ## _func_name); \
        xlat_purify_set(xlat, xlat_expr_logical_purify); \
        xlat->token = _op; \
@@ -1665,10 +1662,9 @@ do { \
 do { \
        if (!(xlat = xlat_func_register(NULL, STRINGIFY(_name), xlat_func_ ## _name, FR_TYPE_VOID))) return -1; \
        xlat_func_args_set(xlat, regex_op_xlat_args); \
-       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE); \
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL); \
        xlat_func_async_instantiate_set(xlat, xlat_instantiate_regex, xlat_regex_inst_t, NULL, NULL); \
        xlat_print_set(xlat, xlat_expr_print_regex); \
-       xlat_internal(xlat); \
        xlat->token = _op; \
 } while (0)
 
@@ -1676,15 +1672,14 @@ do { \
 do { \
        if (!(xlat = xlat_func_register(NULL, _xlat, _func, FR_TYPE_VOID))) return -1; \
        xlat_func_mono_set(xlat, _arg); \
-       xlat_internal(xlat); \
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL); \
 } while (0)
 
 #define XLAT_REGISTER_UNARY(_op, _xlat, _func) \
 do { \
        if (!(xlat = xlat_func_register(NULL, _xlat, _func, FR_TYPE_VOID))) return -1; \
        xlat_func_args_set(xlat, unary_op_xlat_args); \
-       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE); \
-       xlat_internal(xlat); \
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL); \
        xlat_print_set(xlat, xlat_expr_print_unary); \
        xlat->token = _op; \
 } while (0)
@@ -1744,7 +1739,7 @@ int xlat_register_expressions(void)
         */
        if (!(xlat = xlat_func_register(NULL, "paircmp", xlat_paircmp_func, FR_TYPE_VOID))) return -1; /* never pure! */
        xlat_func_args_set(xlat, xlat_paircmp_xlat_args);
-       xlat_internal(xlat);
+       xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL);
 
        return 0;
 }

diff --git a/src/lib/unlang/xlat_func.c b/src/lib/unlang/xlat_func.c
index 38a5fadba39a2d932559e49b16d1ee16f891aa0c..bee545a0475e8dc1b5f5db72513daddb1bff2a82 100644 (file)
--- a/src/lib/unlang/xlat_func.c
+++ b/src/lib/unlang/xlat_func.c
@@ -342,6 +342,7 @@ int xlat_func_mono_set(xlat_t *x, xlat_arg_parser_t const args[])
 void xlat_func_flags_set(xlat_t *x, xlat_func_flags_t flags)
 {
        x->flags.pure = flags & XLAT_FUNC_FLAG_PURE;
+       x->internal = flags & XLAT_FUNC_FLAG_INTERNAL;
 }
 
 /** Set global instantiation/detach callbacks

diff --git a/src/lib/unlang/xlat_func.h b/src/lib/unlang/xlat_func.h
index ea61661276307379e96e00fc92b951c8b1a1f6f4..75faaab4a97c919150d32c82f528e6bfd1feb5a2 100644 (file)
--- a/src/lib/unlang/xlat_func.h
+++ b/src/lib/unlang/xlat_func.h
@@ -35,7 +35,8 @@ RCSIDH(xlat_register_h, "$Id$")
 DIAG_OFF(attributes)
 typedef enum CC_HINT(flag_enum) {
        XLAT_FUNC_FLAG_NONE = 0x00,
-       XLAT_FUNC_FLAG_PURE = 0x01
+       XLAT_FUNC_FLAG_PURE = 0x01,
+       XLAT_FUNC_FLAG_INTERNAL = 0x02
 } xlat_func_flags_t;
 DIAG_ON(attributes)
 

diff --git a/src/lib/unlang/xlat_priv.h b/src/lib/unlang/xlat_priv.h
index 053cf804b66a5ddc936ff1dd000911eb94989175..8e6883268519a22cc6265e0ed8b127935fd21e87 100644 (file)
--- a/src/lib/unlang/xlat_priv.h
+++ b/src/lib/unlang/xlat_priv.h
@@ -240,15 +240,6 @@ static inline xlat_exp_t *xlat_exp_next(xlat_exp_head_t const *head, xlat_exp_t
        return fr_dlist_next(&head->dlist, node);
 }
 
-/** Mark an xlat function as internal
- *
- * @param[in] xlat to mark as internal.
- */
-static inline void xlat_internal(xlat_t *xlat)
-{
-       xlat->internal = true;
-}
-
 /** Set a print routine for an xlat function.
  *
  * @param[in] xlat to set