xlat: Always check registration rcode to keep coverity quiet

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

diff --git a/src/lib/eap_aka_sim/xlat.c b/src/lib/eap_aka_sim/xlat.c
index 30ecdf2da71269ea5b43d2ee6ef0dd6b086ce6dd..7b39271b2cd629109427042311ef01a87edce1f3 100644 (file)
--- a/src/lib/eap_aka_sim/xlat.c
+++ b/src/lib/eap_aka_sim/xlat.c
@@ -496,26 +496,28 @@ static xlat_action_t aka_sim_3gpp_temporary_id_encrypt_xlat(TALLOC_CTX *ctx, fr_
        return XLAT_ACTION_DONE;
 }
 
-void fr_aka_sim_xlat_func_register(void)
+int fr_aka_sim_xlat_func_register(void)
 {
        xlat_t  *xlat;
 
        if (aka_sim_xlat_refs) {
                aka_sim_xlat_refs++;
-               return;
+               return 0;
        }
 
-       xlat = xlat_func_register(NULL, "aka_sim_id_method", aka_sim_xlat_id_method_xlat, FR_TYPE_STRING);
+       if (unlikely((xlat = xlat_func_register(NULL, "aka_sim_id_method", aka_sim_xlat_id_method_xlat, FR_TYPE_STRING)) == NULL)) return -1;
        xlat_func_args_set(xlat, aka_sim_xlat_id_method_xlat_args);
-       xlat = xlat_func_register(NULL, "aka_sim_id_type", aka_sim_xlat_id_type_xlat, FR_TYPE_STRING);
+       if (unlikely((xlat = xlat_func_register(NULL, "aka_sim_id_type", aka_sim_xlat_id_type_xlat, FR_TYPE_STRING)) == NULL)) return -1;
        xlat_func_args_set(xlat, aka_sim_xlat_id_type_xlat_args);
-       xlat = xlat_func_register(NULL, "3gpp_temporary_id_key_index", aka_sim_id_3gpp_temporary_id_key_index_xlat, FR_TYPE_UINT8);
+       if (unlikely((xlat = xlat_func_register(NULL, "3gpp_temporary_id_key_index", aka_sim_id_3gpp_temporary_id_key_index_xlat, FR_TYPE_UINT8)) == NULL)) return -1;
        xlat_func_args_set(xlat, aka_sim_id_3gpp_temporary_id_key_index_xlat_args);
-       xlat = xlat_func_register(NULL, "3gpp_temporary_id_decrypt", aka_sim_3gpp_temporary_id_decrypt_xlat, FR_TYPE_STRING);
+       if (unlikely((xlat = xlat_func_register(NULL, "3gpp_temporary_id_decrypt", aka_sim_3gpp_temporary_id_decrypt_xlat, FR_TYPE_STRING)) == NULL)) return -1;
        xlat_func_args_set(xlat, aka_sim_3gpp_temporary_id_decrypt_xlat_args);
-       xlat = xlat_func_register(NULL, "3gpp_temporary_id_encrypt", aka_sim_3gpp_temporary_id_encrypt_xlat, FR_TYPE_STRING);
+       if (unlikely((xlat = xlat_func_register(NULL, "3gpp_temporary_id_encrypt", aka_sim_3gpp_temporary_id_encrypt_xlat, FR_TYPE_STRING)) == NULL)) return -1;
        xlat_func_args_set(xlat, aka_sim_3gpp_temporary_id_encrypt_xlat_args);
        aka_sim_xlat_refs = 1;
+
+       return 0;
 }
 
 void fr_aka_sim_xlat_func_unregister(void)

diff --git a/src/lib/server/main_config.c b/src/lib/server/main_config.c
index bd08a747f755782154657680dfaaa8bdadbaa938..e71bedd5bbce56908427c299ba76a449e117db00 100644 (file)
--- a/src/lib/server/main_config.c
+++ b/src/lib/server/main_config.c
@@ -1368,7 +1368,7 @@ do {\
        /*
         *      Register the %(config:section.subsection) xlat function.
         */
-       xlat = xlat_func_register(NULL, "config", xlat_config, FR_TYPE_STRING);
+       if (unlikely((xlat = xlat_func_register(NULL, "config", xlat_config, FR_TYPE_STRING)) == NULL)) goto failure;
        xlat_func_args_set(xlat, xlat_config_args);
        xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE);
 

diff --git a/src/lib/unlang/interpret.c b/src/lib/unlang/interpret.c
index 6dcd4a4437321c6f119bafc4cda50890b15a7c7c..ca9d9e3477598ecf336b5c2160cafcda19a5d58a 100644 (file)
--- a/src/lib/unlang/interpret.c
+++ b/src/lib/unlang/interpret.c
@@ -1641,16 +1641,18 @@ unlang_interpret_t *unlang_interpret_get_thread_default(void)
        return talloc_get_type_abort(intp_thread_default, unlang_interpret_t);
 }
 
-void unlang_interpret_init_global(void)
+int unlang_interpret_init_global(void)
 {
        xlat_t  *xlat;
        /*
         *  Should be void, but someone decided not to register multiple xlats
         *  breaking the convention we use everywhere else in the server...
         */
-       xlat = xlat_func_register(NULL, "interpreter", unlang_interpret_xlat, FR_TYPE_VOID);
+       if (unlikely((xlat = xlat_func_register(NULL, "interpreter", unlang_interpret_xlat, FR_TYPE_VOID)) == NULL)) return -1;
        xlat_func_args_set(xlat, unlang_interpret_xlat_args);
 
-       xlat = xlat_func_register(NULL, "cancel", unlang_cancel_xlat, FR_TYPE_VOID);
+       if (unlikely((xlat = xlat_func_register(NULL, "cancel", unlang_cancel_xlat, FR_TYPE_VOID)) == NULL)) return -1;
        xlat_func_args_set(xlat, unlang_cancel_xlat_args);
+
+       return 0;
 }

diff --git a/src/lib/unlang/interpret.h b/src/lib/unlang/interpret.h
index 558d96d846d5a8966319d01af77c43ac1eadaa48..ee57de2b3a75505ff7b539952eaa67f8c92be2a5 100644 (file)
--- a/src/lib/unlang/interpret.h
+++ b/src/lib/unlang/interpret.h
@@ -168,7 +168,7 @@ void                        unlang_interpret_stack_result_set(request_t *request, rlm_rcode_t code);
 
 TALLOC_CTX             *unlang_interpret_frame_talloc_ctx(request_t *request);
 
-void                   unlang_interpret_init_global(void);
+int                    unlang_interpret_init_global(void);
 #ifdef __cplusplus
 }
 #endif

diff --git a/src/lib/unlang/xlat_builtin.c b/src/lib/unlang/xlat_builtin.c
index 65225f0508aa596753ff9c32c416b8590201292b..08e104badc4e3c472ceb2af9bed9295fcae3fd38 100644 (file)
--- a/src/lib/unlang/xlat_builtin.c
+++ b/src/lib/unlang/xlat_builtin.c
@@ -3381,7 +3381,7 @@ do { \
        XLAT_REGISTER_MONO("rand", xlat_func_rand, FR_TYPE_UINT64, xlat_func_rand_arg);
        XLAT_REGISTER_MONO("randstr", xlat_func_randstr, FR_TYPE_STRING, xlat_func_randstr_arg);
 
-       xlat = xlat_func_register(NULL, "module", xlat_func_module, FR_TYPE_STRING);
+       if (unlikely((xlat = xlat_func_register(NULL, "module", xlat_func_module, FR_TYPE_STRING)) == NULL)) return -1;
        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 97732cbdcf298ce991be7cdb8382c782a4d5f39c..c68fdb7e1e70a3f31c371c3db640a937e854e2ce 100644 (file)
--- a/src/lib/unlang/xlat_expr.c
+++ b/src/lib/unlang/xlat_expr.c
@@ -1627,7 +1627,7 @@ static xlat_action_t xlat_func_exists(TALLOC_CTX *ctx, fr_dcursor_t *out,
 #undef XLAT_REGISTER_BINARY_OP
 #define XLAT_REGISTER_BINARY_OP(_op, _name) \
 do { \
-       if (!(xlat = xlat_func_register(NULL, "op_" STRINGIFY(_name), xlat_func_op_ ## _name, FR_TYPE_VOID))) return -1; \
+       if (unlikely((xlat = xlat_func_register(NULL, "op_" STRINGIFY(_name), xlat_func_op_ ## _name, FR_TYPE_VOID)) == NULL)) return -1; \
        xlat_func_args_set(xlat, binary_op_xlat_args); \
        xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL); \
        xlat_func_print_set(xlat, xlat_expr_print_binary); \
@@ -1638,7 +1638,7 @@ do { \
 #undef XLAT_REGISTER_BINARY_CMP
 #define XLAT_REGISTER_BINARY_CMP(_op, _name) \
 do { \
-       if (!(xlat = xlat_func_register(NULL, "cmp_" STRINGIFY(_name), xlat_func_cmp_ ## _name, FR_TYPE_VOID))) return -1; \
+       if (unlikely((xlat = xlat_func_register(NULL, "cmp_" STRINGIFY(_name), xlat_func_cmp_ ## _name, FR_TYPE_VOID)) == NULL)) return -1; \
        xlat_func_args_set(xlat, binary_op_xlat_args); \
        xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL); \
        xlat_func_print_set(xlat, xlat_expr_print_binary); \
@@ -1649,7 +1649,7 @@ do { \
 #undef XLAT_REGISTER_NARY_OP
 #define XLAT_REGISTER_NARY_OP(_op, _name, _func_name) \
 do { \
-       if (!(xlat = xlat_func_register(NULL, STRINGIFY(_name), xlat_func_ ## _func_name, FR_TYPE_VOID))) return -1; \
+       if (unlikely((xlat = xlat_func_register(NULL, STRINGIFY(_name), xlat_func_ ## _func_name, FR_TYPE_VOID)) == NULL)) 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_FUNC_FLAG_INTERNAL); \
        xlat_func_print_set(xlat, xlat_expr_print_ ## _func_name); \
@@ -1660,7 +1660,7 @@ do { \
 #undef XLAT_REGISTER_REGEX_OP
 #define XLAT_REGISTER_REGEX_OP(_op, _name) \
 do { \
-       if (!(xlat = xlat_func_register(NULL, STRINGIFY(_name), xlat_func_ ## _name, FR_TYPE_VOID))) return -1; \
+       if (unlikely((xlat = xlat_func_register(NULL, STRINGIFY(_name), xlat_func_ ## _name, FR_TYPE_VOID)) == NULL)) return -1; \
        xlat_func_args_set(xlat, regex_op_xlat_args); \
        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); \
@@ -1670,14 +1670,14 @@ do { \
 
 #define XLAT_REGISTER_MONO(_xlat, _func, _arg) \
 do { \
-       if (!(xlat = xlat_func_register(NULL, _xlat, _func, FR_TYPE_VOID))) return -1; \
+       if (unlikely((xlat = xlat_func_register(NULL, _xlat, _func, FR_TYPE_VOID)) == NULL)) return -1; \
        xlat_func_mono_set(xlat, _arg); \
        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; \
+       if (unlikely((xlat = xlat_func_register(NULL, _xlat, _func, FR_TYPE_VOID)) == NULL)) return -1; \
        xlat_func_args_set(xlat, unary_op_xlat_args); \
        xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_PURE | XLAT_FUNC_FLAG_INTERNAL); \
        xlat_func_print_set(xlat, xlat_expr_print_unary); \
@@ -1737,7 +1737,7 @@ int xlat_register_expressions(void)
        /*
         *      Callback wrapper around old paircmp() API.
         */
-       if (!(xlat = xlat_func_register(NULL, "paircmp", xlat_paircmp_func, FR_TYPE_VOID))) return -1; /* never pure! */
+       if (unlikely((xlat = xlat_func_register(NULL, "paircmp", xlat_paircmp_func, FR_TYPE_VOID)) == NULL)) return -1; /* never pure! */
        xlat_func_args_set(xlat, xlat_paircmp_xlat_args);
        xlat_func_flags_set(xlat, XLAT_FUNC_FLAG_INTERNAL);
 

diff --git a/src/lib/unlang/xlat_redundant.c b/src/lib/unlang/xlat_redundant.c
index a05b52e02ee1f54a43b4eb919628b68c194c7fc1..15e156514fa353f907c04d925257d88323861fc5 100644 (file)
--- a/src/lib/unlang/xlat_redundant.c
+++ b/src/lib/unlang/xlat_redundant.c
@@ -452,7 +452,7 @@ int xlat_register_redundant(CONF_SECTION *cs)
        }
 
        xlat = xlat_func_register(NULL, name2, xlat_redundant, return_type);
-       if (!xlat) {
+       if (unlikely(xlat == NULL)) {
                ERROR("Registering xlat for %s section failed",
                      fr_table_str_by_value(xlat_redundant_type_table, xr->type, "<INVALID>"));
                talloc_free(xr);

diff --git a/src/modules/rlm_chap/rlm_chap.c b/src/modules/rlm_chap/rlm_chap.c
index 20717abe57c1c70d1e0794e3ff758b6737c5bd0f..2c6aa0bacd3543003df7afb0eea951cc7748b311 100644 (file)
--- a/src/modules/rlm_chap/rlm_chap.c
+++ b/src/modules/rlm_chap/rlm_chap.c
@@ -293,8 +293,7 @@ static int mod_load(void)
 {
        xlat_t  *xlat;
 
-       xlat = xlat_func_register(NULL, "chap_password", xlat_func_chap_password, FR_TYPE_OCTETS);
-       if (!xlat) return -1;
+       if (unlikely((xlat = xlat_func_register(NULL, "chap_password", xlat_func_chap_password, FR_TYPE_OCTETS)) == NULL)) return -1;
        xlat_func_args_set(xlat, xlat_func_chap_password_args);
 
        return 0;

diff --git a/src/modules/rlm_client/rlm_client.c b/src/modules/rlm_client/rlm_client.c
index 2bd1fd2bb07c5df88ec60aa5667f945487b5c557..6d559421e433c8f4e0ea818222407ea8445cd04b 100644 (file)
--- a/src/modules/rlm_client/rlm_client.c
+++ b/src/modules/rlm_client/rlm_client.c
@@ -353,8 +353,7 @@ static int mod_load(void)
 {
        xlat_t  *xlat;
 
-       xlat = xlat_func_register(NULL, "client", xlat_client, FR_TYPE_STRING);
-       if (!xlat) return -1;
+       if (unlikely((xlat = xlat_func_register(NULL, "client", xlat_client, FR_TYPE_STRING)) == NULL)) return -1;
        xlat_func_args_set(xlat, xlat_client_args);
 
        map_proc_register(NULL, "client", map_proc_client, NULL, 0);