From: hyunuktak Date: Tue, 5 Mar 2019 05:34:14 +0000 (+0900) Subject: Add mutex locking/unlocking for multi thread X-Git-Tag: submit/tizen/20190322.054530~1 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F47%2F200847%2F12;p=platform%2Fcore%2Fapi%2Fsmart-traffic-control.git Add mutex locking/unlocking for multi thread Change-Id: I359b333c76c104ed98ac9e9b8663480526ed33da Signed-off-by: hyunuktak --- diff --git a/include/stc_fw_internal.h b/include/stc_fw_internal.h index a315a03..641a732 100755 --- a/include/stc_fw_internal.h +++ b/include/stc_fw_internal.h @@ -454,6 +454,7 @@ int stc_firewall_chain_get_priority(stc_firewall_chain_h chain_h, * @privlevel platform * @privilege %http://tizen.org/privilege/firewall.common * + * @param[in] stc The stc handle * @param[in] chain The firewall chain handle * * @return 0 on success, otherwise a negative error value @@ -470,7 +471,7 @@ int stc_firewall_chain_get_priority(stc_firewall_chain_h chain_h, * @see stc_firewall_chain_create() * @see stc_firewall_chain_destroy() */ -int stc_firewall_chain_add(stc_firewall_chain_h chain_h); +int stc_firewall_chain_add(stc_h stc, stc_firewall_chain_h chain_h); /** * @brief Removes the chain. @@ -478,6 +479,7 @@ int stc_firewall_chain_add(stc_firewall_chain_h chain_h); * @privlevel platform * @privilege %http://tizen.org/privilege/firewall.common * + * @param[in] stc The stc handle * @param[in] chain The firewall chain handle * * @return 0 on success, otherwise a negative error value @@ -494,7 +496,7 @@ int stc_firewall_chain_add(stc_firewall_chain_h chain_h); * @see stc_firewall_chain_create() * @see stc_firewall_chain_destroy() */ -int stc_firewall_chain_remove(stc_firewall_chain_h chain_h); +int stc_firewall_chain_remove(stc_h stc, stc_firewall_chain_h chain_h); /** * @brief Flushs the chain. @@ -502,6 +504,7 @@ int stc_firewall_chain_remove(stc_firewall_chain_h chain_h); * @privlevel platform * @privilege %http://tizen.org/privilege/firewall.common * + * @param[in] stc The stc handle * @param[in] chain The firewall chain handle * * @return 0 on success, otherwise a negative error value @@ -518,7 +521,7 @@ int stc_firewall_chain_remove(stc_firewall_chain_h chain_h); * @see stc_firewall_chain_create() * @see stc_firewall_chain_destroy() */ -int stc_firewall_chain_flush(stc_firewall_chain_h chain_h); +int stc_firewall_chain_flush(stc_h stc, stc_firewall_chain_h chain_h); /** * @brief Gets all chains. @@ -554,6 +557,7 @@ int stc_firewall_chain_foreach(stc_h stc, * @privilege %http://tizen.org/privilege/firewall.common * @remarks You should set only one chain. * + * @param[in] stc The stc handle * @param[in] chain The firewall chain handle * @param[in] target The target type * @@ -571,7 +575,7 @@ int stc_firewall_chain_foreach(stc_h stc, * @see stc_firewall_chain_create() * @see stc_firewall_chain_destroy() */ -int stc_firewall_chain_set(stc_firewall_chain_h chain_h, +int stc_firewall_chain_set(stc_h stc, stc_firewall_chain_h chain_h, stc_firewall_chain_target_e target); /** @@ -580,6 +584,7 @@ int stc_firewall_chain_set(stc_firewall_chain_h chain_h, * @privlevel platform * @privilege %http://tizen.org/privilege/firewall.common * + * @param[in] stc The stc handle * @param[in] chain The firewall chain handle * * @return 0 on success, otherwise a negative error value @@ -596,7 +601,7 @@ int stc_firewall_chain_set(stc_firewall_chain_h chain_h, * @see stc_firewall_chain_create() * @see stc_firewall_chain_destroy() */ -int stc_firewall_chain_unset(stc_firewall_chain_h chain_h); +int stc_firewall_chain_unset(stc_h stc, stc_firewall_chain_h chain_h); /** * @brief Creates the firewall rule handle. @@ -1601,6 +1606,7 @@ int stc_firewall_rule_get_nflog_threshold(stc_firewall_rule_h rule_h, * @privlevel platform * @privilege %http://tizen.org/privilege/firewall.common * + * @param[in] stc The stc handle * @param[in] rule The firewall rule handle * * @return 0 on success, otherwise a negative error value @@ -1617,7 +1623,7 @@ int stc_firewall_rule_get_nflog_threshold(stc_firewall_rule_h rule_h, * @see stc_firewall_rule_create() * @see stc_firewall_rule_destroy() */ -int stc_firewall_rule_add(stc_firewall_rule_h rule_h); +int stc_firewall_rule_add(stc_h stc, stc_firewall_rule_h rule_h); /** * @brief Removes the rule. @@ -1625,6 +1631,7 @@ int stc_firewall_rule_add(stc_firewall_rule_h rule_h); * @privlevel platform * @privilege %http://tizen.org/privilege/firewall.common * + * @param[in] stc The stc handle * @param[in] rule The firewall rule handle * * @return 0 on success, otherwise a negative error value @@ -1641,7 +1648,7 @@ int stc_firewall_rule_add(stc_firewall_rule_h rule_h); * @see stc_firewall_rule_create() * @see stc_firewall_rule_destroy() */ -int stc_firewall_rule_remove(stc_firewall_rule_h rule_h); +int stc_firewall_rule_remove(stc_h stc, stc_firewall_rule_h rule_h); /** * @brief Updates the rule. @@ -1649,6 +1656,7 @@ int stc_firewall_rule_remove(stc_firewall_rule_h rule_h); * @privlevel platform * @privilege %http://tizen.org/privilege/firewall.common * + * @param[in] stc The stc handle * @param[in] rule The firewall rule handle * * @return 0 on success, otherwise a negative error value @@ -1665,7 +1673,7 @@ int stc_firewall_rule_remove(stc_firewall_rule_h rule_h); * @see stc_firewall_rule_create() * @see stc_firewall_rule_destroy() */ -int stc_firewall_rule_update(stc_firewall_rule_h rule_h); +int stc_firewall_rule_update(stc_h stc, stc_firewall_rule_h rule_h); /** * @brief Gets all rules. diff --git a/src/include/stc-reset.h b/src/include/stc-reset.h index cc12ee7..0e151fb 100755 --- a/src/include/stc-reset.h +++ b/src/include/stc-reset.h @@ -74,7 +74,7 @@ typedef struct { * Local Functions Definition *****************************************************************************/ stc_error_e _stc_reset_check_rule(stc_reset_rule_h rule); -stc_error_e _stc_reset_stats(stc_reset_rule_h rule); +stc_error_e _stc_reset_stats(stc_h stc, stc_reset_rule_h rule); #ifdef __cplusplus diff --git a/src/include/stc-restriction.h b/src/include/stc-restriction.h index 6210b85..b60aaab 100755 --- a/src/include/stc-restriction.h +++ b/src/include/stc-restriction.h @@ -106,8 +106,8 @@ void _stc_restriction_add_to_list(stc_restriction_list_h list); void _stc_restriction_remove_from_list(stc_restriction_list_h list); bool _stc_restriction_check_list_validity(stc_restriction_list_h list); -stc_error_e _stc_restriction_set_list(stc_restriction_list_h list_h); -stc_error_e _stc_restriction_unset_list(stc_restriction_list_h list_h); +stc_error_e _stc_restriction_set_list(stc_h stc, stc_restriction_list_h list_h); +stc_error_e _stc_restriction_unset_list(stc_h stc, stc_restriction_list_h list_h); stc_error_e _stc_restriction_validate_rule( stc_restriction_rule_h rule); @@ -116,13 +116,12 @@ stc_error_e _stc_restriction_check_get_all_rule( stc_restriction_rule_h rule); stc_error_e _stc_restriction_check_get_type_rule( stc_restriction_rule_h rule); -stc_error_e _stc_restriction_set(stc_restriction_rule_h rule); -stc_error_e _stc_restriction_exclude(stc_restriction_rule_h rule); -stc_error_e _stc_restriction_unset(stc_restriction_rule_h rule); -stc_error_e _stc_restriction_get_type(stc_restriction_rule_h rule, +stc_error_e _stc_restriction_set(stc_h stc, stc_restriction_rule_h rule); +stc_error_e _stc_restriction_unset(stc_h stc, stc_restriction_rule_h rule); +stc_error_e _stc_restriction_get_type(stc_h stc, stc_restriction_rule_h rule, stc_restriction_type_e *type); -stc_error_e _stc_restriction_get(stc_restriction_rule_h rule); -stc_error_e _stc_restriction_get_all(stc_restriction_rule_h rule); +stc_error_e _stc_restriction_get(stc_h stc, stc_restriction_rule_h rule); +stc_error_e _stc_restriction_get_all(stc_h stc, stc_restriction_rule_h rule); #ifdef __cplusplus } diff --git a/src/include/stc-statistics.h b/src/include/stc-statistics.h index 94c0275..9f1745d 100755 --- a/src/include/stc-statistics.h +++ b/src/include/stc-statistics.h @@ -78,12 +78,12 @@ stc_error_e _stc_stats_check_get_all_rule( stc_error_e _stc_stats_check_get_total_rule( stc_stats_rule_h rule); -stc_error_e _stc_stats_get(stc_stats_rule_h rule); -stc_error_e _stc_stats_foreach(stc_stats_rule_h rule); -stc_error_e _stc_stats_get_all(stc_stats_rule_h rule); +stc_error_e _stc_stats_get(stc_h stc, stc_stats_rule_h rule); +stc_error_e _stc_stats_foreach(stc_h stc, stc_stats_rule_h rule); +stc_error_e _stc_stats_get_all(stc_h stc, stc_stats_rule_h rule); stc_error_e _stc_stats_foreach_all(stc_all_stats_info_h info, stc_stats_info_cb info_cb, void *user_data); -stc_error_e _stc_stats_get_total(stc_stats_rule_h rule); +stc_error_e _stc_stats_get_total(stc_h stc, stc_stats_rule_h rule); #ifdef __cplusplus } diff --git a/src/internal/include/stc-dbus.h b/src/internal/include/stc-dbus.h index 232169d..a9482a3 100755 --- a/src/internal/include/stc-dbus.h +++ b/src/internal/include/stc-dbus.h @@ -45,7 +45,6 @@ extern "C" { /***************************************************************************** * Smart Traffic Control (STC) library headers *****************************************************************************/ -#include "stc-private.h" /***************************************************************************** * Macros and Typedefs @@ -115,19 +114,17 @@ typedef void (*stc_dbus_dict_cb) (const char *key, GVariant *value, void *user_d /***************************************************************************** * Local Functions Definition *****************************************************************************/ -int _stc_dbus_create(void); -int _stc_dbus_destroy(void); -GDBusConnection *_stc_dbus_get_connection(void); -GCancellable *_stc_dbus_get_cancellable(void); +int _stc_dbus_create(stc_h stc); +void _stc_dbus_destroy(stc_h stc); void _stc_dbus_dictionary_foreach(GVariantIter *iter, stc_dbus_dict_cb cb, void *user_data); -GVariant *_stc_dbus_invoke_method(const char *dest, - const char *path, const char *interface_name, const char *method, - GVariant *params, int *dbus_error); -int _stc_dbus_invoke_method_nonblock(const char *dest, - const char *path, const char *interface_name, const char *method, - GVariant *params, int timeout, +GVariant *_stc_dbus_invoke_method(stc_h stc, + const char *dest, const char *path, const char *interface_name, + const char *method, GVariant *params, int *dbus_error); +int _stc_dbus_invoke_method_nonblock(stc_h stc, + const char *dest, const char *path, const char *interface_name, + const char *method, GVariant *params, int timeout, GAsyncReadyCallback notify_func, void *user_data); #ifdef __cplusplus diff --git a/src/internal/include/stc-event.h b/src/internal/include/stc-event.h index beb9f7a..1274851 100755 --- a/src/internal/include/stc-event.h +++ b/src/internal/include/stc-event.h @@ -35,6 +35,7 @@ extern "C" { /***************************************************************************** * Standard headers *****************************************************************************/ + #include /***************************************************************************** @@ -44,6 +45,7 @@ extern "C" { /***************************************************************************** * Smart Traffic Control (STC) library headers *****************************************************************************/ + #include "stc.h" /***************************************************************************** @@ -77,6 +79,7 @@ typedef enum { } stc_request_table_e; typedef struct { + stc_h handle; stc_event_e event; stc_error_e error; int datalength; @@ -88,8 +91,6 @@ typedef void (*stc_event_cb)(const stc_event_info_s* stc_event, void* user_data) typedef struct { stc_event_cb event_callback; void* user_data; - int ref_count; - guint handler_id; } stc_event_handle_info_s; typedef struct { @@ -102,6 +103,14 @@ typedef struct { guint id; } stc_managed_idle_data_s; +typedef struct { + stc_event_e event; + stc_error_e error; + void *info_data; + void *user_callback; + void *user_data; +} stc_callback_data_s; + /***************************************************************************** * Global Variables *****************************************************************************/ @@ -109,13 +118,10 @@ typedef struct { /***************************************************************************** * Local Functions Definition *****************************************************************************/ -int _stc_register_event_cb(stc_event_cb event_cb, void *user_data); -int _stc_deregister_event_cb(void); +void _stc_register_event_cb(stc_h stc, + stc_event_cb event_cb, void *user_data); +void _stc_deregister_event_cb(stc_h stc); void _stc_event_clear_request_table(void); -guint _stc_event_add_client_idle_cb(stc_event_info_s *event_data, - void *user_data); -void _stc_event_clear_client_cb(void); -int _stc_event_get_ref_count(void); bool _stc_event_get_request_table_state(int num); void _stc_event_set_request_table_state(int num, int state); diff --git a/src/internal/include/stc-private.h b/src/internal/include/stc-private.h index 3470714..9059031 100755 --- a/src/internal/include/stc-private.h +++ b/src/internal/include/stc-private.h @@ -35,6 +35,8 @@ extern "C" { /***************************************************************************** * Standard headers *****************************************************************************/ +#include +#include /***************************************************************************** * System headers @@ -45,6 +47,8 @@ extern "C" { *****************************************************************************/ #include "stc.h" #include "stc_internal.h" +#include "stc-event.h" +#include "stc-dbus.h" /***************************************************************************** * Macros and Typedefs @@ -57,7 +61,23 @@ extern "C" { #define STC_HR_DOUBLE "========================================" \ "=========================" +#define STC_LOCK \ + do { \ + _stc_lock(); \ + } while(0) + +#define STC_UNLOCK \ + do { \ + _stc_unlock(); \ + } while(0) + typedef struct { + stc_event_handle_info_s event_handle; + stc_dbus_connection_data_s dbus_connection; + + guint stats_subscribe_id; + guint restriction_subscribe_id; + stc_stats_info_cb stats_cb; void *stats_user_data; stc_stats_info_cb stats_all_cb; @@ -126,11 +146,11 @@ const char *_stc_convert_fw_chain_target_to_string( const char *_stc_convert_fw_rule_target_to_string( stc_firewall_rule_target_e target); -int _stc_initialize(void); -int _stc_deinitialize(void); +int _stc_initialize(stc_h stc); +int _stc_deinitialize(stc_h stc); int _stc_handle_create(stc_h *stc); -int _stc_handle_add(stc_h *stc); -int _stc_handle_remove(stc_h stc); +void _stc_handle_add(stc_h stc); +void _stc_handle_remove(stc_h stc); bool _stc_handle_check_validity(stc_h stc); int _stc_handle_get_count(void); @@ -153,6 +173,9 @@ void _stc_callback_set_restriction_threshold_crossed(stc_h stc, void _stc_callback_set_warn_threshold_crossed(stc_h stc, stc_threshold_crossed_cb user_cb, void *user_data); +void _stc_lock(void); +void _stc_unlock(void); + #ifdef __cplusplus } #endif diff --git a/src/internal/include/stc-signal.h b/src/internal/include/stc-signal.h index 11a325d..5df6dcb 100755 --- a/src/internal/include/stc-signal.h +++ b/src/internal/include/stc-signal.h @@ -40,6 +40,8 @@ extern "C" { * System headers *****************************************************************************/ +#include "stc-private.h" + /***************************************************************************** * Smart Traffic Control (STC) library headers *****************************************************************************/ @@ -59,8 +61,8 @@ extern "C" { /***************************************************************************** * Local Functions Definition *****************************************************************************/ -int _stc_register_signal(void); -int _stc_deregister_signal(void); +int _stc_register_signal(stc_h stc); +void _stc_deregister_signal(stc_h stc); #ifdef __cplusplus diff --git a/src/internal/stc-dbus.c b/src/internal/stc-dbus.c index 668e576..eaca0c4 100755 --- a/src/internal/stc-dbus.c +++ b/src/internal/stc-dbus.c @@ -54,54 +54,45 @@ /***************************************************************************** * Global Variables *****************************************************************************/ -static __thread stc_dbus_connection_data_s g_stc_dbus_conn = { NULL, NULL }; /***************************************************************************** * Local Functions Definition *****************************************************************************/ -int _stc_dbus_create(void) +int _stc_dbus_create(stc_h stc) { GError *err = NULL; + stc_handle_s *stc_handle = (stc_handle_s *)stc; #if !GLIB_CHECK_VERSION(2, 36, 0) g_type_init(); #endif - g_stc_dbus_conn.connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err); - if (g_stc_dbus_conn.connection == NULL) { + stc_handle->dbus_connection.connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err); + if (stc_handle->dbus_connection.connection == NULL) { if (err != NULL) { STC_LOGE("Failed to connect to the D-BUS daemon [%s]", err->message); //LCOV_EXCL_LINE g_error_free(err); //LCOV_EXCL_LINE } + return STC_ERROR_OPERATION_FAILED; } - g_stc_dbus_conn.cancellable = g_cancellable_new(); + stc_handle->dbus_connection.cancellable = g_cancellable_new(); return STC_ERROR_NONE; } -int _stc_dbus_destroy(void) +void _stc_dbus_destroy(stc_h stc) { - g_cancellable_cancel(g_stc_dbus_conn.cancellable); - g_object_unref(g_stc_dbus_conn.cancellable); - g_stc_dbus_conn.cancellable = NULL; - - g_object_unref(g_stc_dbus_conn.connection); - g_stc_dbus_conn.connection = NULL; - - return STC_ERROR_NONE; -} + stc_handle_s *stc_handle = (stc_handle_s *)stc; -GDBusConnection *_stc_dbus_get_connection(void) -{ - return g_stc_dbus_conn.connection; -} + g_cancellable_cancel(stc_handle->dbus_connection.cancellable); + g_object_unref(stc_handle->dbus_connection.cancellable); + stc_handle->dbus_connection.cancellable = NULL; -GCancellable *_stc_dbus_get_cancellable(void) -{ - return g_stc_dbus_conn.cancellable; + g_object_unref(stc_handle->dbus_connection.connection); + stc_handle->dbus_connection.connection = NULL; } void _stc_dbus_dictionary_foreach(GVariantIter *iter, @@ -120,21 +111,16 @@ void _stc_dbus_dictionary_foreach(GVariantIter *iter, } } -GVariant *_stc_dbus_invoke_method(const char *dest, - const char *path, const char *interface_name, const char *method, - GVariant *params, int *dbus_error) +GVariant *_stc_dbus_invoke_method(stc_h stc, + const char *dest, const char *path, const char *interface_name, + const char *method, GVariant *params, int *dbus_error) { GError *error = NULL; GVariant *reply = NULL; *dbus_error = STC_ERROR_NONE; - GDBusConnection *connection; - - connection = _stc_dbus_get_connection(); - if (connection == NULL) { - STC_LOGE("GDBusconnection is NULL"); //LCOV_EXCL_LINE - *dbus_error = STC_ERROR_NOT_INITIALIZED; //LCOV_EXCL_LINE - return reply; //LCOV_EXCL_LINE - } + stc_handle_s *stc_handle = (stc_handle_s *)stc; + GDBusConnection *connection = stc_handle->dbus_connection.connection; + GCancellable *cancellable = stc_handle->dbus_connection.cancellable; reply = g_dbus_connection_call_sync(connection, dest, @@ -145,7 +131,7 @@ GVariant *_stc_dbus_invoke_method(const char *dest, NULL, G_DBUS_CALL_FLAGS_NONE, STC_DBUS_REPLY_TIMEOUT, - _stc_dbus_get_cancellable(), + cancellable, &error); if (reply == NULL) { @@ -165,31 +151,27 @@ GVariant *_stc_dbus_invoke_method(const char *dest, return reply; } -int _stc_dbus_invoke_method_nonblock(const char *dest, - const char *path, const char *interface_name, const char *method, - GVariant *params, int timeout, +int _stc_dbus_invoke_method_nonblock(stc_h stc, + const char *dest, const char *path, const char *interface_name, + const char *method, GVariant *params, int timeout, GAsyncReadyCallback notify_func, void *user_data) { - GDBusConnection *connection; - - connection = _stc_dbus_get_connection(); - if (connection == NULL) { - STC_LOGE("GDBusconnection is NULL"); //LCOV_EXCL_LINE - return STC_ERROR_NOT_INITIALIZED; //LCOV_EXCL_LINE - } + stc_handle_s *stc_handle = (stc_handle_s *)stc; + GDBusConnection *connection = stc_handle->dbus_connection.connection; + GCancellable *cancellable = stc_handle->dbus_connection.cancellable; g_dbus_connection_call(connection, - dest, - path, - interface_name, - method, - params, - NULL, - G_DBUS_CALL_FLAGS_NONE, - timeout, - _stc_dbus_get_cancellable(), - (GAsyncReadyCallback) notify_func, - (gpointer)user_data); + dest, + path, + interface_name, + method, + params, + NULL, + G_DBUS_CALL_FLAGS_NONE, + timeout, + cancellable, + (GAsyncReadyCallback) notify_func, + (gpointer)user_data); return STC_ERROR_NONE; } diff --git a/src/internal/stc-event.c b/src/internal/stc-event.c index 1ee3a9e..d2e0fce 100755 --- a/src/internal/stc-event.c +++ b/src/internal/stc-event.c @@ -47,7 +47,6 @@ #include "stc.h" #include "stc-private.h" - #include "stc-dbus.h" #include "stc-log.h" #include "stc-util.h" @@ -62,127 +61,28 @@ /***************************************************************************** * Global Variables *****************************************************************************/ -static __thread stc_request_table_s g_stc_request_table[STC_EVENT_LAST_ELEM] = { { 0 }, }; -static __thread stc_event_handle_info_s g_stc_event_handle = { 0, }; -static __thread GSList *g_stc_managed_idler_list = NULL; + +static stc_request_table_s g_stc_request_table[STC_EVENT_LAST_ELEM] = { { 0 }, }; /***************************************************************************** * Local Functions Definition *****************************************************************************/ -static void __stc_event_destroy_client_idle_cb(gpointer data) -{ - if (!data) - return; - - g_stc_managed_idler_list = g_slist_remove(g_stc_managed_idler_list, data); - g_free(data); - data = NULL; -} - -static gboolean __stc_event_client_idle_cb(gpointer idle_data) -{ - stc_managed_idle_data_s *data = (stc_managed_idle_data_s *)idle_data; - - if (!data) - return false; - - stc_event_info_s *event_data = (stc_event_info_s *)data->event_data; - void *user_data = data->user_data; - - if (g_stc_event_handle.event_callback != NULL) - g_stc_event_handle.event_callback(event_data, user_data); - - g_free(event_data); - - return false; -} - -static int __stc_init_service(void) +void _stc_register_event_cb(stc_h stc, + stc_event_cb event_cb, void *user_data) { - GVariant *message = NULL; - stc_error_e error = STC_ERROR_NONE; - int result = 0; - - message = _stc_dbus_invoke_method( - STC_MANAGER_SERVICE, - STC_MANAGER_STATS_PATH, - STC_MANAGER_STATS_INTERFACE, - STC_MANAGER_METHOD_STATS_INIT, - NULL, - &error); - - STC_RETURN_VAL_IF(message == NULL, - error, "Failed to invoke dbus method"); - - STC_LOGI("Successfully init service [%d]", result); - - return STC_ERROR_NONE; -} - -int _stc_register_event_cb(stc_event_cb event_cb, void *user_data) -{ - int ret = STC_ERROR_NONE; - - STC_RETURN_VAL_IF(event_cb == NULL, - STC_ERROR_INVALID_PARAMETER, - "Invalid event callback parameter"); - - STC_RETURN_VAL_IF(g_stc_event_handle.event_callback != NULL, - STC_ERROR_ALREADY_INITIALIZED, - "STC event callback already registered"); - - if (_stc_event_get_ref_count() < 1) { - ret = _stc_dbus_create(); - if (ret != STC_ERROR_NONE) { - STC_LOGE("Failed to create DBus [%s]", //LCOV_EXCL_LINE - _stc_convert_error_type_to_string(ret)); - return ret; //LCOV_EXCL_LINE - } - - ret = _stc_register_signal(); - if (ret != STC_ERROR_NONE && ret != STC_ERROR_ALREADY_INITIALIZED) { - STC_LOGE("Failed to register DBus signal [%s]", //LCOV_EXCL_LINE - _stc_convert_error_type_to_string(ret)); - return ret; //LCOV_EXCL_LINE - } - - ret = __stc_init_service(); - if (ret != STC_ERROR_NONE) { - STC_LOGE("Failed to init manager [%s]", //LCOV_EXCL_LINE - _stc_convert_error_type_to_string(ret)); - return ret; //LCOV_EXCL_LINE - } - } + stc_handle_s *stc_handle = (stc_handle_s *)stc; - g_stc_event_handle.event_callback = event_cb; - g_stc_event_handle.user_data = user_data; - - __sync_fetch_and_add(&g_stc_event_handle.ref_count, 1); - - return STC_ERROR_NONE; + stc_handle->event_handle.event_callback = event_cb; + stc_handle->event_handle.user_data = user_data; } -int _stc_deregister_event_cb(void) +void _stc_deregister_event_cb(stc_h stc) { - STC_RETURN_VAL_IF(_stc_event_get_ref_count() < 1, - STC_ERROR_NOT_INITIALIZED, - "Event callback is not registered"); - - STC_RETURN_VAL_IF(g_stc_event_handle.event_callback == NULL, - STC_ERROR_NOT_INITIALIZED, - "Event callback was not registered"); - - g_stc_event_handle.event_callback = NULL; - g_stc_event_handle.user_data = NULL; + stc_handle_s *stc_handle = (stc_handle_s *)stc; - if (__sync_sub_and_fetch(&g_stc_event_handle.ref_count, 1) < 1) { - _stc_deregister_signal(); - _stc_event_clear_request_table(); - _stc_event_clear_client_cb(); - } - - return STC_ERROR_NONE; + stc_handle->event_handle.event_callback = NULL; + stc_handle->event_handle.user_data = NULL; } void _stc_event_clear_request_table(void) @@ -193,81 +93,6 @@ void _stc_event_clear_request_table(void) memset(&g_stc_request_table[i], 0, sizeof(stc_request_table_s)); } -guint _stc_event_add_client_idle_cb(stc_event_info_s *event_data, - void *user_data) -{ - guint id; - stc_managed_idle_data_s *idle_data; - GMainContext *context; - GSource *src; - stc_event_info_s *data; - - idle_data = g_try_new0(stc_managed_idle_data_s, 1); - if (!idle_data) - return 0; - - data = g_try_new0(stc_event_info_s, 1); - if (!data) { - g_free(idle_data); //LCOV_EXCL_LINE - idle_data = NULL; //LCOV_EXCL_LINE - return 0; //LCOV_EXCL_LINE - } - - memcpy(data, event_data, sizeof(stc_event_info_s)); - - idle_data->event_data = data; - idle_data->user_data = user_data; - - context = g_main_context_get_thread_default(); - src = g_idle_source_new(); - g_source_set_callback(src, __stc_event_client_idle_cb, idle_data, - __stc_event_destroy_client_idle_cb); - id = g_source_attach(src, context); - g_source_unref(src); - - if (!id) { - g_slist_free(idle_data->event_data->info_data); //LCOV_EXCL_LINE - g_free(idle_data); //LCOV_EXCL_LINE - idle_data = NULL; //LCOV_EXCL_LINE - return id; //LCOV_EXCL_LINE - } - - idle_data->id = id; - - g_stc_managed_idler_list = g_slist_append(g_stc_managed_idler_list, idle_data); - - return id; -} - -void _stc_event_clear_client_cb(void) -{ - GSList *cur = g_stc_managed_idler_list; - GSource *src; - stc_managed_idle_data_s *data; - - //LCOV_EXCL_START - while (cur) { - GSList *next = cur->next; - data = (stc_managed_idle_data_s *)cur->data; - - src = g_main_context_find_source_by_id(g_main_context_default(), data->id); - if (src) { - g_source_destroy(src); - cur = g_stc_managed_idler_list; - } else - cur = next; - } - //LCOV_EXCL_STOP - - g_slist_free(g_stc_managed_idler_list); - g_stc_managed_idler_list = NULL; -} - -int _stc_event_get_ref_count(void) -{ - return g_stc_event_handle.ref_count; -} - bool _stc_event_get_request_table_state(int num) { return g_stc_request_table[num].state; diff --git a/src/internal/stc-private.c b/src/internal/stc-private.c index eacf5e2..c885879 100755 --- a/src/internal/stc-private.c +++ b/src/internal/stc-private.c @@ -34,9 +34,6 @@ #include #include -#include -#include - /***************************************************************************** * System headers *****************************************************************************/ @@ -49,7 +46,6 @@ #include "stc-private.h" -#include "stc-dbus.h" #include "stc-log.h" #include "stc-util.h" #include "stc-event.h" @@ -63,7 +59,9 @@ /***************************************************************************** * Global Variables *****************************************************************************/ -static __thread GSList *g_stc_handle_list = NULL; + +static pthread_mutex_t g_stc_thread_mutex = PTHREAD_MUTEX_INITIALIZER; +static GSList *g_stc_handle_list = NULL; /***************************************************************************** * Local Functions Definition @@ -373,249 +371,239 @@ const char *_stc_convert_fw_rule_target_to_string( } //LCOV_EXCL_STOP +static int __stc_init_service(stc_h stc) +{ + GVariant *message = NULL; + stc_error_e error = STC_ERROR_NONE; + int result = 0; + + message = _stc_dbus_invoke_method(stc, + STC_MANAGER_SERVICE, + STC_MANAGER_STATS_PATH, + STC_MANAGER_STATS_INTERFACE, + STC_MANAGER_METHOD_STATS_INIT, + NULL, + &error); + + STC_RETURN_VAL_IF(message == NULL, + error, "Failed to invoke dbus method"); + + STC_LOGI("Successfully init service [%d]", result); + + return STC_ERROR_NONE; +} + static bool __stc_handle_find(stc_h stc) { - if (g_slist_find(g_stc_handle_list, stc) != NULL) + GSList *find = g_slist_find(g_stc_handle_list, stc); + + if (find) return true; else return false; } -static void __stc_callback_foreach(stc_event_e e, - stc_error_e err, GSList *info_data) +static void __stc_call_callback(stc_event_e event, stc_error_e error, + void *info_data, void *user_callback, void *user_data) { - GSList *list, *data; + GSList *list; int ret = STC_ERROR_NONE; - for (list = g_stc_handle_list; list; list = list->next) { - stc_handle_s *handle = (stc_handle_s *)list->data; - switch (e) { - case STC_EVENT_STATS_GET_RSP: - if (handle->stats_cb) { - if (err == STC_ERROR_NONE) { - if (info_data != NULL) { - for (data = info_data; data; data = data->next) { - stc_stats_info_h info = data->data; - ret = handle->stats_cb(err, - info, handle->stats_user_data); - - if (ret == STC_CALLBACK_CANCEL) - break; - } - } else { - handle->stats_cb(err, NULL, NULL); //LCOV_EXCL_LINE - } - } else { - handle->stats_cb(err, NULL, NULL); //LCOV_EXCL_LINE - } - - handle->stats_cb = NULL; - handle->stats_user_data = NULL; - } - break; - case STC_EVENT_STATS_FOREACH_RSP: - if (handle->stats_all_cb) { - if (err == STC_ERROR_NONE) { - if (info_data != NULL) { - for (data = info_data; data; data = data->next) { - stc_stats_info_h info = data->data; - ret = handle->stats_all_cb(err, - info, handle->stats_all_user_data); - - if (ret == STC_CALLBACK_CANCEL) - break; - } - } else { - handle->stats_all_cb(err, NULL, NULL); //LCOV_EXCL_LINE - } - } else { - handle->stats_all_cb(err, NULL, NULL); //LCOV_EXCL_LINE + switch (event) { + case STC_EVENT_STATS_GET_RSP: + case STC_EVENT_STATS_FOREACH_RSP: + case STC_EVENT_STATS_GET_TOTAL_RSP: + if (error == STC_ERROR_NONE) { + if (info_data) { + for (list = info_data; list; list = list->next) { + stc_stats_info_h info = list->data; + ret = ((stc_stats_info_cb)user_callback)(error, info, user_data); + + if (ret == STC_CALLBACK_CANCEL) + break; } - handle->stats_all_cb = NULL; - handle->stats_all_user_data = NULL; + g_slist_free_full(info_data, g_free); + } else { + ((stc_stats_info_cb)user_callback)(error, NULL, NULL); } - break; - case STC_EVENT_STATS_GET_ALL_RSP: - if (handle->get_stats_finished_cb) { - if (err == STC_ERROR_NONE) { - if (info_data != NULL) { - handle->get_stats_finished_cb(err, - (stc_all_stats_info_h)info_data, - handle->get_stats_finished_user_data); - } else { - handle->get_stats_finished_cb(err, NULL, NULL); //LCOV_EXCL_LINE - } - } else { - handle->get_stats_finished_cb(err, NULL, NULL); //LCOV_EXCL_LINE - } - - handle->get_stats_finished_cb = NULL; - handle->get_stats_finished_user_data = NULL; + } else { + ((stc_stats_info_cb)user_callback)(error, NULL, NULL); + } + break; + case STC_EVENT_STATS_GET_ALL_RSP: + if (error == STC_ERROR_NONE) { + if (info_data) { + ((stc_get_all_stats_finished_cb)user_callback)(error, + (stc_all_stats_info_h)info_data, user_data); + + g_slist_free_full(info_data, g_free); + } else { + ((stc_get_all_stats_finished_cb)user_callback)(error, NULL, NULL); } - break; - case STC_EVENT_STATS_GET_TOTAL_RSP: - if (handle->stats_total_cb) { - if (err == STC_ERROR_NONE) { - if (info_data != NULL) { - for (data = info_data; data; data = data->next) { - stc_stats_info_h info = data->data; - ret = handle->stats_total_cb(err, - info, handle->stats_total_user_data); - - if (ret == STC_CALLBACK_CANCEL) - break; - } - } else { - handle->stats_total_cb(err, NULL, NULL); //LCOV_EXCL_LINE - } - } else { - handle->stats_total_cb(err, NULL, NULL); //LCOV_EXCL_LINE + } else { + ((stc_get_all_stats_finished_cb)user_callback)(error, NULL, NULL); + } + break; + case STC_EVENT_RESTRICTION_GET_RSP: + case STC_EVENT_RESTRICTION_GET_ALL_RSP: + if (error == STC_ERROR_NONE) { + if (info_data) { + for (list = info_data; list; list = list->next) { + stc_restriction_rule_h rule = list->data; + STC_LOCK; + _stc_restriction_add_rule(rule); + STC_UNLOCK; + + ret = ((stc_restriction_rule_cb)user_callback)(error, rule, user_data); + + STC_LOCK; + _stc_restriction_remove_rule(rule); + STC_UNLOCK; + + if (ret == STC_CALLBACK_CANCEL) + break; } - handle->stats_total_cb = NULL; - handle->stats_total_user_data = NULL; + g_slist_free_full(info_data, g_free); + } else { + ((stc_restriction_rule_cb)user_callback)(error, NULL, NULL); } - break; - //LCOV_EXCL_START - case STC_EVENT_RESTRICTION_GET_RSP: - if (handle->restriction_cb) { - if (err == STC_ERROR_NONE) { - if (info_data != NULL) { - for (data = info_data; data; data = data->next) { - stc_restriction_rule_h rule = data->data; - _stc_restriction_add_rule(rule); - ret = handle->restriction_cb(err, - rule, handle->restriction_user_data); - _stc_restriction_remove_rule(rule); - - if (ret == STC_CALLBACK_CANCEL) - break; - } - } else { - handle->restriction_cb(err, NULL, NULL); + } else { + ((stc_restriction_rule_cb)user_callback)(error, NULL, NULL); + } + break; + case STC_EVENT_PCAP_FIND_ALL_DEVS_RSP: + if (error == STC_ERROR_NONE) { + if (info_data) { + for (list = info_data; list; list = list->next) { + stc_pcap_h pcap = list->data; + ret = ((stc_pcap_info_cb)user_callback)(pcap, user_data); + + if (ret == STC_CALLBACK_CANCEL) + break; } - } else { - handle->restriction_cb(err, NULL, NULL); - } - handle->restriction_cb = NULL; - handle->restriction_user_data = NULL; - } - break; - case STC_EVENT_RESTRICTION_GET_ALL_RSP: - if (handle->restriction_all_cb) { - if (err == STC_ERROR_NONE) { - if (info_data != NULL) { - for (data = info_data; data; data = data->next) { - stc_restriction_rule_h rule = data->data; - _stc_restriction_add_rule(rule); - ret = handle->restriction_all_cb(err, - rule, handle->restriction_all_user_data); - _stc_restriction_remove_rule(rule); - - if (ret == STC_CALLBACK_CANCEL) - break; - } - } else { - handle->restriction_all_cb(err, NULL, NULL); - } + g_slist_free_full(info_data, g_free); } else { - handle->restriction_all_cb(err, NULL, NULL); + ((stc_pcap_info_cb)user_callback)(NULL, NULL); } - - handle->restriction_all_cb = NULL; - handle->restriction_all_user_data = NULL; + } else { + ((stc_pcap_info_cb)user_callback)(NULL, NULL); } - break; - case STC_EVENT_PCAP_FIND_ALL_DEVS_RSP: - if (handle->pcap_info_cb) { - if (err == STC_ERROR_NONE) { - if (info_data != NULL) { - for (data = info_data; data; data = data->next) { - stc_pcap_h pcap = data->data; - ret = handle->pcap_info_cb(pcap, - handle->pcap_info_user_data); - - if (ret == STC_CALLBACK_CANCEL) - break; - } - } else { - handle->pcap_info_cb(NULL, NULL); //LCOV_EXCL_LINE - } - } else { - handle->pcap_info_cb(NULL, NULL); //LCOV_EXCL_LINE - } + break; + case STC_EVENT_WARN_THRESHOLD_CROSSED_RSP: + case STC_EVENT_RESTRICTION_THRESHOLD_CROSSED_RSP: + { + stc_restriction_rule_h rule = info_data; + STC_LOCK; + _stc_restriction_add_rule(rule); + STC_UNLOCK; - handle->pcap_info_cb = NULL; - handle->pcap_info_user_data = NULL; - } - break; - //LCOV_EXCL_STOP - default: - break; - } - } -} + ((stc_threshold_crossed_cb)user_callback)(rule, user_data); -//LCOV_EXCL_START -static void __stc_signal_callback(stc_event_e e, void *info_data) -{ - GSList *list; + STC_LOCK; + _stc_restriction_remove_rule(rule); + STC_UNLOCK; - for (list = g_stc_handle_list; list; list = list->next) { - stc_handle_s *handle = (stc_handle_s *)list->data; - switch (e) { - case STC_EVENT_WARN_THRESHOLD_CROSSED_RSP: - if (handle->warn_crossed_cb) { - _stc_restriction_add_rule((stc_restriction_rule_h)info_data); - handle->warn_crossed_cb((stc_restriction_rule_h)info_data, - handle->warn_crossed_user_data); - _stc_restriction_remove_rule((stc_restriction_rule_h)info_data); - } - break; - case STC_EVENT_RESTRICTION_THRESHOLD_CROSSED_RSP: - if (handle->restriction_crossed_cb) { - _stc_restriction_add_rule((stc_restriction_rule_h)info_data); - handle->restriction_crossed_cb((stc_restriction_rule_h)info_data, - handle->restriction_crossed_user_data); - _stc_restriction_remove_rule((stc_restriction_rule_h)info_data); - } - break; - default: - break; + g_free(info_data); } + break; + default: + break; } } -//LCOV_EXCL_STOP static void __stc_event_cb(stc_event_info_s *event_info, void *user_data) { STC_LOGI("STC event callback [%d]", event_info->event); + stc_handle_s *handle = (stc_handle_s *)event_info->handle; + switch (event_info->event) { case STC_EVENT_STATS_GET_RSP: + if (handle->stats_cb) { + __stc_call_callback(event_info->event, event_info->error, + event_info->info_data, handle->stats_cb, + handle->stats_user_data); + + handle->stats_cb = NULL; + handle->stats_user_data = NULL; + } + break; case STC_EVENT_STATS_FOREACH_RSP: + if (handle->stats_all_cb) { + __stc_call_callback(event_info->event, event_info->error, + event_info->info_data, handle->stats_all_cb, + handle->stats_all_user_data); + + handle->stats_all_cb = NULL; + handle->stats_all_user_data = NULL; + } + break; case STC_EVENT_STATS_GET_ALL_RSP: + if (handle->get_stats_finished_cb) { + __stc_call_callback(event_info->event, event_info->error, + event_info->info_data, handle->get_stats_finished_cb, + handle->get_stats_finished_user_data); + + handle->get_stats_finished_cb = NULL; + handle->get_stats_finished_user_data = NULL; + } + break; case STC_EVENT_STATS_GET_TOTAL_RSP: + if (handle->stats_total_cb) { + __stc_call_callback(event_info->event, event_info->error, + event_info->info_data, handle->stats_total_cb, + handle->stats_total_user_data); + + handle->stats_total_cb = NULL; + handle->stats_total_user_data = NULL; + } + break; case STC_EVENT_RESTRICTION_GET_RSP: + if (handle->restriction_cb) { + __stc_call_callback(event_info->event, event_info->error, + event_info->info_data, handle->restriction_cb, + handle->restriction_user_data); + + handle->restriction_cb = NULL; + handle->restriction_user_data = NULL; + } + break; case STC_EVENT_RESTRICTION_GET_ALL_RSP: + if (handle->restriction_all_cb) { + __stc_call_callback(event_info->event, event_info->error, + event_info->info_data, handle->restriction_all_cb, + handle->restriction_all_user_data); + + handle->restriction_all_cb = NULL; + handle->restriction_all_user_data = NULL; + } + break; case STC_EVENT_PCAP_FIND_ALL_DEVS_RSP: - { - stc_error_e error = event_info->error; - GSList *info_data = (GSList *)event_info->info_data; - __stc_callback_foreach(event_info->event, - error, info_data); - g_slist_free(info_data); + if (handle->pcap_info_cb) { + __stc_call_callback(event_info->event, event_info->error, + event_info->info_data, handle->pcap_info_cb, + handle->pcap_info_user_data); + + handle->pcap_info_cb = NULL; + handle->pcap_info_user_data = NULL; } break; //LCOV_EXCL_START case STC_EVENT_WARN_THRESHOLD_CROSSED_RSP: + if (handle->warn_crossed_cb) { + __stc_call_callback(event_info->event, STC_ERROR_NONE, + event_info->info_data, handle->warn_crossed_cb, + handle->warn_crossed_user_data); + } + break; case STC_EVENT_RESTRICTION_THRESHOLD_CROSSED_RSP: - { - __stc_signal_callback(event_info->event, - event_info->info_data); - g_free(event_info->info_data); + if (handle->restriction_crossed_cb) { + __stc_call_callback(event_info->event, STC_ERROR_NONE, + event_info->info_data, handle->restriction_crossed_cb, + handle->restriction_crossed_user_data); } break; //LCOV_EXCL_STOP @@ -624,32 +612,46 @@ static void __stc_event_cb(stc_event_info_s *event_info, void *user_data) } } -int _stc_initialize(void) +int _stc_initialize(stc_h stc) { int ret = STC_ERROR_NONE; - ret = _stc_register_event_cb((stc_event_cb)__stc_event_cb, NULL); - if (ret != STC_ERROR_NONE && ret != STC_ERROR_ALREADY_INITIALIZED) { - STC_LOGE("Failed to register event callback [%s]", //LCOV_EXCL_LINE + ret = _stc_dbus_create(stc); + if (ret != STC_ERROR_NONE) { + STC_LOGE("Failed to create DBus [%s]", //LCOV_EXCL_LINE + _stc_convert_error_type_to_string(ret)); + return ret; //LCOV_EXCL_LINE + } + + ret = _stc_register_signal(stc); + if (ret != STC_ERROR_NONE) { + STC_LOGE("Failed to register DBus signal [%s]", //LCOV_EXCL_LINE _stc_convert_error_type_to_string(ret)); return ret; //LCOV_EXCL_LINE } + ret = __stc_init_service(stc); + if (ret != STC_ERROR_NONE) { + STC_LOGE("Failed to init manager [%s]", //LCOV_EXCL_LINE + _stc_convert_error_type_to_string(ret)); + return ret; //LCOV_EXCL_LINE + } + + _stc_register_event_cb(stc, (stc_event_cb)__stc_event_cb, NULL); + return STC_ERROR_NONE; } -int _stc_deinitialize(void) +int _stc_deinitialize(stc_h stc) { - int ret = STC_ERROR_NONE; + _stc_deregister_signal(stc); + _stc_dbus_destroy(stc); + _stc_deregister_event_cb(stc); - ret = _stc_deregister_event_cb(); - if (ret != STC_ERROR_NONE && ret != STC_ERROR_NOT_INITIALIZED) { - STC_LOGE("Failed to deregister event callback [%s]", //LCOV_EXCL_LINE - _stc_convert_error_type_to_string(ret)); - return ret; //LCOV_EXCL_LINE - } + if (_stc_handle_get_count() == 0) + _stc_event_clear_request_table(); - return STC_ERROR_NONE;; + return STC_ERROR_NONE; } int _stc_handle_create(stc_h *stc) @@ -664,20 +666,17 @@ int _stc_handle_create(stc_h *stc) return STC_ERROR_NONE; } -int _stc_handle_add(stc_h *stc) +void _stc_handle_add(stc_h stc) { - g_stc_handle_list = g_slist_append(g_stc_handle_list, *stc); - return STC_ERROR_NONE; + g_stc_handle_list = g_slist_append(g_stc_handle_list, stc); } -int _stc_handle_remove(stc_h stc) +void _stc_handle_remove(stc_h stc) { g_stc_handle_list = g_slist_remove(g_stc_handle_list, stc); g_free(stc); stc = NULL; - - return STC_ERROR_NONE; } bool _stc_handle_check_validity(stc_h stc) @@ -690,7 +689,7 @@ bool _stc_handle_check_validity(stc_h stc) int _stc_handle_get_count(void) { - return ((int)g_slist_length(g_stc_handle_list)); + return (int)g_slist_length(g_stc_handle_list); } void _stc_callback_set_stats_info(stc_h stc, @@ -765,4 +764,14 @@ void _stc_callback_set_warn_threshold_crossed(stc_h stc, handle->warn_crossed_cb = user_cb; handle->warn_crossed_user_data = user_data; } + +void _stc_lock(void) +{ + pthread_mutex_lock(&g_stc_thread_mutex); +} + +void _stc_unlock(void) +{ + pthread_mutex_unlock(&g_stc_thread_mutex); +} //LCOV_EXCL_STOP diff --git a/src/internal/stc-signal.c b/src/internal/stc-signal.c index 480f89b..e99e037 100755 --- a/src/internal/stc-signal.c +++ b/src/internal/stc-signal.c @@ -40,7 +40,6 @@ *****************************************************************************/ #include "stc.h" -#include "stc-private.h" #include "stc-dbus.h" #include "stc-log.h" #include "stc-util.h" @@ -57,61 +56,73 @@ /***************************************************************************** * Global Variables *****************************************************************************/ -static __thread guint gdbus_subscribe_id_stc_manager_stats = 0; -static __thread guint gdbus_subscribe_id_stc_manager_restriction = 0; /***************************************************************************** * Local Functions Definition *****************************************************************************/ //LCOV_EXCL_START -static void __stc_handle_stats(GVariant *param) +static void __stc_handle_stats(GVariant *param, stc_handle_s *stc_handle) { } -static void __stc_handle_restriction(GVariant *param) +static void __stc_handle_restriction(GVariant *param, stc_handle_s *stc_handle) { } -static void __stc_handle_warn_threshold_crossed(GVariant *param) +static void __stc_handle_warn_threshold_crossed(GVariant *param, + stc_handle_s *stc_handle) { const char *app_id = NULL; stc_iface_type_e iftype = STC_IFACE_UNKNOWN; - stc_event_info_s event_data = { 0, }; + stc_event_info_s *event_data = NULL; stc_restriction_rule_s *rule = NULL; g_variant_get(param, "(&si)", &app_id, iftype); - rule = g_try_malloc0(sizeof(stc_restriction_rule_s)); - if (rule != NULL) { - g_strlcpy(rule->app_id, app_id, STC_APP_ID_LEN); - rule->iface_type = iftype; + event_data = g_try_malloc0(sizeof(stc_event_info_s)); + if (event_data != NULL) { + rule = g_try_malloc0(sizeof(stc_restriction_rule_s)); + if (rule != NULL) { + g_strlcpy(rule->app_id, app_id, STC_APP_ID_LEN); + rule->iface_type = iftype; - event_data.event = STC_EVENT_WARN_THRESHOLD_CROSSED_RSP; - event_data.info_data = (stc_restriction_rule_h)rule; + event_data->handle = stc_handle; + event_data->event = STC_EVENT_WARN_THRESHOLD_CROSSED_RSP; + event_data->info_data = (stc_restriction_rule_h)rule; - _stc_event_add_client_idle_cb(&event_data, NULL); + stc_handle->event_handle.event_callback(event_data, NULL); + + g_free(event_data); + } } } -static void __stc_handle_restriction_threshold_crossed(GVariant *param) +static void __stc_handle_restriction_threshold_crossed(GVariant *param, + stc_handle_s *stc_handle) { const char *app_id = NULL; stc_iface_type_e iftype = STC_IFACE_UNKNOWN; - stc_event_info_s event_data = { 0, }; + stc_event_info_s *event_data = NULL; stc_restriction_rule_s *rule = NULL; g_variant_get(param, "(&si)", &app_id, iftype); - rule = g_try_malloc0(sizeof(stc_restriction_rule_s)); - if (rule != NULL) { - g_strlcpy(rule->app_id, app_id, STC_APP_ID_LEN); - rule->iface_type = iftype; + event_data = g_try_malloc0(sizeof(stc_event_info_s)); + if (event_data != NULL) { + rule = g_try_malloc0(sizeof(stc_restriction_rule_s)); + if (rule != NULL) { + g_strlcpy(rule->app_id, app_id, STC_APP_ID_LEN); + rule->iface_type = iftype; + + event_data->handle = stc_handle; + event_data->event = STC_EVENT_RESTRICTION_THRESHOLD_CROSSED_RSP; + event_data->info_data = (stc_restriction_rule_h)rule; - event_data.event = STC_EVENT_RESTRICTION_THRESHOLD_CROSSED_RSP; - event_data.info_data = (stc_restriction_rule_h)rule; + stc_handle->event_handle.event_callback(event_data, NULL); - _stc_event_add_client_idle_cb(&event_data, NULL); + g_free(event_data); + } } } @@ -119,36 +130,35 @@ static void __stc_stats_signal_filter(GDBusConnection *conn, const gchar *name, const gchar *path, const gchar *interface, const gchar *sig, GVariant *param, gpointer user_data) { + stc_handle_s *stc_handle = (stc_handle_s *)user_data; + if (g_strcmp0(sig, STC_SIGNAL_STATS) == 0) - __stc_handle_stats(param); + __stc_handle_stats(param, stc_handle); } static void __stc_restriction_signal_filter(GDBusConnection *conn, const gchar *name, const gchar *path, const gchar *interface, const gchar *sig, GVariant *param, gpointer user_data) { + stc_handle_s *stc_handle = (stc_handle_s *)user_data; + if (g_strcmp0(sig, STC_SIGNAL_RESTRICTION) == 0) - __stc_handle_restriction(param); + __stc_handle_restriction(param, stc_handle); else if (g_strcmp0(sig, STC_SIGNAL_WARN_THRESHOLD_CROSSED) == 0) - __stc_handle_warn_threshold_crossed(param); + __stc_handle_warn_threshold_crossed(param, stc_handle); else if (g_strcmp0(sig, STC_SIGNAL_RESTRICTION_THRESHOLD_CROSSED) == 0) - __stc_handle_restriction_threshold_crossed(param); + __stc_handle_restriction_threshold_crossed(param, stc_handle); else ;//Do Nothing } //LCOV_EXCL_STOP -int _stc_register_signal(void) +int _stc_register_signal(stc_h stc) { - GDBusConnection *connection; - stc_error_e err = STC_ERROR_NONE; + stc_handle_s *stc_handle = (stc_handle_s *)stc; - connection = _stc_dbus_get_connection(); - if (connection == NULL) - return STC_ERROR_NOT_INITIALIZED; - - gdbus_subscribe_id_stc_manager_stats = g_dbus_connection_signal_subscribe( - connection, + stc_handle->stats_subscribe_id = g_dbus_connection_signal_subscribe( + stc_handle->dbus_connection.connection, STC_MANAGER_SERVICE, STC_MANAGER_STATS_INTERFACE, NULL, @@ -156,11 +166,11 @@ int _stc_register_signal(void) NULL, G_DBUS_SIGNAL_FLAGS_NONE, __stc_stats_signal_filter, - NULL, + stc_handle, NULL); - gdbus_subscribe_id_stc_manager_restriction = g_dbus_connection_signal_subscribe( - connection, + stc_handle->restriction_subscribe_id = g_dbus_connection_signal_subscribe( + stc_handle->dbus_connection.connection, STC_MANAGER_SERVICE, STC_MANAGER_RESTRICTION_INTERFACE, NULL, @@ -168,39 +178,25 @@ int _stc_register_signal(void) NULL, G_DBUS_SIGNAL_FLAGS_NONE, __stc_restriction_signal_filter, - NULL, + stc_handle, NULL); - if (gdbus_subscribe_id_stc_manager_stats == 0 || - gdbus_subscribe_id_stc_manager_restriction == 0) { - STC_LOGE("Failed register signals stc_monitor[%d], stc_manager[%d]", //LCOV_EXCL_LINE - gdbus_subscribe_id_stc_manager_stats, - gdbus_subscribe_id_stc_manager_restriction); - err = STC_ERROR_NOT_INITIALIZED; //LCOV_EXCL_LINE + if (stc_handle->stats_subscribe_id == 0 || + stc_handle->restriction_subscribe_id == 0) { + STC_LOGE("Failed register signals stats[%d] restriction[%d]", //LCOV_EXCL_LINE + stc_handle->stats_subscribe_id, stc_handle->restriction_subscribe_id); + return STC_ERROR_NOT_INITIALIZED; //LCOV_EXCL_LINE } - return err; + return STC_ERROR_NONE; } -int _stc_deregister_signal(void) +void _stc_deregister_signal(stc_h stc) { - GDBusConnection *connection; - stc_error_e err = STC_ERROR_NONE; - - connection = _stc_dbus_get_connection(); - if (connection == NULL) { - STC_LOGE("Already de-registered"); //LCOV_EXCL_LINE - return STC_ERROR_NOT_INITIALIZED; //LCOV_EXCL_LINE - } - - g_dbus_connection_signal_unsubscribe(connection, - gdbus_subscribe_id_stc_manager_stats); - g_dbus_connection_signal_unsubscribe(connection, - gdbus_subscribe_id_stc_manager_restriction); - - err = _stc_dbus_destroy(); - if (err != STC_ERROR_NONE) - return err; + stc_handle_s *stc_handle = (stc_handle_s *)stc; - return err; + g_dbus_connection_signal_unsubscribe(stc_handle->dbus_connection.connection, + stc_handle->stats_subscribe_id); + g_dbus_connection_signal_unsubscribe(stc_handle->dbus_connection.connection, + stc_handle->restriction_subscribe_id); } diff --git a/src/stc-firewall.c b/src/stc-firewall.c index a704c74..4b55070 100755 --- a/src/stc-firewall.c +++ b/src/stc-firewall.c @@ -558,13 +558,13 @@ static void __stc_fw_print_rule(stc_fw_rule_s *rule) STC_LOGD(STC_HR_SINGLE); } -stc_error_e _stc_fw_lock(void) +stc_error_e _stc_fw_lock(stc_h stc) { GVariant *message = NULL; stc_error_e error = STC_ERROR_NONE; int result = 0; - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_FW_PATH, STC_MANAGER_FW_INTERFACE, @@ -582,13 +582,13 @@ stc_error_e _stc_fw_lock(void) return STC_ERROR_NONE; } -stc_error_e _stc_fw_unlock(void) +stc_error_e _stc_fw_unlock(stc_h stc) { GVariant *message = NULL; stc_error_e error = STC_ERROR_NONE; int result = 0; - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_FW_PATH, STC_MANAGER_FW_INTERFACE, @@ -606,13 +606,13 @@ stc_error_e _stc_fw_unlock(void) return STC_ERROR_NONE; } -stc_error_e _stc_fw_get_lock(stc_firewall_lock_e *state) +stc_error_e _stc_fw_get_lock(stc_h stc, stc_firewall_lock_e *state) { GVariant *message = NULL; stc_error_e error = STC_ERROR_NONE; int result = 0; - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_FW_PATH, STC_MANAGER_FW_INTERFACE, @@ -633,7 +633,7 @@ stc_error_e _stc_fw_get_lock(stc_firewall_lock_e *state) } -stc_error_e _stc_fw_chain_add(stc_fw_chain_s *chain) +stc_error_e _stc_fw_chain_add(stc_h stc, stc_fw_chain_s *chain) { GVariant *message = NULL; GVariant *params = NULL; @@ -642,7 +642,7 @@ stc_error_e _stc_fw_chain_add(stc_fw_chain_s *chain) params = g_variant_new("(s)", chain->chain); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_FW_PATH, STC_MANAGER_FW_INTERFACE, @@ -660,7 +660,7 @@ stc_error_e _stc_fw_chain_add(stc_fw_chain_s *chain) return STC_ERROR_NONE; } -stc_error_e _stc_fw_chain_remove(stc_fw_chain_s *chain) +stc_error_e _stc_fw_chain_remove(stc_h stc, stc_fw_chain_s *chain) { GVariant *message = NULL; GVariant *params = NULL; @@ -669,7 +669,7 @@ stc_error_e _stc_fw_chain_remove(stc_fw_chain_s *chain) params = g_variant_new("(s)", chain->chain); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_FW_PATH, STC_MANAGER_FW_INTERFACE, @@ -687,7 +687,7 @@ stc_error_e _stc_fw_chain_remove(stc_fw_chain_s *chain) return STC_ERROR_NONE; } -stc_error_e _stc_fw_chain_flush(stc_fw_chain_s *chain) +stc_error_e _stc_fw_chain_flush(stc_h stc, stc_fw_chain_s *chain) { GVariant *message = NULL; GVariant *params = NULL; @@ -696,7 +696,7 @@ stc_error_e _stc_fw_chain_flush(stc_fw_chain_s *chain) params = g_variant_new("(s)", chain->chain); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_FW_PATH, STC_MANAGER_FW_INTERFACE, @@ -714,7 +714,8 @@ stc_error_e _stc_fw_chain_flush(stc_fw_chain_s *chain) return STC_ERROR_NONE; } -stc_error_e _stc_fw_chain_foreach(stc_firewall_chain_info_cb callback, +stc_error_e _stc_fw_chain_foreach(stc_h stc, + stc_firewall_chain_info_cb callback, void *user_data) { GVariant *message = NULL; @@ -725,7 +726,7 @@ stc_error_e _stc_fw_chain_foreach(stc_firewall_chain_info_cb callback, GSList *list = NULL; stc_callback_ret_e rv = STC_CALLBACK_CANCEL; - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_FW_PATH, STC_MANAGER_FW_INTERFACE, @@ -764,9 +765,16 @@ stc_error_e _stc_fw_chain_foreach(stc_firewall_chain_info_cb callback, for (list = chain_list; list; list = list->next) { stc_fw_chain_s *chain = (stc_fw_chain_s *)list->data; + STC_LOCK; __stc_fw_add_to_chain_list((stc_firewall_chain_h)chain); + STC_UNLOCK; + rv = callback((stc_firewall_chain_h)chain, user_data); + + STC_LOCK; __stc_fw_remove_from_chain_list((stc_firewall_chain_h)chain); + STC_UNLOCK; + if (rv == false) break; } @@ -776,7 +784,7 @@ stc_error_e _stc_fw_chain_foreach(stc_firewall_chain_info_cb callback, return STC_ERROR_NONE; } -stc_error_e _stc_fw_chain_set(stc_fw_chain_s *chain) +stc_error_e _stc_fw_chain_set(stc_h stc, stc_fw_chain_s *chain) { GVariant *message = NULL; GVariant *params = NULL; @@ -785,7 +793,7 @@ stc_error_e _stc_fw_chain_set(stc_fw_chain_s *chain) params = g_variant_new("(su)", chain->chain, chain->target); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_FW_PATH, STC_MANAGER_FW_INTERFACE, @@ -803,7 +811,7 @@ stc_error_e _stc_fw_chain_set(stc_fw_chain_s *chain) return STC_ERROR_NONE; } -stc_error_e _stc_fw_chain_unset(stc_fw_chain_s *chain) +stc_error_e _stc_fw_chain_unset(stc_h stc, stc_fw_chain_s *chain) { GVariant *message = NULL; GVariant *params = NULL; @@ -812,7 +820,7 @@ stc_error_e _stc_fw_chain_unset(stc_fw_chain_s *chain) params = g_variant_new("(s)", chain->chain); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_FW_PATH, STC_MANAGER_FW_INTERFACE, @@ -830,7 +838,7 @@ stc_error_e _stc_fw_chain_unset(stc_fw_chain_s *chain) return STC_ERROR_NONE; } -stc_error_e _stc_fw_rule_add(stc_fw_rule_s *rule) +stc_error_e _stc_fw_rule_add(stc_h stc, stc_fw_rule_s *rule) { GVariant *message = NULL; GVariant *params = NULL; @@ -839,7 +847,7 @@ stc_error_e _stc_fw_rule_add(stc_fw_rule_s *rule) __stc_fw_make_rule_params(rule, ¶ms); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_FW_PATH, STC_MANAGER_FW_INTERFACE, @@ -857,7 +865,7 @@ stc_error_e _stc_fw_rule_add(stc_fw_rule_s *rule) return STC_ERROR_NONE; } -stc_error_e _stc_fw_rule_remove(stc_fw_rule_s *rule) +stc_error_e _stc_fw_rule_remove(stc_h stc, stc_fw_rule_s *rule) { GVariant *message = NULL; GVariant *params = NULL; @@ -866,7 +874,7 @@ stc_error_e _stc_fw_rule_remove(stc_fw_rule_s *rule) __stc_fw_make_rule_params(rule, ¶ms); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_FW_PATH, STC_MANAGER_FW_INTERFACE, @@ -884,7 +892,7 @@ stc_error_e _stc_fw_rule_remove(stc_fw_rule_s *rule) return STC_ERROR_NONE; } -stc_error_e _stc_fw_rule_update(stc_fw_rule_s *rule) +stc_error_e _stc_fw_rule_update(stc_h stc, stc_fw_rule_s *rule) { GVariant *message = NULL; GVariant *params = NULL; @@ -893,7 +901,7 @@ stc_error_e _stc_fw_rule_update(stc_fw_rule_s *rule) __stc_fw_make_rule_params(rule, ¶ms); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_FW_PATH, STC_MANAGER_FW_INTERFACE, @@ -911,7 +919,8 @@ stc_error_e _stc_fw_rule_update(stc_fw_rule_s *rule) return STC_ERROR_NONE; } -stc_error_e _stc_fw_rule_foreach(stc_firewall_rule_info_cb callback, +stc_error_e _stc_fw_rule_foreach(stc_h stc, + stc_firewall_rule_info_cb callback, void *user_data) { GVariant *message = NULL; @@ -922,7 +931,7 @@ stc_error_e _stc_fw_rule_foreach(stc_firewall_rule_info_cb callback, GSList *list = NULL; stc_callback_ret_e rv = STC_CALLBACK_CANCEL; - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_FW_PATH, STC_MANAGER_FW_INTERFACE, @@ -958,9 +967,16 @@ stc_error_e _stc_fw_rule_foreach(stc_firewall_rule_info_cb callback, for (list = rule_list; list; list = list->next) { stc_fw_rule_s *rule = (stc_fw_rule_s *)list->data; + STC_LOCK; __stc_fw_add_to_rule_list((stc_firewall_rule_h)rule); + STC_UNLOCK; + rv = callback((stc_firewall_rule_h)rule, user_data); + + STC_LOCK; __stc_fw_remove_from_rule_list((stc_firewall_rule_h)rule); + STC_UNLOCK; + if (rv == false) break; } @@ -976,20 +992,25 @@ EXPORT_API int stc_firewall_lock(stc_h stc) CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_fw_lock(); + ret = _stc_fw_lock(stc); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to lock firewall [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } STC_LOGI("Firewall successfully locked"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -999,20 +1020,25 @@ EXPORT_API int stc_firewall_unlock(stc_h stc) CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_fw_unlock(); + ret = _stc_fw_unlock(stc); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to unlock firewall [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } STC_LOGI("Firewall successfully unlocked"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1022,20 +1048,25 @@ EXPORT_API int stc_firewall_get_lock(stc_h stc, stc_firewall_lock_e *state) CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_fw_get_lock(state); + ret = _stc_fw_get_lock(stc, state); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to get firewall lock state [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } STC_LOGI("Firewall successfully get lock state"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1044,19 +1075,24 @@ EXPORT_API int stc_firewall_chain_create(stc_h stc, const char *name, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!chain_h || !name) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } stc_fw_chain_s *fw_chain = MALLOC0(stc_fw_chain_s, 1); if (!fw_chain) { STC_LOGE("Memory allocation failed"); + STC_UNLOCK; return STC_ERROR_OUT_OF_MEMORY; } @@ -1067,6 +1103,7 @@ EXPORT_API int stc_firewall_chain_create(stc_h stc, const char *name, STC_LOGI("Firewall chain successfully created"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1075,15 +1112,19 @@ EXPORT_API int stc_firewall_chain_clone(stc_firewall_chain_h origin_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_chain_validity(origin_h) == false || cloned_chain_h == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } stc_fw_chain_s *fw_chain = MALLOC0(stc_fw_chain_s, 1); if (!fw_chain) { STC_LOGE("Memory allocation failed"); + STC_UNLOCK; return STC_ERROR_OUT_OF_MEMORY; } @@ -1094,6 +1135,7 @@ EXPORT_API int stc_firewall_chain_clone(stc_firewall_chain_h origin_h, STC_LOGI("Firewall chain successfully cloned"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1101,8 +1143,11 @@ EXPORT_API int stc_firewall_chain_destroy(stc_firewall_chain_h chain_h) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_chain_validity(chain_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1111,6 +1156,7 @@ EXPORT_API int stc_firewall_chain_destroy(stc_firewall_chain_h chain_h) STC_LOGI("Firewall rule successfully destroyed"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1118,13 +1164,17 @@ EXPORT_API int stc_firewall_chain_get_name(stc_firewall_chain_h chain_h, char ** { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_chain_validity(chain_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!name) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1134,6 +1184,7 @@ EXPORT_API int stc_firewall_chain_get_name(stc_firewall_chain_h chain_h, char ** STC_LOGI("Chain [%s]", *name); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1142,13 +1193,17 @@ EXPORT_API int stc_firewall_chain_get_target(stc_firewall_chain_h chain_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_chain_validity(chain_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!target) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1158,6 +1213,7 @@ EXPORT_API int stc_firewall_chain_get_target(stc_firewall_chain_h chain_h, STC_LOGI("Target [%s]", _stc_convert_fw_chain_target_to_string(*target)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1166,13 +1222,17 @@ EXPORT_API int stc_firewall_chain_get_priority(stc_firewall_chain_h chain_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_chain_validity(chain_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!priority) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1182,84 +1242,103 @@ EXPORT_API int stc_firewall_chain_get_priority(stc_firewall_chain_h chain_h, STC_LOGI("Priority [%u]", *priority); + STC_UNLOCK; return STC_ERROR_NONE; } -EXPORT_API int stc_firewall_chain_add(stc_firewall_chain_h chain_h) +EXPORT_API int stc_firewall_chain_add(stc_h stc, stc_firewall_chain_h chain_h) { int ret = STC_ERROR_NONE; CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_chain_validity(chain_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (__stc_fw_check_chain_created(chain_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_fw_chain_add((stc_fw_chain_s *)chain_h); + ret = _stc_fw_chain_add(stc, (stc_fw_chain_s *)chain_h); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to add firewall cahin [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } -EXPORT_API int stc_firewall_chain_remove(stc_firewall_chain_h chain_h) +EXPORT_API int stc_firewall_chain_remove(stc_h stc, stc_firewall_chain_h chain_h) { int ret = STC_ERROR_NONE; CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_chain_validity(chain_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (__stc_fw_check_chain_created(chain_h) == true) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_fw_chain_remove((stc_fw_chain_s *)chain_h); + ret = _stc_fw_chain_remove(stc, (stc_fw_chain_s *)chain_h); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to remove firewall cahin [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } -EXPORT_API int stc_firewall_chain_flush(stc_firewall_chain_h chain_h) +EXPORT_API int stc_firewall_chain_flush(stc_h stc, stc_firewall_chain_h chain_h) { int ret = STC_ERROR_NONE; CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_chain_validity(chain_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (__stc_fw_check_chain_created(chain_h) == true) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_fw_chain_flush((stc_fw_chain_s *)chain_h); + ret = _stc_fw_chain_flush(stc, (stc_fw_chain_s *)chain_h); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to flush firewall cahin [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1270,17 +1349,22 @@ EXPORT_API int stc_firewall_chain_foreach(stc_h stc, CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } + STC_UNLOCK; + if (callback == NULL) { STC_LOGE("Invalid parameter"); return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_fw_chain_foreach(callback, user_data); + ret = _stc_fw_chain_foreach(stc, callback, user_data); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to get all firewall chain [%s]", _stc_convert_error_type_to_string(ret)); @@ -1290,58 +1374,70 @@ EXPORT_API int stc_firewall_chain_foreach(stc_h stc, return STC_ERROR_NONE; } -EXPORT_API int stc_firewall_chain_set(stc_firewall_chain_h chain_h, +EXPORT_API int stc_firewall_chain_set(stc_h stc, stc_firewall_chain_h chain_h, stc_firewall_chain_target_e target) { int ret = STC_ERROR_NONE; CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_chain_validity(chain_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (__stc_fw_check_chain_created(chain_h) == true) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } __stc_fw_set_chain(chain_h, target); - ret = _stc_fw_chain_set((stc_fw_chain_s *)chain_h); + ret = _stc_fw_chain_set(stc, (stc_fw_chain_s *)chain_h); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to set firewall cahin [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } -EXPORT_API int stc_firewall_chain_unset(stc_firewall_chain_h chain_h) +EXPORT_API int stc_firewall_chain_unset(stc_h stc, stc_firewall_chain_h chain_h) { int ret = STC_ERROR_NONE; CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_chain_validity(chain_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (__stc_fw_check_chain_created(chain_h) == true) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_fw_chain_unset((stc_fw_chain_s *)chain_h); + ret = _stc_fw_chain_unset(stc, (stc_fw_chain_s *)chain_h); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to unset firewall cahin [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1349,19 +1445,24 @@ EXPORT_API int stc_firewall_rule_create(stc_h stc, stc_firewall_rule_h *rule_h) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!rule_h) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } stc_fw_rule_s *fw_rule = MALLOC0(stc_fw_rule_s, 1); if (!fw_rule) { STC_LOGE("Memory allocation failed"); + STC_UNLOCK; return STC_ERROR_OUT_OF_MEMORY; } @@ -1372,6 +1473,7 @@ EXPORT_API int stc_firewall_rule_create(stc_h stc, stc_firewall_rule_h *rule_h) STC_LOGI("Firewall rule successfully created"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1380,15 +1482,19 @@ EXPORT_API int stc_firewall_rule_clone(stc_firewall_rule_h origin_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(origin_h) == false || cloned_rule_h == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } stc_fw_rule_s *fw_rule = MALLOC0(stc_fw_rule_s, 1); if (!fw_rule) { STC_LOGE("Memory allocation failed"); + STC_UNLOCK; return STC_ERROR_OUT_OF_MEMORY; } @@ -1399,6 +1505,7 @@ EXPORT_API int stc_firewall_rule_clone(stc_firewall_rule_h origin_h, STC_LOGI("Firewall rule successfully cloned"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1406,8 +1513,11 @@ EXPORT_API int stc_firewall_rule_destroy(stc_firewall_rule_h rule_h) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1416,6 +1526,7 @@ EXPORT_API int stc_firewall_rule_destroy(stc_firewall_rule_h rule_h) STC_LOGI("Firewall rule successfully destroyed"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1423,13 +1534,17 @@ EXPORT_API int stc_firewall_rule_set_chain(stc_firewall_rule_h rule_h, char *cha { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!chain || strlen(chain) == 0) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1440,6 +1555,7 @@ EXPORT_API int stc_firewall_rule_set_chain(stc_firewall_rule_h rule_h, char *cha STC_LOGI("Chain [%s]", fw_rule->chain); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1448,13 +1564,17 @@ EXPORT_API int stc_firewall_rule_set_direction(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (direction > STC_FIREWALL_DIRECTION_OUT) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1464,6 +1584,7 @@ EXPORT_API int stc_firewall_rule_set_direction(stc_firewall_rule_h rule_h, STC_LOGI("Direction [%u]", fw_rule->direction); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1472,13 +1593,17 @@ EXPORT_API int stc_firewall_rule_set_src_ip_type(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (type > STC_FIREWALL_IP_RANGE) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1488,6 +1613,7 @@ EXPORT_API int stc_firewall_rule_set_src_ip_type(stc_firewall_rule_h rule_h, STC_LOGI("Source IP type [%u]", fw_rule->s_ip_type); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1496,13 +1622,17 @@ EXPORT_API int stc_firewall_rule_set_dst_ip_type(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (type > STC_FIREWALL_IP_RANGE) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1512,6 +1642,7 @@ EXPORT_API int stc_firewall_rule_set_dst_ip_type(stc_firewall_rule_h rule_h, STC_LOGI("Destination IP type [%u]", fw_rule->d_ip_type); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1520,13 +1651,17 @@ EXPORT_API int stc_firewall_rule_set_src_port_type(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (type > STC_FIREWALL_PORT_RANGE) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1536,6 +1671,7 @@ EXPORT_API int stc_firewall_rule_set_src_port_type(stc_firewall_rule_h rule_h, STC_LOGI("Source port type [%u]", fw_rule->s_port_type); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1544,13 +1680,17 @@ EXPORT_API int stc_firewall_rule_set_dst_port_type(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (type > STC_FIREWALL_PORT_RANGE) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1560,6 +1700,7 @@ EXPORT_API int stc_firewall_rule_set_dst_port_type(stc_firewall_rule_h rule_h, STC_LOGI("Destination port type [%u]", fw_rule->d_port_type); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1568,13 +1709,17 @@ EXPORT_API int stc_firewall_rule_set_protocol_type(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (type > STC_FIREWALL_PROTOCOL_ALL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1584,6 +1729,7 @@ EXPORT_API int stc_firewall_rule_set_protocol_type(stc_firewall_rule_h rule_h, STC_LOGI("Protocol type [%u]", fw_rule->protocol); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1592,13 +1738,17 @@ EXPORT_API int stc_firewall_rule_set_family_type(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (type > STC_FIREWALL_FAMILY_V6) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1608,6 +1758,7 @@ EXPORT_API int stc_firewall_rule_set_family_type(stc_firewall_rule_h rule_h, STC_LOGI("Family type [%u]", fw_rule->family); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1616,8 +1767,11 @@ EXPORT_API int stc_firewall_rule_set_src_ip(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1630,6 +1784,7 @@ EXPORT_API int stc_firewall_rule_set_src_ip(stc_firewall_rule_h rule_h, STC_LOGI("Source IP [%s:%s]", fw_rule->s_ip1, fw_rule->s_ip2); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1638,8 +1793,11 @@ EXPORT_API int stc_firewall_rule_set_dst_ip(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1652,6 +1810,7 @@ EXPORT_API int stc_firewall_rule_set_dst_ip(stc_firewall_rule_h rule_h, STC_LOGI("Destination IP [%s:%s]", fw_rule->d_ip1, fw_rule->d_ip2); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1660,8 +1819,11 @@ EXPORT_API int stc_firewall_rule_set_src_port(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1672,6 +1834,7 @@ EXPORT_API int stc_firewall_rule_set_src_port(stc_firewall_rule_h rule_h, STC_LOGI("Source port [%u:%u]", fw_rule->s_port1, fw_rule->s_port2); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1680,8 +1843,11 @@ EXPORT_API int stc_firewall_rule_set_dst_port(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1692,6 +1858,7 @@ EXPORT_API int stc_firewall_rule_set_dst_port(stc_firewall_rule_h rule_h, STC_LOGI("Destination port [%u:%u]", fw_rule->d_port1, fw_rule->d_port2); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1699,8 +1866,11 @@ EXPORT_API int stc_firewall_rule_set_ifname(stc_firewall_rule_h rule_h, char *if { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1711,6 +1881,7 @@ EXPORT_API int stc_firewall_rule_set_ifname(stc_firewall_rule_h rule_h, char *if STC_LOGI("Interface name [%s]", fw_rule->ifname); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1719,8 +1890,11 @@ EXPORT_API int stc_firewall_rule_set_target(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1731,6 +1905,7 @@ EXPORT_API int stc_firewall_rule_set_target(stc_firewall_rule_h rule_h, STC_LOGI("Target [%s]", _stc_convert_fw_rule_target_to_string(fw_rule->target)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1739,8 +1914,11 @@ EXPORT_API int stc_firewall_rule_set_log_level(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1750,6 +1928,7 @@ EXPORT_API int stc_firewall_rule_set_log_level(stc_firewall_rule_h rule_h, STC_LOGI("Log level [%u]", fw_rule->log_level); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1758,8 +1937,11 @@ EXPORT_API int stc_firewall_rule_set_log_prefix(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1770,6 +1952,7 @@ EXPORT_API int stc_firewall_rule_set_log_prefix(stc_firewall_rule_h rule_h, STC_LOGI("Log prefix [%s]", fw_rule->log_prefix); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1778,8 +1961,11 @@ EXPORT_API int stc_firewall_rule_set_nflog_group(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1789,6 +1975,7 @@ EXPORT_API int stc_firewall_rule_set_nflog_group(stc_firewall_rule_h rule_h, STC_LOGI("Nflog group [%d]", fw_rule->nflog_group); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1797,8 +1984,11 @@ EXPORT_API int stc_firewall_rule_set_nflog_prefix(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1809,6 +1999,7 @@ EXPORT_API int stc_firewall_rule_set_nflog_prefix(stc_firewall_rule_h rule_h, STC_LOGI("Nflog prefix [%s]", fw_rule->nflog_prefix); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1817,8 +2008,11 @@ EXPORT_API int stc_firewall_rule_set_nflog_range(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1828,6 +2022,7 @@ EXPORT_API int stc_firewall_rule_set_nflog_range(stc_firewall_rule_h rule_h, STC_LOGI("Nflog range [%d]", fw_rule->nflog_range); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1836,8 +2031,11 @@ EXPORT_API int stc_firewall_rule_set_nflog_threshold(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1847,6 +2045,7 @@ EXPORT_API int stc_firewall_rule_set_nflog_threshold(stc_firewall_rule_h rule_h, STC_LOGI("Nflog threshold [%d]", fw_rule->nflog_threshold); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1854,13 +2053,17 @@ EXPORT_API int stc_firewall_rule_get_chain(stc_firewall_rule_h rule_h, char **ch { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!chain) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1870,6 +2073,7 @@ EXPORT_API int stc_firewall_rule_get_chain(stc_firewall_rule_h rule_h, char **ch STC_LOGI("Chain [%s]", *chain); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1878,13 +2082,17 @@ EXPORT_API int stc_firewall_rule_get_direction(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!direction) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1894,6 +2102,7 @@ EXPORT_API int stc_firewall_rule_get_direction(stc_firewall_rule_h rule_h, STC_LOGI("Direction [%s]", _stc_convert_fw_direction_to_string(*direction)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1902,13 +2111,17 @@ EXPORT_API int stc_firewall_rule_get_src_ip_type(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!type) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1918,6 +2131,7 @@ EXPORT_API int stc_firewall_rule_get_src_ip_type(stc_firewall_rule_h rule_h, STC_LOGI("Source IP type [%s]", _stc_convert_fw_ip_type_to_string(*type)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1926,13 +2140,17 @@ EXPORT_API int stc_firewall_rule_get_dst_ip_type(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!type) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1942,6 +2160,7 @@ EXPORT_API int stc_firewall_rule_get_dst_ip_type(stc_firewall_rule_h rule_h, STC_LOGI("Destination IP type [%s]", _stc_convert_fw_ip_type_to_string(*type)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1950,13 +2169,17 @@ EXPORT_API int stc_firewall_rule_get_src_port_type(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!type) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1966,6 +2189,7 @@ EXPORT_API int stc_firewall_rule_get_src_port_type(stc_firewall_rule_h rule_h, STC_LOGI("Source port type [%s]", _stc_convert_fw_port_type_to_string(*type)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1974,13 +2198,17 @@ EXPORT_API int stc_firewall_rule_get_dst_port_type(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!type) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1990,6 +2218,7 @@ EXPORT_API int stc_firewall_rule_get_dst_port_type(stc_firewall_rule_h rule_h, STC_LOGI("Destination port type [%s]", _stc_convert_fw_port_type_to_string(*type)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1998,13 +2227,17 @@ EXPORT_API int stc_firewall_rule_get_protocol_type(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!type) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -2014,6 +2247,7 @@ EXPORT_API int stc_firewall_rule_get_protocol_type(stc_firewall_rule_h rule_h, STC_LOGI("Protocol type [%s]", _stc_convert_fw_protocol_type_to_string(*type)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -2022,13 +2256,17 @@ EXPORT_API int stc_firewall_rule_get_family_type(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!type) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -2038,6 +2276,7 @@ EXPORT_API int stc_firewall_rule_get_family_type(stc_firewall_rule_h rule_h, STC_LOGI("Address family type [%s]", _stc_convert_fw_family_type_to_string(*type)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -2046,13 +2285,17 @@ EXPORT_API int stc_firewall_rule_get_src_ip(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!ip1 || !ip2) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -2063,6 +2306,7 @@ EXPORT_API int stc_firewall_rule_get_src_ip(stc_firewall_rule_h rule_h, STC_LOGI("Source IP [%s:%s]", *ip1, *ip2); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -2071,13 +2315,17 @@ EXPORT_API int stc_firewall_rule_get_dst_ip(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!ip1 || !ip2) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -2088,6 +2336,7 @@ EXPORT_API int stc_firewall_rule_get_dst_ip(stc_firewall_rule_h rule_h, STC_LOGI("Destination IP [%s:%s]", *ip1, *ip2); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -2096,13 +2345,17 @@ EXPORT_API int stc_firewall_rule_get_src_port(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!port1 || !port2) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -2113,6 +2366,7 @@ EXPORT_API int stc_firewall_rule_get_src_port(stc_firewall_rule_h rule_h, STC_LOGI("Source port [%u:%u]", *port1, *port2); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -2121,13 +2375,17 @@ EXPORT_API int stc_firewall_rule_get_dst_port(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!port1 || !port2) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -2138,6 +2396,7 @@ EXPORT_API int stc_firewall_rule_get_dst_port(stc_firewall_rule_h rule_h, STC_LOGI("Destination port [%u:%u]", *port1, *port2); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -2145,13 +2404,17 @@ EXPORT_API int stc_firewall_rule_get_ifname(stc_firewall_rule_h rule_h, char **i { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!ifname) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -2161,6 +2424,7 @@ EXPORT_API int stc_firewall_rule_get_ifname(stc_firewall_rule_h rule_h, char **i STC_LOGI("Interface name [%s]", *ifname); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -2169,13 +2433,17 @@ EXPORT_API int stc_firewall_rule_get_target(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!target) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -2185,6 +2453,7 @@ EXPORT_API int stc_firewall_rule_get_target(stc_firewall_rule_h rule_h, STC_LOGI("Target [%s]", _stc_convert_fw_rule_target_to_string(*target)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -2193,13 +2462,17 @@ EXPORT_API int stc_firewall_rule_get_log_level(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!level) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -2209,6 +2482,7 @@ EXPORT_API int stc_firewall_rule_get_log_level(stc_firewall_rule_h rule_h, STC_LOGI("Log level [%u]", *level); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -2217,13 +2491,17 @@ EXPORT_API int stc_firewall_rule_get_log_prefix(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!prefix) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -2233,6 +2511,7 @@ EXPORT_API int stc_firewall_rule_get_log_prefix(stc_firewall_rule_h rule_h, STC_LOGI("Log prefix [%s]", *prefix); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -2241,13 +2520,17 @@ EXPORT_API int stc_firewall_rule_get_nflog_group(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!group) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -2257,6 +2540,7 @@ EXPORT_API int stc_firewall_rule_get_nflog_group(stc_firewall_rule_h rule_h, STC_LOGI("Nflog group [%d]", *group); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -2265,13 +2549,17 @@ EXPORT_API int stc_firewall_rule_get_nflog_prefix(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!prefix) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -2281,6 +2569,7 @@ EXPORT_API int stc_firewall_rule_get_nflog_prefix(stc_firewall_rule_h rule_h, STC_LOGI("Nflog prefix [%s]", *prefix); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -2289,13 +2578,17 @@ EXPORT_API int stc_firewall_rule_get_nflog_range(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!range) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -2305,6 +2598,7 @@ EXPORT_API int stc_firewall_rule_get_nflog_range(stc_firewall_rule_h rule_h, STC_LOGI("Nflog range [%d]", *range); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -2313,13 +2607,17 @@ EXPORT_API int stc_firewall_rule_get_nflog_threshold(stc_firewall_rule_h rule_h, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!threshold) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -2329,84 +2627,103 @@ EXPORT_API int stc_firewall_rule_get_nflog_threshold(stc_firewall_rule_h rule_h, STC_LOGI("Nflog threshold [%d]", *threshold); + STC_UNLOCK; return STC_ERROR_NONE; } -EXPORT_API int stc_firewall_rule_add(stc_firewall_rule_h rule_h) +EXPORT_API int stc_firewall_rule_add(stc_h stc, stc_firewall_rule_h rule_h) { int ret = STC_ERROR_NONE; CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (__stc_fw_check_rule_created(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_fw_rule_add((stc_fw_rule_s *)rule_h); + ret = _stc_fw_rule_add(stc, (stc_fw_rule_s *)rule_h); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to add firewall rule [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } -EXPORT_API int stc_firewall_rule_remove(stc_firewall_rule_h rule_h) +EXPORT_API int stc_firewall_rule_remove(stc_h stc, stc_firewall_rule_h rule_h) { int ret = STC_ERROR_NONE; CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (__stc_fw_check_rule_created(rule_h) == true) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_fw_rule_remove((stc_fw_rule_s *)rule_h); + ret = _stc_fw_rule_remove(stc, (stc_fw_rule_s *)rule_h); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to remove firewall rule [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } -EXPORT_API int stc_firewall_rule_update(stc_firewall_rule_h rule_h) +EXPORT_API int stc_firewall_rule_update(stc_h stc, stc_firewall_rule_h rule_h) { int ret = STC_ERROR_NONE; CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (__stc_fw_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (__stc_fw_check_rule_created(rule_h) == true) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_fw_rule_update((stc_fw_rule_s *)rule_h); + ret = _stc_fw_rule_update(stc, (stc_fw_rule_s *)rule_h); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to update firewall rule [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } EXPORT_API int stc_firewall_rule_foreach(stc_h stc, @@ -2416,17 +2733,22 @@ EXPORT_API int stc_firewall_rule_foreach(stc_h stc, CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC_FW); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } + STC_UNLOCK; + if (callback == NULL) { STC_LOGE("Invalid parameter"); return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_fw_rule_foreach(callback, user_data); + ret = _stc_fw_rule_foreach(stc, callback, user_data); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to get all firewall rule [%s]", _stc_convert_error_type_to_string(ret)); diff --git a/src/stc-manager.c b/src/stc-manager.c index 83e1897..2a9742a 100755 --- a/src/stc-manager.c +++ b/src/stc-manager.c @@ -65,8 +65,8 @@ *****************************************************************************/ //LCOV_EXCL_START -stc_error_e _stc_iptables_commit(const char *option, - int *err_num, char **err_str) +stc_error_e _stc_iptables_commit(stc_h stc, + const char *option, int *err_num, char **err_str) { GVariant *message = NULL; GVariant *params = NULL; @@ -77,7 +77,7 @@ stc_error_e _stc_iptables_commit(const char *option, params = g_variant_new("(s)", option); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_PATH, STC_MANAGER_INTERFACE, @@ -103,8 +103,8 @@ stc_error_e _stc_iptables_commit(const char *option, return STC_ERROR_OPERATION_FAILED; } -stc_error_e _stc_ip6tables_commit(const char *option, - int *err_num, char **err_str) +stc_error_e _stc_ip6tables_commit(stc_h stc, + const char *option, int *err_num, char **err_str) { GVariant *message = NULL; GVariant *params = NULL; @@ -115,7 +115,7 @@ stc_error_e _stc_ip6tables_commit(const char *option, params = g_variant_new("(s)", option); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_PATH, STC_MANAGER_INTERFACE, @@ -147,8 +147,11 @@ EXPORT_API int stc_reset_stats(stc_h stc, stc_reset_rule_h rule) CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -156,18 +159,21 @@ EXPORT_API int stc_reset_stats(stc_h stc, stc_reset_rule_h rule) if (ret != STC_ERROR_NONE) { STC_LOGE("Invalid reset rule [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } - ret = _stc_reset_stats(rule); + ret = _stc_reset_stats(stc, rule); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to reset stats [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } STC_LOGI("Reset stats"); + STC_UNLOCK; return STC_ERROR_NONE; } //LCOV_EXCL_STOP @@ -179,13 +185,17 @@ EXPORT_API int stc_get_stats(stc_h stc, stc_stats_rule_h rule, CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER;//LCOV_EXCL_LINE } if (info_cb == NULL) { STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } @@ -193,19 +203,22 @@ EXPORT_API int stc_get_stats(stc_h stc, stc_stats_rule_h rule, if (ret != STC_ERROR_NONE) { STC_LOGE("Invalid stats rule [%s]", //LCOV_EXCL_LINE _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; //LCOV_EXCL_LINE } _stc_callback_set_stats_info(stc, info_cb, user_data); - ret = _stc_stats_get(rule); + ret = _stc_stats_get(stc, rule); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to request stats info [%s]", //LCOV_EXCL_LINE _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; //LCOV_EXCL_LINE } + STC_UNLOCK; return STC_ERROR_NONE; } @@ -216,13 +229,17 @@ EXPORT_API int stc_foreach_stats(stc_h stc, stc_stats_rule_h rule, CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } if (info_cb == NULL) { STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } @@ -230,19 +247,22 @@ EXPORT_API int stc_foreach_stats(stc_h stc, stc_stats_rule_h rule, if (ret != STC_ERROR_NONE) { STC_LOGE("Invalid stats rule [%s]", //LCOV_EXCL_LINE _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; //LCOV_EXCL_LINE } _stc_callback_set_stats_all_info(stc, info_cb, user_data); - ret = _stc_stats_foreach(rule); + ret = _stc_stats_foreach(stc, rule); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to request stats all info [%s]", //LCOV_EXCL_LINE _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; //LCOV_EXCL_LINE } + STC_UNLOCK; return STC_ERROR_NONE; } @@ -253,13 +273,17 @@ int stc_get_all_stats(stc_h stc, stc_stats_rule_h rule, CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } if (finished_cb == NULL) { STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } @@ -267,37 +291,49 @@ int stc_get_all_stats(stc_h stc, stc_stats_rule_h rule, if (ret != STC_ERROR_NONE) { STC_LOGE("Invalid stats rule [%s]", //LCOV_EXCL_LINE _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; //LCOV_EXCL_LINE } _stc_callback_set_stats_get_all_info(stc, finished_cb, user_data); - ret = _stc_stats_get_all(rule); + ret = _stc_stats_get_all(stc, rule); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to request stats all info [%s]", //LCOV_EXCL_LINE _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; //LCOV_EXCL_LINE } + STC_UNLOCK; return STC_ERROR_NONE; } int stc_foreach_all_stats(stc_all_stats_info_h info, stc_stats_info_cb info_cb, void *user_data) { + int ret = STC_ERROR_NONE; + CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (info == NULL) { - STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE - return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE - } + STC_LOCK; if (info_cb == NULL) { STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } - return _stc_stats_foreach_all(info, info_cb, user_data); + ret = _stc_stats_foreach_all(info, info_cb, user_data); + if (ret != STC_ERROR_NONE) { + STC_LOGE("Failed to get all stats info [%s]", //LCOV_EXCL_LINE + _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; + return ret; + } + + STC_UNLOCK; + return STC_ERROR_NONE; } EXPORT_API int stc_get_total_stats(stc_h stc, stc_stats_rule_h rule, @@ -307,13 +343,17 @@ EXPORT_API int stc_get_total_stats(stc_h stc, stc_stats_rule_h rule, CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } if (info_cb == NULL) { STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } @@ -321,19 +361,22 @@ EXPORT_API int stc_get_total_stats(stc_h stc, stc_stats_rule_h rule, if (ret != STC_ERROR_NONE) { STC_LOGE("Invalid stats rule [%s]", //LCOV_EXCL_LINE _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; //LCOV_EXCL_LINE } _stc_callback_set_stats_total_info(stc, info_cb, user_data); - ret = _stc_stats_get_total(rule); + ret = _stc_stats_get_total(stc, rule); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to request stats total info [%s]", //LCOV_EXCL_LINE _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; //LCOV_EXCL_LINE } + STC_UNLOCK; return STC_ERROR_NONE; } @@ -345,13 +388,17 @@ EXPORT_API int stc_set_restriction(stc_h stc, CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -359,16 +406,19 @@ EXPORT_API int stc_set_restriction(stc_h stc, if (ret != STC_ERROR_NONE) { STC_LOGE("Invalid restriction rule [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } - ret = _stc_restriction_set(rule); + ret = _stc_restriction_set(stc, rule); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to set restriction [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } @@ -378,13 +428,17 @@ EXPORT_API int stc_unset_restriction(stc_h stc, stc_restriction_rule_h rule) CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -392,16 +446,19 @@ EXPORT_API int stc_unset_restriction(stc_h stc, stc_restriction_rule_h rule) if (ret != STC_ERROR_NONE) { STC_LOGE("Invalid restriction rule [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } - ret = _stc_restriction_unset(rule); + ret = _stc_restriction_unset(stc, rule); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to unset restriction [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } @@ -412,18 +469,23 @@ EXPORT_API int stc_get_restriction(stc_h stc, stc_restriction_rule_h rule, CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (rule_cb == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -431,19 +493,22 @@ EXPORT_API int stc_get_restriction(stc_h stc, stc_restriction_rule_h rule, if (ret != STC_ERROR_NONE) { STC_LOGE("Invalid restriction rule [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } _stc_callback_set_restriction_rule(stc, rule_cb, user_data); - ret = _stc_restriction_get(rule); + ret = _stc_restriction_get(stc, rule); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to request restriction rule [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } @@ -452,18 +517,23 @@ EXPORT_API int stc_set_restriction_threshold_crossed_cb(stc_h stc, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (crossed_cb == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } _stc_callback_set_restriction_threshold_crossed(stc, crossed_cb, user_data); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -471,13 +541,17 @@ EXPORT_API int stc_unset_restriction_threshold_crossed_cb(stc_h stc) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } _stc_callback_set_restriction_threshold_crossed(stc, NULL, NULL); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -486,18 +560,23 @@ EXPORT_API int stc_set_warn_threshold_crossed_cb(stc_h stc, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (crossed_cb == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } _stc_callback_set_warn_threshold_crossed(stc, crossed_cb, user_data); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -505,13 +584,17 @@ EXPORT_API int stc_unset_warn_threshold_crossed_cb(stc_h stc) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } _stc_callback_set_warn_threshold_crossed(stc, NULL, NULL); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -522,18 +605,23 @@ EXPORT_API int stc_foreach_restriction(stc_h stc, stc_restriction_rule_h rule, CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (rule_cb == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -541,19 +629,22 @@ EXPORT_API int stc_foreach_restriction(stc_h stc, stc_restriction_rule_h rule, if (ret != STC_ERROR_NONE) { STC_LOGE("Invalid restriction rule [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } _stc_callback_set_restriction_all_rule(stc, rule_cb, user_data); - ret = _stc_restriction_get_all(rule); + ret = _stc_restriction_get_all(stc, rule); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to request restriction all rule [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } @@ -564,13 +655,17 @@ EXPORT_API int stc_get_restriction_type(stc_h stc, stc_restriction_rule_h rule, CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -578,18 +673,21 @@ EXPORT_API int stc_get_restriction_type(stc_h stc, stc_restriction_rule_h rule, if (ret != STC_ERROR_NONE) { STC_LOGE("Invalid restriction rule [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } - ret = _stc_restriction_get_type(rule, type); + ret = _stc_restriction_get_type(stc, rule, type); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to get restriction type [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } STC_LOGI("Get restriction type"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -600,13 +698,17 @@ EXPORT_API int stc_add_restriction_rule_to_list(stc_restriction_list_h list_h, CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_list_validity(list_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (_stc_restriction_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -614,17 +716,20 @@ EXPORT_API int stc_add_restriction_rule_to_list(stc_restriction_list_h list_h, if (ret != STC_ERROR_NONE) { STC_LOGE("Invalid restriction rule [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } if (_stc_restriction_add_rule_to_list(list_h, rule_h) == false) { STC_LOGE("Failed to add restriction rule to list[%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } STC_LOGI("Added restriction rule to list"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -635,13 +740,17 @@ EXPORT_API int stc_remove_restriction_rule_from_list(stc_restriction_list_h list CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_list_validity(list_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (_stc_restriction_check_rule_validity(rule_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -649,36 +758,53 @@ EXPORT_API int stc_remove_restriction_rule_from_list(stc_restriction_list_h list if (ret != STC_ERROR_NONE) { STC_LOGE("Invalid restriction rule [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } if (_stc_restriction_remove_rule_from_list(list_h, rule_h) == false) { STC_LOGE("Failed to remove restriction rule from list[%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } STC_LOGI("Removed restriction rule from list"); + STC_UNLOCK; return STC_ERROR_NONE; } EXPORT_API int stc_foreach_restriction_rule_from_list(stc_restriction_list_h list_h, stc_restriction_rule_cb rule_cb, void *user_data) { + int ret = STC_ERROR_NONE; + CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_list_validity(list_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } + STC_UNLOCK; + if (rule_cb == NULL) { STC_LOGE("Invalid parameter"); return STC_ERROR_INVALID_PARAMETER; } - return _stc_restriction_foreach_rule_from_list(list_h, rule_cb, user_data); + ret = _stc_restriction_foreach_rule_from_list(list_h, rule_cb, user_data); + if (ret != STC_ERROR_NONE) { + STC_LOGE("Failed to get restriction rule from list[%s]", + _stc_convert_error_type_to_string(ret)); + return ret; + } + + return STC_ERROR_NONE; } EXPORT_API int stc_set_restriction_list(stc_h stc, stc_restriction_list_h list_h) @@ -687,23 +813,29 @@ EXPORT_API int stc_set_restriction_list(stc_h stc, stc_restriction_list_h list_h CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (_stc_restriction_check_list_validity(list_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_restriction_set_list(list_h); + ret = _stc_restriction_set_list(stc, list_h); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to set restriction [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } @@ -713,23 +845,29 @@ EXPORT_API int stc_unset_restriction_list(stc_h stc, stc_restriction_list_h list CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (_stc_restriction_check_list_validity(list_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_restriction_unset_list(list_h); + ret = _stc_restriction_unset_list(stc, list_h); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to unset restriction [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } @@ -740,23 +878,29 @@ EXPORT_API int stc_iptables_commit(stc_h stc, const char *option, CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (option == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_iptables_commit(option, err_num, err_str); + ret = _stc_iptables_commit(stc, option, err_num, err_str); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to commit iptables [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } @@ -767,23 +911,29 @@ EXPORT_API int stc_ip6tables_commit(stc_h stc, const char *option, CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (option == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_ip6tables_commit(option, err_num, err_str); + ret = _stc_ip6tables_commit(stc, option, err_num, err_str); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to commit ip6tables [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } //LCOV_EXCL_STOP diff --git a/src/stc-pcap.c b/src/stc-pcap.c index 9f68500..2c3cb7b 100755 --- a/src/stc-pcap.c +++ b/src/stc-pcap.c @@ -117,10 +117,13 @@ static void __stc_pcap_add_to_list(stc_pcap_h pcap_h) static bool __stc_pcap_check_validity(stc_pcap_h pcap_h) { + GSList *find; + if (!pcap_h) return false; - if (g_slist_find(g_pcap_list, pcap_h)) + find = g_slist_find(g_pcap_list, pcap_h); + if (find) return true; else return false; @@ -224,7 +227,8 @@ static void __stc_pcap_find_all_devs_reply( GVariantIter *iter_row = NULL; stc_error_e error = STC_ERROR_NONE; GSList *dev_list = NULL; - stc_event_info_s event_data = { 0, }; + stc_event_info_s *event_data = NULL; + stc_handle_s *stc_handle = (stc_handle_s *)user_data; conn = G_DBUS_CONNECTION(source_object); dbus_data = g_dbus_connection_call_finish(conn, res, &dbus_error); @@ -239,39 +243,48 @@ static void __stc_pcap_find_all_devs_reply( if (error == STC_ERROR_NONE) { g_variant_get(dbus_data, "(aa{sv})", &iter); - while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { - stc_pcap_s *pcap = MALLOC0(stc_pcap_s, 1); - if (pcap != NULL) { - _stc_dbus_dictionary_foreach(iter_row, - __stc_pcap_dev_extract, pcap); + event_data = g_try_malloc0(sizeof(stc_event_info_s)); + if (event_data != NULL) { + while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { + stc_pcap_s *pcap = MALLOC0(stc_pcap_s, 1); + if (pcap != NULL) { + _stc_dbus_dictionary_foreach(iter_row, + __stc_pcap_dev_extract, pcap); - __stc_pcap_dev_print(pcap); + __stc_pcap_dev_print(pcap); - dev_list = g_slist_append(dev_list, (stc_pcap_s *)pcap); + dev_list = g_slist_append(dev_list, (stc_pcap_s *)pcap); - g_variant_iter_free(iter_row); + g_variant_iter_free(iter_row); + } } - } - g_variant_iter_free(iter); + g_variant_iter_free(iter); - event_data.event = STC_EVENT_PCAP_FIND_ALL_DEVS_RSP; - event_data.info_data = (GSList *)dev_list; - event_data.datalength = g_slist_length(dev_list); - event_data.error = STC_ERROR_NONE; + event_data->handle = stc_handle; + event_data->event = STC_EVENT_PCAP_FIND_ALL_DEVS_RSP; + event_data->info_data = (GSList *)dev_list; + event_data->datalength = g_slist_length(dev_list); + event_data->error = STC_ERROR_NONE; + } } else { STC_LOGE("Find all devs response error [%s]", _stc_convert_error_type_to_string(error)); - event_data.event = STC_EVENT_PCAP_FIND_ALL_DEVS_RSP; - event_data.info_data = NULL; - event_data.datalength = 0; - event_data.error = error; + event_data = g_try_malloc0(sizeof(stc_event_info_s)); + if (event_data != NULL) { + event_data->handle = stc_handle; + event_data->event = STC_EVENT_PCAP_FIND_ALL_DEVS_RSP; + event_data->info_data = NULL; + event_data->datalength = 0; + event_data->error = error; + } } - _stc_event_add_client_idle_cb(&event_data, user_data); + stc_handle->event_handle.event_callback(event_data, user_data); + g_free(event_data); } -stc_error_e _stc_pcap_start(stc_pcap_s *pcap) +stc_error_e _stc_pcap_start(stc_h stc, stc_pcap_s *pcap) { GVariant *message = NULL; GVariant *params = NULL; @@ -280,7 +293,7 @@ stc_error_e _stc_pcap_start(stc_pcap_s *pcap) __stc_pcap_make_params(pcap, ¶ms); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_PCAP_PATH, STC_MANAGER_PCAP_INTERFACE, @@ -298,7 +311,7 @@ stc_error_e _stc_pcap_start(stc_pcap_s *pcap) return STC_ERROR_NONE; } -stc_error_e _stc_pcap_stop(stc_pcap_s *pcap) +stc_error_e _stc_pcap_stop(stc_h stc, stc_pcap_s *pcap) { GVariant *message = NULL; GVariant *params = NULL; @@ -307,7 +320,7 @@ stc_error_e _stc_pcap_stop(stc_pcap_s *pcap) __stc_pcap_make_params(pcap, ¶ms); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_PCAP_PATH, STC_MANAGER_PCAP_INTERFACE, @@ -325,7 +338,8 @@ stc_error_e _stc_pcap_stop(stc_pcap_s *pcap) return STC_ERROR_NONE; } -stc_error_e _stc_pcap_foreach(stc_pcap_info_cb callback, +stc_error_e _stc_pcap_foreach(stc_h stc, + stc_pcap_info_cb callback, void *user_data) { GVariant *message = NULL; @@ -336,7 +350,7 @@ stc_error_e _stc_pcap_foreach(stc_pcap_info_cb callback, GSList *list = NULL; stc_callback_ret_e rv = STC_CALLBACK_CANCEL; - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_PCAP_PATH, STC_MANAGER_PCAP_INTERFACE, @@ -372,9 +386,16 @@ stc_error_e _stc_pcap_foreach(stc_pcap_info_cb callback, for (list = pcap_list; list; list = list->next) { stc_pcap_s *pcap = (stc_pcap_s *)list->data; + STC_LOCK; __stc_pcap_add_to_list((stc_pcap_h)pcap); + STC_UNLOCK; + rv = callback((stc_pcap_h)pcap, user_data); + + STC_LOCK; __stc_pcap_remove_from_list((stc_pcap_h)pcap); + STC_UNLOCK; + if (rv == false) break; } @@ -384,7 +405,8 @@ stc_error_e _stc_pcap_foreach(stc_pcap_info_cb callback, return STC_ERROR_NONE; } -stc_error_e _stc_pcap_find_all_devs(stc_pcap_info_cb callback, +stc_error_e _stc_pcap_find_all_devs(stc_h stc, + stc_pcap_info_cb callback, void *user_data) { stc_error_e error = STC_ERROR_NONE; @@ -398,7 +420,7 @@ stc_error_e _stc_pcap_find_all_devs(stc_pcap_info_cb callback, _stc_event_set_request_table_state( STC_REQUEST_TABLE_PCAP_FIND_ALL_DEVS, true); - error = _stc_dbus_invoke_method_nonblock( + error = _stc_dbus_invoke_method_nonblock(stc, STC_MANAGER_SERVICE, STC_MANAGER_PCAP_PATH, STC_MANAGER_PCAP_INTERFACE, @@ -406,7 +428,7 @@ stc_error_e _stc_pcap_find_all_devs(stc_pcap_info_cb callback, NULL, STC_DBUS_REPLY_TIMEOUT, __stc_pcap_find_all_devs_reply, - NULL); + stc); if (error != STC_ERROR_NONE) { STC_LOGE("Failed to invoke dbus method nonblock"); //LCOV_EXCL_LINE @@ -432,19 +454,24 @@ EXPORT_API int stc_pcap_create(stc_h stc, stc_pcap_h *pcap_h) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!pcap_h) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } stc_pcap_s *pcap = MALLOC0(stc_pcap_s, 1); if (!pcap) { STC_LOGE("Memory allocation failed"); + STC_UNLOCK; return STC_ERROR_OUT_OF_MEMORY; } @@ -455,6 +482,7 @@ EXPORT_API int stc_pcap_create(stc_h stc, stc_pcap_h *pcap_h) STC_LOGI("Successfully created pcap handle"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -462,8 +490,11 @@ EXPORT_API int stc_pcap_destroy(stc_pcap_h pcap_h) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (__stc_pcap_check_validity(pcap_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -472,6 +503,7 @@ EXPORT_API int stc_pcap_destroy(stc_pcap_h pcap_h) STC_LOGI("Successfully destroyed pcap handle"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -481,28 +513,35 @@ EXPORT_API int stc_pcap_start(stc_h stc, stc_pcap_h pcap_h) CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (__stc_pcap_check_validity(pcap_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (__stc_pcap_check_param(pcap_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_pcap_start((stc_pcap_s *)pcap_h); + ret = _stc_pcap_start(stc, (stc_pcap_s *)pcap_h); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to start pcap [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } @@ -512,28 +551,35 @@ EXPORT_API int stc_pcap_stop(stc_h stc, stc_pcap_h pcap_h) CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (__stc_pcap_check_validity(pcap_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (__stc_pcap_check_param(pcap_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_pcap_stop((stc_pcap_s *)pcap_h); + ret = _stc_pcap_stop(stc, (stc_pcap_s *)pcap_h); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to stop pcap [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } @@ -544,17 +590,22 @@ EXPORT_API int stc_pcap_foreach(stc_h stc, CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } + STC_UNLOCK; + if (callback == NULL) { STC_LOGE("Invalid parameter"); return STC_ERROR_INVALID_PARAMETER; } - ret = _stc_pcap_foreach(callback, user_data); + ret = _stc_pcap_foreach(stc, callback, user_data); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to get all pcap [%s]", _stc_convert_error_type_to_string(ret)); @@ -571,25 +622,31 @@ EXPORT_API int stc_pcap_find_all_devs(stc_h stc, CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (callback == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } _stc_pcap_set_callback(stc, callback, user_data); - ret = _stc_pcap_find_all_devs(callback, user_data); + ret = _stc_pcap_find_all_devs(stc, callback, user_data); if (ret != STC_ERROR_NONE) { STC_LOGE("Failed to find all devs [%s]", _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; } + STC_UNLOCK; return STC_ERROR_NONE; } @@ -597,8 +654,11 @@ EXPORT_API int stc_pcap_set_ifname(stc_pcap_h pcap_h, char *ifname) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (__stc_pcap_check_validity(pcap_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -609,6 +669,7 @@ EXPORT_API int stc_pcap_set_ifname(stc_pcap_h pcap_h, char *ifname) STC_LOGI("Interface name [%s]", pcap->ifname); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -616,8 +677,11 @@ EXPORT_API int stc_pcap_set_nflog_group(stc_pcap_h pcap_h, int group) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (__stc_pcap_check_validity(pcap_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -627,6 +691,7 @@ EXPORT_API int stc_pcap_set_nflog_group(stc_pcap_h pcap_h, int group) STC_LOGI("Nflog group [%d]", pcap->nflog_group); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -634,13 +699,17 @@ EXPORT_API int stc_pcap_get_ifname(stc_pcap_h pcap_h, char **ifname) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (__stc_pcap_check_validity(pcap_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!ifname) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -650,6 +719,7 @@ EXPORT_API int stc_pcap_get_ifname(stc_pcap_h pcap_h, char **ifname) STC_LOGI("Interface name [%s]", *ifname); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -657,13 +727,17 @@ EXPORT_API int stc_pcap_get_nflog_group(stc_pcap_h pcap_h, int *group) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (__stc_pcap_check_validity(pcap_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (!group) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -673,6 +747,7 @@ EXPORT_API int stc_pcap_get_nflog_group(stc_pcap_h pcap_h, int *group) STC_LOGI("Nflog group [%d]", *group); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -680,8 +755,11 @@ EXPORT_API int stc_pcap_get_dev_name(stc_pcap_h pcap_h, char **name) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!name) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -691,6 +769,7 @@ EXPORT_API int stc_pcap_get_dev_name(stc_pcap_h pcap_h, char **name) STC_LOGI("Device name [%s]", *name); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -698,8 +777,11 @@ EXPORT_API int stc_pcap_get_dev_decs(stc_pcap_h pcap_h, char **decs) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!decs) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -709,6 +791,7 @@ EXPORT_API int stc_pcap_get_dev_decs(stc_pcap_h pcap_h, char **decs) STC_LOGI("Device description [%s]", *decs); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -716,8 +799,11 @@ EXPORT_API int stc_pcap_get_dev_net(stc_pcap_h pcap_h, char **net) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!net) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -727,6 +813,7 @@ EXPORT_API int stc_pcap_get_dev_net(stc_pcap_h pcap_h, char **net) STC_LOGI("Device net [%s]", *net); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -734,8 +821,11 @@ EXPORT_API int stc_pcap_get_dev_mask(stc_pcap_h pcap_h, char **mask) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!mask) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -745,6 +835,7 @@ EXPORT_API int stc_pcap_get_dev_mask(stc_pcap_h pcap_h, char **mask) STC_LOGI("Device mask [%s]", *mask); + STC_UNLOCK; return STC_ERROR_NONE; } //LCOV_EXCL_STOP diff --git a/src/stc-reset.c b/src/stc-reset.c index 4a56fcd..0ebfc0c 100755 --- a/src/stc-reset.c +++ b/src/stc-reset.c @@ -57,6 +57,8 @@ * Global Variables *****************************************************************************/ +static GSList *g_reset_rule = NULL; + /***************************************************************************** * Local Functions Definition *****************************************************************************/ @@ -114,6 +116,30 @@ static void __stc_reset_stats_make_params( g_variant_builder_unref(builder); } +static void __stc_reset_add_rule(stc_reset_rule_h rule) +{ + g_reset_rule = g_slist_append(g_reset_rule, rule); +} + +static void __stc_reset_remove_rule(stc_reset_rule_h rule) +{ + g_reset_rule = g_slist_remove(g_reset_rule, rule); +} + +static bool __stc_reset_check_rule_validity(stc_reset_rule_h rule) +{ + GSList *find; + + if (!rule) + return false; + + find = g_slist_find(g_reset_rule, rule); + if (find) + return true; + else + return false; +} + stc_error_e _stc_reset_check_rule(stc_reset_rule_h rule) { stc_reset_rule_s *reset_rule = (stc_reset_rule_s *)rule; @@ -133,7 +159,7 @@ stc_error_e _stc_reset_check_rule(stc_reset_rule_h rule) return STC_ERROR_NONE; } -stc_error_e _stc_reset_stats(stc_reset_rule_h rule) +stc_error_e _stc_reset_stats(stc_h stc, stc_reset_rule_h rule) { GVariant *message = NULL; GVariant *params = NULL; @@ -142,7 +168,7 @@ stc_error_e _stc_reset_stats(stc_reset_rule_h rule) __stc_reset_stats_make_params(rule, ¶ms); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_STATS_PATH, STC_MANAGER_STATS_INTERFACE, @@ -164,26 +190,34 @@ EXPORT_API int stc_reset_rule_create(stc_h stc, stc_reset_rule_h *rule) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (rule == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } stc_reset_rule_s *reset_rule = g_try_malloc0(sizeof(stc_reset_rule_s)); if (reset_rule == NULL) { STC_LOGE("Memory allocation failed"); + STC_UNLOCK; return STC_ERROR_OUT_OF_MEMORY; } __stc_reset_init_rule(reset_rule); + __stc_reset_add_rule((stc_reset_rule_h)reset_rule); + *rule = (stc_reset_rule_h)reset_rule; STC_LOGI("Reset rule successfully created"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -191,14 +225,20 @@ EXPORT_API int stc_reset_rule_destroy(stc_reset_rule_h rule) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL) { + STC_LOCK; + + if (__stc_reset_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } + __stc_reset_remove_rule(rule); __stc_reset_deinit_rule(rule); + STC_LOGI("Reset rule successfully destroyed"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -206,8 +246,11 @@ EXPORT_API int stc_reset_rule_set_app_id(stc_reset_rule_h rule, const char *app_ { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL) { + STC_LOCK; + + if (__stc_reset_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -220,6 +263,7 @@ EXPORT_API int stc_reset_rule_set_app_id(stc_reset_rule_h rule, const char *app_ STC_LOGI("App id [%s]", reset_rule->app_id); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -228,8 +272,11 @@ EXPORT_API int stc_reset_rule_set_subscriber_id(stc_reset_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL) { + STC_LOCK; + + if (__stc_reset_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -242,6 +289,7 @@ EXPORT_API int stc_reset_rule_set_subscriber_id(stc_reset_rule_h rule, STC_LOGI("Subscriber ID [%s]", reset_rule->subscriber_id); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -250,8 +298,11 @@ EXPORT_API int stc_reset_rule_set_iface_type(stc_reset_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL) { + STC_LOCK; + + if (__stc_reset_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -268,12 +319,14 @@ EXPORT_API int stc_reset_rule_set_iface_type(stc_reset_rule_h rule, break; default: STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } STC_LOGI("Iface type [%s]", _stc_convert_iface_type_to_string(reset_rule->iface_type)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -282,13 +335,17 @@ EXPORT_API int stc_reset_rule_set_time_interval(stc_reset_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL) { + STC_LOCK; + + if (__stc_reset_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (from < 0 || to < 0) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -299,6 +356,7 @@ EXPORT_API int stc_reset_rule_set_time_interval(stc_reset_rule_h rule, STC_LOGI("Time interval from[%lu] to[%lu]", reset_rule->interval.from, reset_rule->interval.to); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -306,19 +364,31 @@ EXPORT_API int stc_reset_rule_get_app_id(stc_reset_rule_h rule, char **app_id) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL || app_id == NULL) { + STC_LOCK; + + if (__stc_reset_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; + return STC_ERROR_INVALID_PARAMETER; + } + + if (app_id == NULL) { + STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } stc_reset_rule_s *reset_rule = (stc_reset_rule_s *)rule; *app_id = g_strdup(reset_rule->app_id); - if (*app_id == NULL) + if (*app_id == NULL) { + STC_UNLOCK; return STC_ERROR_OUT_OF_MEMORY; + } STC_LOGI("App id [%s]", *app_id); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -327,19 +397,31 @@ EXPORT_API int stc_reset_rule_get_subscriber_id(stc_reset_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL || subscriber_id == NULL) { + STC_LOCK; + + if (__stc_reset_check_rule_validity(rule) == false) { + STC_LOGE("Invalid parameter"); + STC_UNLOCK; + return STC_ERROR_INVALID_PARAMETER; + } + + if (subscriber_id == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } stc_reset_rule_s *reset_rule = (stc_reset_rule_s *)rule; *subscriber_id = g_strdup(reset_rule->subscriber_id); - if (*subscriber_id == NULL) + if (*subscriber_id == NULL) { + STC_UNLOCK; return STC_ERROR_OUT_OF_MEMORY; + } STC_LOGI("Subscriber ID [%s]", *subscriber_id); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -348,8 +430,11 @@ EXPORT_API int stc_reset_rule_get_iface_type(stc_reset_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL) { + STC_LOCK; + + if (__stc_reset_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -359,6 +444,7 @@ EXPORT_API int stc_reset_rule_get_iface_type(stc_reset_rule_h rule, STC_LOGI("Iftype [%s]", _stc_convert_iface_type_to_string(*iface_type)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -367,8 +453,11 @@ EXPORT_API int stc_reset_rule_get_time_interval(stc_reset_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL) { + STC_LOCK; + + if (__stc_reset_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -379,6 +468,7 @@ EXPORT_API int stc_reset_rule_get_time_interval(stc_reset_rule_h rule, STC_LOGI("Time interval from[%lu] to[%lu]", *from, *to); + STC_UNLOCK; return STC_ERROR_NONE; } //LCOV_EXCL_STOP diff --git a/src/stc-restriction.c b/src/stc-restriction.c index 0a9ae31..fb48fd6 100755 --- a/src/stc-restriction.c +++ b/src/stc-restriction.c @@ -240,8 +240,9 @@ static void __stc_restriction_list_make_params(gpointer data, static void __stc_restriction_list_foreach(stc_restriction_list_h list_h, GVariantBuilder *builder) { - GSList *find = g_slist_find(g_restriction_list, list_h); + GSList *find; + find = g_slist_find(g_restriction_list, list_h); if (find) { stc_restriction_list_s *list_data = (stc_restriction_list_s *)find->data; g_slist_foreach(list_data->rules, __stc_restriction_list_make_params, builder); @@ -355,7 +356,8 @@ static void __stc_restriction_get_per_app_id_reply( stc_error_e error = STC_ERROR_NONE; stc_restriction_rule_s *restriction_rule = NULL; GSList *restriction_list = NULL; - stc_event_info_s event_data = { 0, }; + stc_event_info_s *event_data = NULL; + stc_handle_s *stc_handle = (stc_handle_s *)user_data; conn = G_DBUS_CONNECTION(source_object); dbus_data = g_dbus_connection_call_finish(conn, res, &dbus_error); @@ -370,36 +372,45 @@ static void __stc_restriction_get_per_app_id_reply( if (error == STC_ERROR_NONE) { g_variant_get(dbus_data, "(ia{sv})", &dbus_result, &iter); - if (iter != NULL) { - restriction_rule = g_try_malloc0( - sizeof(stc_restriction_rule_s)); - if (restriction_rule) { - _stc_dbus_dictionary_foreach(iter, - __stc_restriction_extract_rule_cb, restriction_rule); - - __stc_restriction_print_rule(restriction_rule); - - restriction_list = g_slist_append(restriction_list, - (stc_restriction_rule_s *)restriction_rule); + event_data = g_try_malloc0(sizeof(stc_event_info_s)); + if (event_data != NULL) { + if (iter != NULL) { + restriction_rule = g_try_malloc0( + sizeof(stc_restriction_rule_s)); + if (restriction_rule) { + _stc_dbus_dictionary_foreach(iter, + __stc_restriction_extract_rule_cb, restriction_rule); + + __stc_restriction_print_rule(restriction_rule); + + restriction_list = g_slist_append(restriction_list, + (stc_restriction_rule_s *)restriction_rule); + } + g_variant_iter_free(iter); } - g_variant_iter_free(iter); - } - event_data.event = STC_EVENT_RESTRICTION_GET_RSP; - event_data.info_data = (GSList *)restriction_list; - event_data.datalength = g_slist_length(restriction_list); - event_data.error = dbus_result; + event_data->handle = stc_handle; + event_data->event = STC_EVENT_RESTRICTION_GET_RSP; + event_data->info_data = (GSList *)restriction_list; + event_data->datalength = g_slist_length(restriction_list); + event_data->error = dbus_result; + } } else { STC_LOGE("Get restriction per app id response error [%s]", _stc_convert_error_type_to_string(error)); - event_data.event = STC_EVENT_RESTRICTION_GET_RSP; - event_data.info_data = NULL; - event_data.datalength = 0; - event_data.error = error; + event_data = g_try_malloc0(sizeof(stc_event_info_s)); + if (event_data != NULL) { + event_data->handle = stc_handle; + event_data->event = STC_EVENT_RESTRICTION_GET_RSP; + event_data->info_data = NULL; + event_data->datalength = 0; + event_data->error = error; + } } - _stc_event_add_client_idle_cb(&event_data, user_data); + stc_handle->event_handle.event_callback(event_data, user_data); + g_free(event_data); } static void __stc_restriction_get_all_reply( @@ -414,7 +425,8 @@ static void __stc_restriction_get_all_reply( stc_error_e error = STC_ERROR_NONE; stc_restriction_rule_s *restriction_rule = NULL; GSList *restriction_list = NULL; - stc_event_info_s event_data = { 0, }; + stc_event_info_s *event_data = NULL; + stc_handle_s *stc_handle = (stc_handle_s *)user_data; conn = G_DBUS_CONNECTION(source_object); dbus_data = g_dbus_connection_call_finish(conn, res, &dbus_error); @@ -429,110 +441,46 @@ static void __stc_restriction_get_all_reply( if (error == STC_ERROR_NONE) { g_variant_get(dbus_data, "(iaa{sv})", &dbus_result, &iter); - while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { - restriction_rule = g_try_malloc0( - sizeof(stc_restriction_rule_s)); - if (restriction_rule) { - _stc_dbus_dictionary_foreach(iter_row, - __stc_restriction_extract_rule_cb, restriction_rule); - - __stc_restriction_print_rule(restriction_rule); - - restriction_list = g_slist_append(restriction_list, - (stc_restriction_rule_s *)restriction_rule); + event_data = g_try_malloc0(sizeof(stc_event_info_s)); + if (event_data != NULL) { + while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { + restriction_rule = g_try_malloc0( + sizeof(stc_restriction_rule_s)); + if (restriction_rule) { + _stc_dbus_dictionary_foreach(iter_row, + __stc_restriction_extract_rule_cb, restriction_rule); + + __stc_restriction_print_rule(restriction_rule); + + restriction_list = g_slist_append(restriction_list, + (stc_restriction_rule_s *)restriction_rule); + } + g_variant_iter_free(iter_row); } - g_variant_iter_free(iter_row); - } - g_variant_iter_free(iter); + g_variant_iter_free(iter); - event_data.event = STC_EVENT_RESTRICTION_GET_ALL_RSP; - event_data.info_data = (GSList *)restriction_list; - event_data.datalength = g_slist_length(restriction_list); - event_data.error = dbus_result; + event_data->handle = stc_handle; + event_data->event = STC_EVENT_RESTRICTION_GET_ALL_RSP; + event_data->info_data = (GSList *)restriction_list; + event_data->datalength = g_slist_length(restriction_list); + event_data->error = dbus_result; + } } else { STC_LOGE("Get restriction all response error [%s]", _stc_convert_error_type_to_string(error)); - event_data.event = STC_EVENT_RESTRICTION_GET_ALL_RSP; - event_data.info_data = NULL; - event_data.datalength = 0; - event_data.error = error; - } - - _stc_event_add_client_idle_cb(&event_data, user_data); -} - -stc_error_e __stc_restriction_get_per_app_id( - stc_restriction_rule_h rule) -{ - GVariant *params = NULL; - stc_error_e error = STC_ERROR_NONE; - - STC_RETURN_VAL_IF( - _stc_event_get_request_table_state( - STC_REQUEST_TABLE_RESTRICTION_GET), - STC_ERROR_IN_PROGRESS, - "Request in progress"); - - _stc_event_set_request_table_state( - STC_REQUEST_TABLE_RESTRICTION_GET, true); - - __stc_restriction_get_make_params(rule, ¶ms); - - error = _stc_dbus_invoke_method_nonblock( - STC_MANAGER_SERVICE, - STC_MANAGER_RESTRICTION_PATH, - STC_MANAGER_RESTRICTION_INTERFACE, - STC_MANAGER_METHOD_RESTRICTION_GET_PER_APP_ID, - params, - STC_DBUS_REPLY_TIMEOUT, - __stc_restriction_get_per_app_id_reply, - NULL); - - if (error != STC_ERROR_NONE) { - STC_LOGE("Failed to invoke dbus method nonblock"); - - _stc_event_set_request_table_state( - STC_REQUEST_TABLE_RESTRICTION_GET, false); - return error; - } - - return STC_ERROR_NONE; -} - -stc_error_e __stc_restriction_get_all( - stc_restriction_rule_h rule) -{ - stc_error_e error = STC_ERROR_NONE; - - STC_RETURN_VAL_IF( - _stc_event_get_request_table_state( - STC_REQUEST_TABLE_RESTRICTION_GET_ALL), - STC_ERROR_IN_PROGRESS, - "Request in progress"); - - _stc_event_set_request_table_state( - STC_REQUEST_TABLE_RESTRICTION_GET_ALL, true); - - error = _stc_dbus_invoke_method_nonblock( - STC_MANAGER_SERVICE, - STC_MANAGER_RESTRICTION_PATH, - STC_MANAGER_RESTRICTION_INTERFACE, - STC_MANAGER_METHOD_RESTRICTION_GET_ALL, - NULL, - STC_DBUS_REPLY_TIMEOUT, - __stc_restriction_get_all_reply, - NULL); - - if (error != STC_ERROR_NONE) { - STC_LOGE("Failed to invoke dbus method nonblock"); - - _stc_event_set_request_table_state( - STC_REQUEST_TABLE_RESTRICTION_GET_ALL, false); - return error; + event_data = g_try_malloc0(sizeof(stc_event_info_s)); + if (event_data != NULL) { + event_data->handle = stc_handle; + event_data->event = STC_EVENT_RESTRICTION_GET_ALL_RSP; + event_data->info_data = NULL; + event_data->datalength = 0; + event_data->error = error; + } } - return STC_ERROR_NONE; + stc_handle->event_handle.event_callback(event_data, user_data); + g_free(event_data); } void _stc_restriction_add_rule(stc_restriction_rule_h rule) @@ -547,10 +495,13 @@ void _stc_restriction_remove_rule(stc_restriction_rule_h rule) bool _stc_restriction_check_rule_validity(stc_restriction_rule_h rule) { + GSList *find; + if (!rule) return false; - if (g_slist_find(g_restriction_rule, rule)) + find = g_slist_find(g_restriction_rule, rule); + if (find) return true; else return false; @@ -559,7 +510,9 @@ bool _stc_restriction_check_rule_validity(stc_restriction_rule_h rule) bool _stc_restriction_add_rule_to_list(stc_restriction_list_h list_h, stc_restriction_rule_h rule_h) { - GSList *find = g_slist_find(g_restriction_list, list_h); + GSList *find; + + find = g_slist_find(g_restriction_list, list_h); if (find) { stc_restriction_list_s *list_data = (stc_restriction_list_s *)find->data; list_data->rules = g_slist_append(list_data->rules, rule_h); @@ -572,7 +525,9 @@ bool _stc_restriction_add_rule_to_list(stc_restriction_list_h list_h, bool _stc_restriction_remove_rule_from_list(stc_restriction_list_h list_h, stc_restriction_rule_h rule_h) { - GSList *find = g_slist_find(g_restriction_list, list_h); + GSList *find; + + find = g_slist_find(g_restriction_list, list_h); if (find) { stc_restriction_list_s *list_data = (stc_restriction_list_s *)find->data; list_data->rules = g_slist_remove(list_data->rules, rule_h); @@ -589,12 +544,17 @@ stc_error_e _stc_restriction_foreach_rule_from_list(stc_restriction_list_h list_ GSList *list; GSList *find; + STC_LOCK; + find = g_slist_find(g_restriction_list, list_h); if (!find) { STC_LOGD("There is no restriction list"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } + STC_UNLOCK; + stc_restriction_list_s *list_data = (stc_restriction_list_s *)find->data; if (g_slist_length(list_data->rules) == 0) { STC_LOGD("There is no restriction rule from list"); @@ -621,21 +581,25 @@ void _stc_restriction_add_to_list(stc_restriction_list_h list_h) void _stc_restriction_remove_from_list(stc_restriction_list_h list_h) { g_restriction_list = g_slist_remove(g_restriction_list, list_h); + __stc_restriction_deinit_list(list_h); } bool _stc_restriction_check_list_validity(stc_restriction_list_h list_h) { + GSList *find; + if (!list_h) return false; - if (g_slist_find(g_restriction_list, list_h)) + find = g_slist_find(g_restriction_list, list_h); + if (find) return true; - - return false; + else + return false; } -stc_error_e _stc_restriction_set_list(stc_restriction_list_h list_h) +stc_error_e _stc_restriction_set_list(stc_h stc, stc_restriction_list_h list_h) { GVariant *message = NULL; GVariant *params = NULL; @@ -648,7 +612,7 @@ stc_error_e _stc_restriction_set_list(stc_restriction_list_h list_h) params = g_variant_new("(aa{sv})", builder); g_variant_builder_unref(builder); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_RESTRICTION_PATH, STC_MANAGER_RESTRICTION_INTERFACE, @@ -666,7 +630,7 @@ stc_error_e _stc_restriction_set_list(stc_restriction_list_h list_h) return STC_ERROR_NONE; } -stc_error_e _stc_restriction_unset_list(stc_restriction_list_h list_h) +stc_error_e _stc_restriction_unset_list(stc_h stc, stc_restriction_list_h list_h) { GVariant *message = NULL; GVariant *params = NULL; @@ -679,7 +643,7 @@ stc_error_e _stc_restriction_unset_list(stc_restriction_list_h list_h) params = g_variant_new("(aa{sv})", builder); g_variant_builder_unref(builder); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_RESTRICTION_PATH, STC_MANAGER_RESTRICTION_INTERFACE, @@ -967,7 +931,7 @@ stc_error_e _stc_restriction_check_exclude_rule( return STC_ERROR_NONE; } -stc_error_e _stc_restriction_set( +stc_error_e _stc_restriction_set(stc_h stc, stc_restriction_rule_h rule) { GVariant *message = NULL; @@ -977,7 +941,7 @@ stc_error_e _stc_restriction_set( __stc_restriction_rule_make_params(rule, ¶ms); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_RESTRICTION_PATH, STC_MANAGER_RESTRICTION_INTERFACE, @@ -995,7 +959,7 @@ stc_error_e _stc_restriction_set( return STC_ERROR_NONE; } -stc_error_e _stc_restriction_unset( +stc_error_e _stc_restriction_unset(stc_h stc, stc_restriction_rule_h rule) { GVariant *message = NULL; @@ -1005,7 +969,7 @@ stc_error_e _stc_restriction_unset( __stc_restriction_rule_make_params(rule, ¶ms); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_RESTRICTION_PATH, STC_MANAGER_RESTRICTION_INTERFACE, @@ -1023,27 +987,80 @@ stc_error_e _stc_restriction_unset( return STC_ERROR_NONE; } -stc_error_e _stc_restriction_get( +stc_error_e _stc_restriction_get(stc_h stc, stc_restriction_rule_h rule) { - STC_RETURN_VAL_IF(_stc_event_get_ref_count() < 1, - STC_ERROR_NOT_INITIALIZED, - "Event callback is not registered"); + GVariant *params = NULL; + stc_error_e error = STC_ERROR_NONE; + + STC_RETURN_VAL_IF( + _stc_event_get_request_table_state( + STC_REQUEST_TABLE_RESTRICTION_GET), + STC_ERROR_IN_PROGRESS, + "Request in progress"); + + _stc_event_set_request_table_state( + STC_REQUEST_TABLE_RESTRICTION_GET, true); + + __stc_restriction_get_make_params(rule, ¶ms); - return __stc_restriction_get_per_app_id(rule); + error = _stc_dbus_invoke_method_nonblock(stc, + STC_MANAGER_SERVICE, + STC_MANAGER_RESTRICTION_PATH, + STC_MANAGER_RESTRICTION_INTERFACE, + STC_MANAGER_METHOD_RESTRICTION_GET_PER_APP_ID, + params, + STC_DBUS_REPLY_TIMEOUT, + __stc_restriction_get_per_app_id_reply, + stc); + + if (error != STC_ERROR_NONE) { + STC_LOGE("Failed to invoke dbus method nonblock"); + + _stc_event_set_request_table_state( + STC_REQUEST_TABLE_RESTRICTION_GET, false); + return error; + } + + return STC_ERROR_NONE; } -stc_error_e _stc_restriction_get_all( +stc_error_e _stc_restriction_get_all(stc_h stc, stc_restriction_rule_h rule) { - STC_RETURN_VAL_IF(_stc_event_get_ref_count() < 1, - STC_ERROR_NOT_INITIALIZED, - "Event callback is not registered"); + stc_error_e error = STC_ERROR_NONE; - return __stc_restriction_get_all(rule); + STC_RETURN_VAL_IF( + _stc_event_get_request_table_state( + STC_REQUEST_TABLE_RESTRICTION_GET_ALL), + STC_ERROR_IN_PROGRESS, + "Request in progress"); + + _stc_event_set_request_table_state( + STC_REQUEST_TABLE_RESTRICTION_GET_ALL, true); + + error = _stc_dbus_invoke_method_nonblock(stc, + STC_MANAGER_SERVICE, + STC_MANAGER_RESTRICTION_PATH, + STC_MANAGER_RESTRICTION_INTERFACE, + STC_MANAGER_METHOD_RESTRICTION_GET_ALL, + NULL, + STC_DBUS_REPLY_TIMEOUT, + __stc_restriction_get_all_reply, + stc); + + if (error != STC_ERROR_NONE) { + STC_LOGE("Failed to invoke dbus method nonblock"); + + _stc_event_set_request_table_state( + STC_REQUEST_TABLE_RESTRICTION_GET_ALL, false); + return error; + } + + return STC_ERROR_NONE; } -stc_error_e _stc_restriction_get_type( +stc_error_e _stc_restriction_get_type(stc_h stc, stc_restriction_rule_h rule, stc_restriction_type_e *type) { @@ -1054,7 +1071,7 @@ stc_error_e _stc_restriction_get_type( __stc_restriction_get_type_make_params(rule, ¶ms); - message = _stc_dbus_invoke_method( + message = _stc_dbus_invoke_method(stc, STC_MANAGER_SERVICE, STC_MANAGER_RESTRICTION_PATH, STC_MANAGER_RESTRICTION_INTERFACE, @@ -1077,13 +1094,17 @@ EXPORT_API int stc_restriction_rule_create(stc_h stc, stc_restriction_rule_h *ru { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (rule == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1091,6 +1112,7 @@ EXPORT_API int stc_restriction_rule_create(stc_h stc, stc_restriction_rule_h *ru g_try_malloc0(sizeof(stc_restriction_rule_s)); if (restriction_rule == NULL) { STC_LOGE("Memory allocation failed"); + STC_UNLOCK; return STC_ERROR_OUT_OF_MEMORY; } @@ -1100,6 +1122,7 @@ EXPORT_API int stc_restriction_rule_create(stc_h stc, stc_restriction_rule_h *ru *rule = (stc_restriction_rule_h)restriction_rule; STC_LOGI("Restriction rule successfully created"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1107,8 +1130,11 @@ EXPORT_API int stc_restriction_rule_destroy(stc_restriction_rule_h rule) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1117,6 +1143,7 @@ EXPORT_API int stc_restriction_rule_destroy(stc_restriction_rule_h rule) STC_LOGI("Restriction rule successfully destroyed"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1125,8 +1152,11 @@ EXPORT_API int stc_restriction_rule_set_app_id(stc_restriction_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1140,6 +1170,7 @@ EXPORT_API int stc_restriction_rule_set_app_id(stc_restriction_rule_h rule, STC_LOGI("App id [%s]", restriction_rule->app_id); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1149,8 +1180,11 @@ EXPORT_API int stc_restriction_rule_set_iface_name(stc_restriction_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1164,6 +1198,7 @@ EXPORT_API int stc_restriction_rule_set_iface_name(stc_restriction_rule_h rule, STC_LOGI("Ifname [%s]", restriction_rule->iface_name); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1172,8 +1207,11 @@ EXPORT_API int stc_restriction_rule_set_iface_type(stc_restriction_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1191,12 +1229,14 @@ EXPORT_API int stc_restriction_rule_set_iface_type(stc_restriction_rule_h rule, break; default: STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } STC_LOGI("Iface type [%s]", _stc_convert_iface_type_to_string(restriction_rule->iface_type)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1205,8 +1245,11 @@ EXPORT_API int stc_restriction_rule_set_type(stc_restriction_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1221,12 +1264,14 @@ EXPORT_API int stc_restriction_rule_set_type(stc_restriction_rule_h rule, break; default: STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } STC_LOGI("Type [%s]", _stc_convert_rstn_type_to_string(restriction_rule->rstn_type)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1235,8 +1280,11 @@ EXPORT_API int stc_restriction_rule_set_limit(stc_restriction_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1247,6 +1295,7 @@ EXPORT_API int stc_restriction_rule_set_limit(stc_restriction_rule_h rule, STC_LOGI("Data limit [%lld] bytes", restriction_rule->data_limit); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1255,8 +1304,11 @@ EXPORT_API int stc_restriction_rule_set_warning_limit(stc_restriction_rule_h rul { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1268,6 +1320,7 @@ EXPORT_API int stc_restriction_rule_set_warning_limit(stc_restriction_rule_h rul STC_LOGI("Data warn limit [%lld] bytes", restriction_rule->data_warn_limit); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1276,8 +1329,11 @@ EXPORT_API int stc_restriction_rule_set_monthly_limit(stc_restriction_rule_h rul { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1289,6 +1345,7 @@ EXPORT_API int stc_restriction_rule_set_monthly_limit(stc_restriction_rule_h rul STC_LOGI("Monthly limit [%lld] bytes", restriction_rule->monthly_limit); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1297,8 +1354,11 @@ EXPORT_API int stc_restriction_rule_set_weekly_limit(stc_restriction_rule_h rule { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1310,6 +1370,7 @@ EXPORT_API int stc_restriction_rule_set_weekly_limit(stc_restriction_rule_h rule STC_LOGI("Weekly data limit [%lld] bytes", restriction_rule->weekly_limit); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1318,8 +1379,11 @@ EXPORT_API int stc_restriction_rule_set_daily_limit(stc_restriction_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1331,6 +1395,7 @@ EXPORT_API int stc_restriction_rule_set_daily_limit(stc_restriction_rule_h rule, STC_LOGI("Daily data limit [%lld] bytes", restriction_rule->daily_limit); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1339,8 +1404,11 @@ EXPORT_API int stc_restriction_rule_set_month_start_date(stc_restriction_rule_h { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1352,6 +1420,7 @@ EXPORT_API int stc_restriction_rule_set_month_start_date(stc_restriction_rule_h STC_LOGI("Month start date [%d]", restriction_rule->month_start_date); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1360,8 +1429,11 @@ EXPORT_API int stc_restriction_rule_set_roaming_type(stc_restriction_rule_h rule { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1375,12 +1447,14 @@ EXPORT_API int stc_restriction_rule_set_roaming_type(stc_restriction_rule_h rule break; default: STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } STC_LOGI("Roaming type [%s]", _stc_convert_roaming_to_string(restriction_rule->roaming_type)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1389,8 +1463,11 @@ EXPORT_API int stc_restriction_rule_set_subscriber_id(stc_restriction_rule_h rul { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1404,6 +1481,7 @@ EXPORT_API int stc_restriction_rule_set_subscriber_id(stc_restriction_rule_h rul STC_LOGI("Subscriber ID [%s]", restriction_rule->subscriber_id); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1411,13 +1489,17 @@ EXPORT_API int stc_restriction_rule_get_app_id(stc_restriction_rule_h rule, char { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (app_id == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1425,11 +1507,14 @@ EXPORT_API int stc_restriction_rule_get_app_id(stc_restriction_rule_h rule, char (stc_restriction_rule_s *)rule; *app_id = g_strdup(restriction_rule->app_id); - if (*app_id == NULL) + if (*app_id == NULL) { + STC_UNLOCK; return STC_ERROR_OUT_OF_MEMORY; + } STC_LOGI("App id [%s]", *app_id); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1438,13 +1523,17 @@ EXPORT_API int stc_restriction_rule_get_iface_name(stc_restriction_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (iface_name == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1452,11 +1541,14 @@ EXPORT_API int stc_restriction_rule_get_iface_name(stc_restriction_rule_h rule, (stc_restriction_rule_s *)rule; *iface_name = g_strdup(restriction_rule->iface_name); - if (*iface_name == NULL) + if (*iface_name == NULL) { + STC_UNLOCK; return STC_ERROR_OUT_OF_MEMORY; + } STC_LOGI("Ifname [%s]", *iface_name); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1465,8 +1557,11 @@ EXPORT_API int stc_restriction_rule_get_iface_type(stc_restriction_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1477,6 +1572,7 @@ EXPORT_API int stc_restriction_rule_get_iface_type(stc_restriction_rule_h rule, STC_LOGI("Iftype [%s]", _stc_convert_iface_type_to_string(*iface_type)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1485,8 +1581,11 @@ EXPORT_API int stc_restriction_rule_get_type(stc_restriction_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1497,6 +1596,7 @@ EXPORT_API int stc_restriction_rule_get_type(stc_restriction_rule_h rule, STC_LOGI("Type [%s]", _stc_convert_rstn_type_to_string(*type)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1505,13 +1605,17 @@ EXPORT_API int stc_restriction_rule_get_limit(stc_restriction_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (data_limit == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1522,6 +1626,7 @@ EXPORT_API int stc_restriction_rule_get_limit(stc_restriction_rule_h rule, STC_LOGI("Data limit [%lld] bytes", *data_limit); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1530,13 +1635,17 @@ EXPORT_API int stc_restriction_rule_get_warning_limit(stc_restriction_rule_h rul { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (data_warn_limit == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1547,6 +1656,7 @@ EXPORT_API int stc_restriction_rule_get_warning_limit(stc_restriction_rule_h rul STC_LOGI("Data Warn limit [%lld] bytes", *data_warn_limit); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1555,13 +1665,17 @@ EXPORT_API int stc_restriction_rule_get_monthly_limit(stc_restriction_rule_h rul { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (limit == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1572,6 +1686,7 @@ EXPORT_API int stc_restriction_rule_get_monthly_limit(stc_restriction_rule_h rul STC_LOGI("Monthly data limit [%lld] bytes", *limit); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1580,13 +1695,17 @@ EXPORT_API int stc_restriction_rule_get_weekly_limit(stc_restriction_rule_h rule { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (limit == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1597,6 +1716,7 @@ EXPORT_API int stc_restriction_rule_get_weekly_limit(stc_restriction_rule_h rule STC_LOGI("Weekly data limit [%lld] bytes", *limit); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1605,13 +1725,17 @@ EXPORT_API int stc_restriction_rule_get_daily_limit(stc_restriction_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (limit == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1622,6 +1746,7 @@ EXPORT_API int stc_restriction_rule_get_daily_limit(stc_restriction_rule_h rule, STC_LOGI("Daily data limit [%lld] bytes", *limit); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1630,13 +1755,17 @@ EXPORT_API int stc_restriction_rule_get_month_start_date(stc_restriction_rule_h { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (date == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1647,6 +1776,7 @@ EXPORT_API int stc_restriction_rule_get_month_start_date(stc_restriction_rule_h STC_LOGI("Month start date [%d]", *date); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1655,8 +1785,11 @@ EXPORT_API int stc_restriction_rule_get_roaming_type(stc_restriction_rule_h rule { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1668,6 +1801,7 @@ EXPORT_API int stc_restriction_rule_get_roaming_type(stc_restriction_rule_h rule STC_LOGI("Roaming type [%s]", _stc_convert_roaming_to_string(*roaming_type)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1676,13 +1810,17 @@ EXPORT_API int stc_restriction_rule_get_subscriber_id(stc_restriction_rule_h rul { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (subscriber_id == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1690,11 +1828,14 @@ EXPORT_API int stc_restriction_rule_get_subscriber_id(stc_restriction_rule_h rul (stc_restriction_rule_s *)rule; *subscriber_id = g_strdup(restriction_rule->subscriber_id); - if (*subscriber_id == NULL) + if (*subscriber_id == NULL) { + STC_UNLOCK; return STC_ERROR_OUT_OF_MEMORY; + } STC_LOGI("Subscriber ID [%s]", *subscriber_id); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1703,13 +1844,17 @@ EXPORT_API int stc_restriction_list_create(stc_h stc, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (list_h == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1717,6 +1862,7 @@ EXPORT_API int stc_restriction_list_create(stc_h stc, g_try_malloc0(sizeof(stc_restriction_list_s)); if (restriction_list == NULL) { STC_LOGE("Memory allocation failed"); + STC_UNLOCK; return STC_ERROR_OUT_OF_MEMORY; } @@ -1726,6 +1872,7 @@ EXPORT_API int stc_restriction_list_create(stc_h stc, *list_h = (stc_restriction_list_h)restriction_list; STC_LOGI("Restriction list successfully created"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1733,8 +1880,11 @@ EXPORT_API int stc_restriction_list_destroy(stc_restriction_list_h list_h) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (_stc_restriction_check_list_validity(list_h) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1742,6 +1892,7 @@ EXPORT_API int stc_restriction_list_destroy(stc_restriction_list_h list_h) STC_LOGI("Restriction list successfully destroyed"); + STC_UNLOCK; return STC_ERROR_NONE; } //LCOV_EXCL_STOP diff --git a/src/stc-statistics.c b/src/stc-statistics.c index 5cdac07..3235b75 100755 --- a/src/stc-statistics.c +++ b/src/stc-statistics.c @@ -58,6 +58,8 @@ * Global Variables *****************************************************************************/ +static GSList *g_stats_rule = NULL; + /***************************************************************************** * Local Functions Definition *****************************************************************************/ @@ -278,7 +280,8 @@ static void __stc_stats_get_per_app_id_reply( stc_error_e error = STC_ERROR_NONE; stc_stats_info_s *stats_info = NULL; GSList *stats_list = NULL; - stc_event_info_s event_data = { 0, }; + stc_event_info_s *event_data = NULL; + stc_handle_s *stc_handle = (stc_handle_s *)user_data; conn = G_DBUS_CONNECTION(source_object); dbus_data = g_dbus_connection_call_finish(conn, res, &dbus_error); @@ -293,39 +296,48 @@ static void __stc_stats_get_per_app_id_reply( if (error == STC_ERROR_NONE) { g_variant_get(dbus_data, "(iaa{sv})", &dbus_result, &iter); - while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { - stats_info = g_try_malloc0(sizeof(stc_stats_info_s)); - if (stats_info != NULL) { - _stc_dbus_dictionary_foreach(iter_row, - __stc_stats_extract_info_cb, stats_info); + event_data = g_try_malloc0(sizeof(stc_event_info_s)); + if (event_data != NULL) { + while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { + stats_info = g_try_malloc0(sizeof(stc_stats_info_s)); + if (stats_info != NULL) { + _stc_dbus_dictionary_foreach(iter_row, + __stc_stats_extract_info_cb, stats_info); - __stc_stats_print_info(stats_info); + __stc_stats_print_info(stats_info); - stats_list = g_slist_append(stats_list, - (stc_stats_info_s *)stats_info); + stats_list = g_slist_append(stats_list, + (stc_stats_info_s *)stats_info); - g_variant_iter_free(iter_row); + g_variant_iter_free(iter_row); + } } - } - g_variant_iter_free(iter); + g_variant_iter_free(iter); - event_data.event = STC_EVENT_STATS_GET_RSP; - event_data.info_data = (GSList *)stats_list; - event_data.datalength = g_slist_length(stats_list); - event_data.error = dbus_result; + event_data->handle = stc_handle; + event_data->event = STC_EVENT_STATS_GET_RSP; + event_data->info_data = (GSList *)stats_list; + event_data->datalength = g_slist_length(stats_list); + event_data->error = dbus_result; + } } else { //LCOV_EXCL_START STC_LOGE("Get stats per app id response error [%s]", _stc_convert_error_type_to_string(error)); - event_data.event = STC_EVENT_STATS_GET_RSP; - event_data.info_data = NULL; - event_data.datalength = 0; - event_data.error = error; + event_data = g_try_malloc0(sizeof(stc_event_info_s)); + if (event_data != NULL) { + event_data->handle = stc_handle; + event_data->event = STC_EVENT_STATS_GET_RSP; + event_data->info_data = NULL; + event_data->datalength = 0; + event_data->error = error; + } //LCOV_EXCL_STOP } - _stc_event_add_client_idle_cb(&event_data, user_data); + stc_handle->event_handle.event_callback(event_data, user_data); + g_free(event_data); } static void __stc_stats_foreach_reply( @@ -340,7 +352,8 @@ static void __stc_stats_foreach_reply( stc_error_e error = STC_ERROR_NONE; stc_stats_info_s *stats_info = NULL; GSList *stats_list = NULL; - stc_event_info_s event_data = { 0, }; + stc_event_info_s *event_data = NULL; + stc_handle_s *stc_handle = (stc_handle_s *)user_data; conn = G_DBUS_CONNECTION(source_object); dbus_data = g_dbus_connection_call_finish(conn, res, &dbus_error); @@ -355,39 +368,48 @@ static void __stc_stats_foreach_reply( if (error == STC_ERROR_NONE) { g_variant_get(dbus_data, "(iaa{sv})", &dbus_result, &iter); - while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { - stats_info = g_try_malloc0(sizeof(stc_stats_info_s)); - if (stats_info != NULL) { - _stc_dbus_dictionary_foreach(iter_row, - __stc_stats_extract_info_cb, stats_info); + event_data = g_try_malloc0(sizeof(stc_event_info_s)); + if (event_data != NULL) { + while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { + stats_info = g_try_malloc0(sizeof(stc_stats_info_s)); + if (stats_info != NULL) { + _stc_dbus_dictionary_foreach(iter_row, + __stc_stats_extract_info_cb, stats_info); - __stc_stats_print_info(stats_info); + __stc_stats_print_info(stats_info); - stats_list = g_slist_append(stats_list, - (stc_stats_info_s *)stats_info); + stats_list = g_slist_append(stats_list, + (stc_stats_info_s *)stats_info); - g_variant_iter_free(iter_row); + g_variant_iter_free(iter_row); + } } - } - g_variant_iter_free(iter); + g_variant_iter_free(iter); - event_data.event = STC_EVENT_STATS_FOREACH_RSP; - event_data.info_data = (GSList *)stats_list; - event_data.datalength = g_slist_length(stats_list); - event_data.error = dbus_result; + event_data->handle = stc_handle; + event_data->event = STC_EVENT_STATS_FOREACH_RSP; + event_data->info_data = (GSList *)stats_list; + event_data->datalength = g_slist_length(stats_list); + event_data->error = dbus_result; + } } else { //LCOV_EXCL_START STC_LOGE("Get stats all response error [%s]", _stc_convert_error_type_to_string(error)); - event_data.event = STC_EVENT_STATS_FOREACH_RSP; - event_data.info_data = NULL; - event_data.datalength = 0; - event_data.error = error; + event_data = g_try_malloc0(sizeof(stc_event_info_s)); + if (event_data != NULL) { + event_data->handle = stc_handle; + event_data->event = STC_EVENT_STATS_FOREACH_RSP; + event_data->info_data = NULL; + event_data->datalength = 0; + event_data->error = error; + } //LCOV_EXCL_STOP } - _stc_event_add_client_idle_cb(&event_data, user_data); + stc_handle->event_handle.event_callback(event_data, user_data); + g_free(event_data); } static void __stc_stats_get_all_reply( @@ -402,7 +424,8 @@ static void __stc_stats_get_all_reply( stc_error_e error = STC_ERROR_NONE; stc_stats_info_s *stats_info = NULL; GSList *stats_list = NULL; - stc_event_info_s event_data = { 0, }; + stc_event_info_s *event_data = NULL; + stc_handle_s *stc_handle = (stc_handle_s *)user_data; conn = G_DBUS_CONNECTION(source_object); dbus_data = g_dbus_connection_call_finish(conn, res, &dbus_error); @@ -417,39 +440,48 @@ static void __stc_stats_get_all_reply( if (error == STC_ERROR_NONE) { g_variant_get(dbus_data, "(iaa{sv})", &dbus_result, &iter); - while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { - stats_info = g_try_malloc0(sizeof(stc_stats_info_s)); - if (stats_info != NULL) { - _stc_dbus_dictionary_foreach(iter_row, - __stc_stats_extract_info_cb, stats_info); + event_data = g_try_malloc0(sizeof(stc_event_info_s)); + if (event_data != NULL) { + while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { + stats_info = g_try_malloc0(sizeof(stc_stats_info_s)); + if (stats_info != NULL) { + _stc_dbus_dictionary_foreach(iter_row, + __stc_stats_extract_info_cb, stats_info); - __stc_stats_print_info(stats_info); + __stc_stats_print_info(stats_info); - stats_list = g_slist_append(stats_list, - (stc_stats_info_s *)stats_info); + stats_list = g_slist_append(stats_list, + (stc_stats_info_s *)stats_info); - g_variant_iter_free(iter_row); + g_variant_iter_free(iter_row); + } } - } - g_variant_iter_free(iter); + g_variant_iter_free(iter); - event_data.event = STC_EVENT_STATS_GET_ALL_RSP; - event_data.info_data = (GSList *)stats_list; - event_data.datalength = g_slist_length(stats_list); - event_data.error = dbus_result; + event_data->handle = stc_handle; + event_data->event = STC_EVENT_STATS_GET_ALL_RSP; + event_data->info_data = (GSList *)stats_list; + event_data->datalength = g_slist_length(stats_list); + event_data->error = dbus_result; + } } else { //LCOV_EXCL_START STC_LOGE("Get stats all response error [%s]", _stc_convert_error_type_to_string(error)); - event_data.event = STC_EVENT_STATS_GET_ALL_RSP; - event_data.info_data = NULL; - event_data.datalength = 0; - event_data.error = error; + event_data = g_try_malloc0(sizeof(stc_event_info_s)); + if (event_data != NULL) { + event_data->handle = stc_handle; + event_data->event = STC_EVENT_STATS_GET_ALL_RSP; + event_data->info_data = NULL; + event_data->datalength = 0; + event_data->error = error; + } //LCOV_EXCL_STOP } - _stc_event_add_client_idle_cb(&event_data, user_data); + stc_handle->event_handle.event_callback(event_data, user_data); + g_free(event_data); } static void __stc_stats_get_total_reply( @@ -464,7 +496,8 @@ static void __stc_stats_get_total_reply( stc_error_e error = STC_ERROR_NONE; stc_stats_info_s *stats_info = NULL; GSList *stats_list = NULL; - stc_event_info_s event_data = { 0, }; + stc_event_info_s *event_data = NULL; + stc_handle_s *stc_handle = (stc_handle_s *)user_data; conn = G_DBUS_CONNECTION(source_object); dbus_data = g_dbus_connection_call_finish(conn, res, &dbus_error); @@ -479,43 +512,139 @@ static void __stc_stats_get_total_reply( if (error == STC_ERROR_NONE) { g_variant_get(dbus_data, "(iaa{sv})", &dbus_result, &iter); - while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { - stats_info = g_try_malloc0(sizeof(stc_stats_info_s)); - if (stats_info != NULL) { - _stc_dbus_dictionary_foreach(iter_row, - __stc_stats_extract_info_cb, stats_info); + event_data = g_try_malloc0(sizeof(stc_event_info_s)); + if (event_data != NULL) { + while (g_variant_iter_next(iter, "a{sv}", &iter_row)) { + stats_info = g_try_malloc0(sizeof(stc_stats_info_s)); + if (stats_info != NULL) { + _stc_dbus_dictionary_foreach(iter_row, + __stc_stats_extract_info_cb, stats_info); - __stc_stats_print_info(stats_info); + __stc_stats_print_info(stats_info); - stats_list = g_slist_append(stats_list, - (stc_stats_info_s *)stats_info); + stats_list = g_slist_append(stats_list, + (stc_stats_info_s *)stats_info); - g_variant_iter_free(iter_row); + g_variant_iter_free(iter_row); + } } - } - g_variant_iter_free(iter); + g_variant_iter_free(iter); - event_data.event = STC_EVENT_STATS_GET_TOTAL_RSP; - event_data.info_data = (GSList *)stats_list; - event_data.datalength = g_slist_length(stats_list); - event_data.error = dbus_result; + event_data->handle = stc_handle; + event_data->event = STC_EVENT_STATS_GET_TOTAL_RSP; + event_data->info_data = (GSList *)stats_list; + event_data->datalength = g_slist_length(stats_list); + event_data->error = dbus_result; + } } else { //LCOV_EXCL_START STC_LOGE("Get stats total response error [%s]", _stc_convert_error_type_to_string(error)); - event_data.event = STC_EVENT_STATS_GET_TOTAL_RSP; - event_data.info_data = NULL; - event_data.datalength = 0; - event_data.error = error; + event_data = g_try_malloc0(sizeof(stc_event_info_s)); + if (event_data != NULL) { + event_data->handle = stc_handle; + event_data->event = STC_EVENT_STATS_GET_TOTAL_RSP; + event_data->info_data = NULL; + event_data->datalength = 0; + event_data->error = error; + } //LCOV_EXCL_STOP } - _stc_event_add_client_idle_cb(&event_data, user_data); + stc_handle->event_handle.event_callback(event_data, user_data); + g_free(event_data); +} + +static void __stc_stats_add_rule(stc_stats_rule_h rule) +{ + g_stats_rule = g_slist_append(g_stats_rule, rule); } -stc_error_e __stc_stats_get_per_app_id( +static void __stc_stats_remove_rule(stc_stats_rule_h rule) +{ + g_stats_rule = g_slist_remove(g_stats_rule, rule); +} + +static bool __stc_stats_check_rule_validity(stc_stats_rule_h rule) +{ + GSList *find; + + if (!rule) + return false; + + find = g_slist_find(g_stats_rule, rule); + if (find) + return true; + else + return false; +} + +stc_error_e _stc_stats_check_get_rule( stc_stats_rule_h rule) +{ + stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; + + STC_RETURN_VAL_IF(stats_rule == NULL, + STC_ERROR_INVALID_PARAMETER, + "Stats rule should be set"); + + STC_RETURN_VAL_IF(stats_rule->app_id[0] == '\0', + STC_ERROR_INVALID_PARAMETER, + "Application ID is required argument"); + + STC_RETURN_VAL_IF(stats_rule->interval.from <= STC_INVALID_TIME_INTERVAL, + STC_ERROR_INVALID_PARAMETER, + "Invalid time interval for [from]"); + + STC_RETURN_VAL_IF(stats_rule->interval.to <= STC_INVALID_TIME_INTERVAL, + STC_ERROR_INVALID_PARAMETER, + "Invalid time interval for [to]"); + + return STC_ERROR_NONE; +} + +stc_error_e _stc_stats_check_get_all_rule( + stc_stats_rule_h rule) +{ + stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; + + STC_RETURN_VAL_IF(stats_rule == NULL, + STC_ERROR_INVALID_PARAMETER, + "Stats rule should be set"); + + STC_RETURN_VAL_IF(stats_rule->interval.from <= STC_INVALID_TIME_INTERVAL, + STC_ERROR_INVALID_PARAMETER, + "Invalid time interval for [from]"); + + STC_RETURN_VAL_IF(stats_rule->interval.to <= STC_INVALID_TIME_INTERVAL, + STC_ERROR_INVALID_PARAMETER, + "Invalid time interval for [to]"); + + return STC_ERROR_NONE; +} + +stc_error_e _stc_stats_check_get_total_rule( + stc_stats_rule_h rule) +{ + stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; + + STC_RETURN_VAL_IF(stats_rule == NULL, + STC_ERROR_INVALID_PARAMETER, + "Stats rule should be set"); + + STC_RETURN_VAL_IF(stats_rule->interval.from <= STC_INVALID_TIME_INTERVAL, + STC_ERROR_INVALID_PARAMETER, + "Invalid time interval for [from]"); + + STC_RETURN_VAL_IF(stats_rule->interval.to <= STC_INVALID_TIME_INTERVAL, + STC_ERROR_INVALID_PARAMETER, + "Invalid time interval for [to]"); + + return STC_ERROR_NONE; +} + +stc_error_e _stc_stats_get(stc_h stc, stc_stats_rule_h rule) { GVariant *params = NULL; stc_error_e error = STC_ERROR_NONE; @@ -531,7 +660,7 @@ stc_error_e __stc_stats_get_per_app_id( __stc_stats_get_make_params(rule, ¶ms); - error = _stc_dbus_invoke_method_nonblock( + error = _stc_dbus_invoke_method_nonblock(stc, STC_MANAGER_SERVICE, STC_MANAGER_STATS_PATH, STC_MANAGER_STATS_INTERFACE, @@ -539,7 +668,7 @@ stc_error_e __stc_stats_get_per_app_id( params, STC_DBUS_REPLY_TIMEOUT, __stc_stats_get_per_app_id_reply, - NULL); + stc); if (error != STC_ERROR_NONE) { STC_LOGE("Failed to invoke dbus method nonblock"); //LCOV_EXCL_LINE @@ -552,7 +681,7 @@ stc_error_e __stc_stats_get_per_app_id( return STC_ERROR_NONE; } -stc_error_e __stc_stats_foreach(stc_stats_rule_h rule) +stc_error_e _stc_stats_foreach(stc_h stc, stc_stats_rule_h rule) { GVariant *params = NULL; stc_error_e error = STC_ERROR_NONE; @@ -568,7 +697,7 @@ stc_error_e __stc_stats_foreach(stc_stats_rule_h rule) __stc_stats_get_all_make_params(rule, ¶ms); - error = _stc_dbus_invoke_method_nonblock( + error = _stc_dbus_invoke_method_nonblock(stc, STC_MANAGER_SERVICE, STC_MANAGER_STATS_PATH, STC_MANAGER_STATS_INTERFACE, @@ -576,7 +705,7 @@ stc_error_e __stc_stats_foreach(stc_stats_rule_h rule) params, STC_DBUS_REPLY_TIMEOUT, __stc_stats_foreach_reply, - NULL); + stc); if (error != STC_ERROR_NONE) { STC_LOGE("Failed to invoke dbus method nonblock"); //LCOV_EXCL_LINE @@ -589,7 +718,7 @@ stc_error_e __stc_stats_foreach(stc_stats_rule_h rule) return STC_ERROR_NONE; } -stc_error_e __stc_stats_get_all(stc_stats_rule_h rule) +stc_error_e _stc_stats_get_all(stc_h stc, stc_stats_rule_h rule) { GVariant *params = NULL; stc_error_e error = STC_ERROR_NONE; @@ -605,7 +734,7 @@ stc_error_e __stc_stats_get_all(stc_stats_rule_h rule) __stc_stats_get_all_make_params(rule, ¶ms); - error = _stc_dbus_invoke_method_nonblock( + error = _stc_dbus_invoke_method_nonblock(stc, STC_MANAGER_SERVICE, STC_MANAGER_STATS_PATH, STC_MANAGER_STATS_INTERFACE, @@ -613,7 +742,7 @@ stc_error_e __stc_stats_get_all(stc_stats_rule_h rule) params, STC_DBUS_REPLY_TIMEOUT, __stc_stats_get_all_reply, - NULL); + stc); if (error != STC_ERROR_NONE) { STC_LOGE("Failed to invoke dbus method nonblock"); //LCOV_EXCL_LINE @@ -626,7 +755,31 @@ stc_error_e __stc_stats_get_all(stc_stats_rule_h rule) return STC_ERROR_NONE; } -stc_error_e __stc_stats_get_total(stc_stats_rule_h rule) +stc_error_e _stc_stats_foreach_all(stc_all_stats_info_h info, + stc_stats_info_cb info_cb, void *user_data) +{ + GSList *list; + stc_callback_ret_e ret = STC_CALLBACK_CANCEL; + GSList *stats_list = (GSList *)info; + + if (g_slist_length(stats_list) == 0) { + STC_LOGD("There is no stats info"); + return STC_ERROR_NONE; + } + + for (list = stats_list; list; list = list->next) { + stc_stats_info_s *stats_info = (stc_stats_info_s *)list->data; + STC_LOGD("App id[%s] Ifname[%s] Sub id[%s] Roaming[%u]", stats_info->app_id, + stats_info->iface_name, stats_info->subscriber_id, stats_info->roaming_type); + ret = info_cb(STC_ERROR_NONE, (stc_stats_info_h)stats_info, user_data); + if (ret == STC_CALLBACK_CANCEL) + break; + } + + return STC_ERROR_NONE; +} + +stc_error_e _stc_stats_get_total(stc_h stc, stc_stats_rule_h rule) { GVariant *params = NULL; stc_error_e error = STC_ERROR_NONE; @@ -642,7 +795,7 @@ stc_error_e __stc_stats_get_total(stc_stats_rule_h rule) __stc_stats_get_total_make_params(rule, ¶ms); - error = _stc_dbus_invoke_method_nonblock( + error = _stc_dbus_invoke_method_nonblock(stc, STC_MANAGER_SERVICE, STC_MANAGER_STATS_PATH, STC_MANAGER_STATS_INTERFACE, @@ -650,7 +803,7 @@ stc_error_e __stc_stats_get_total(stc_stats_rule_h rule) params, STC_DBUS_REPLY_TIMEOUT, __stc_stats_get_total_reply, - NULL); + stc); if (error != STC_ERROR_NONE) { STC_LOGE("Failed to invoke dbus method nonblock"); //LCOV_EXCL_LINE @@ -663,154 +816,38 @@ stc_error_e __stc_stats_get_total(stc_stats_rule_h rule) return STC_ERROR_NONE; } -stc_error_e _stc_stats_check_get_rule( - stc_stats_rule_h rule) -{ - stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; - - STC_RETURN_VAL_IF(stats_rule == NULL, - STC_ERROR_INVALID_PARAMETER, - "Stats rule should be set"); - - STC_RETURN_VAL_IF(stats_rule->app_id[0] == '\0', - STC_ERROR_INVALID_PARAMETER, - "Application ID is required argument"); - - STC_RETURN_VAL_IF(stats_rule->interval.from <= STC_INVALID_TIME_INTERVAL, - STC_ERROR_INVALID_PARAMETER, - "Invalid time interval for [from]"); - - STC_RETURN_VAL_IF(stats_rule->interval.to <= STC_INVALID_TIME_INTERVAL, - STC_ERROR_INVALID_PARAMETER, - "Invalid time interval for [to]"); - - return STC_ERROR_NONE; -} - -stc_error_e _stc_stats_check_get_all_rule( - stc_stats_rule_h rule) -{ - stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; - - STC_RETURN_VAL_IF(stats_rule == NULL, - STC_ERROR_INVALID_PARAMETER, - "Stats rule should be set"); - - STC_RETURN_VAL_IF(stats_rule->interval.from <= STC_INVALID_TIME_INTERVAL, - STC_ERROR_INVALID_PARAMETER, - "Invalid time interval for [from]"); - - STC_RETURN_VAL_IF(stats_rule->interval.to <= STC_INVALID_TIME_INTERVAL, - STC_ERROR_INVALID_PARAMETER, - "Invalid time interval for [to]"); - - return STC_ERROR_NONE; -} - -stc_error_e _stc_stats_check_get_total_rule( - stc_stats_rule_h rule) -{ - stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; - - STC_RETURN_VAL_IF(stats_rule == NULL, - STC_ERROR_INVALID_PARAMETER, - "Stats rule should be set"); - - STC_RETURN_VAL_IF(stats_rule->interval.from <= STC_INVALID_TIME_INTERVAL, - STC_ERROR_INVALID_PARAMETER, - "Invalid time interval for [from]"); - - STC_RETURN_VAL_IF(stats_rule->interval.to <= STC_INVALID_TIME_INTERVAL, - STC_ERROR_INVALID_PARAMETER, - "Invalid time interval for [to]"); - - return STC_ERROR_NONE; -} - -stc_error_e _stc_stats_get(stc_stats_rule_h rule) -{ - STC_RETURN_VAL_IF(_stc_event_get_ref_count() < 1, - STC_ERROR_NOT_INITIALIZED, - "Event callback is not registered"); - - return __stc_stats_get_per_app_id(rule); -} - -stc_error_e _stc_stats_foreach(stc_stats_rule_h rule) -{ - STC_RETURN_VAL_IF(_stc_event_get_ref_count() < 1, - STC_ERROR_NOT_INITIALIZED, - "Event callback is not registered"); - - return __stc_stats_foreach(rule); -} - -stc_error_e _stc_stats_get_all(stc_stats_rule_h rule) -{ - STC_RETURN_VAL_IF(_stc_event_get_ref_count() < 1, - STC_ERROR_NOT_INITIALIZED, - "Event callback is not registered"); - - return __stc_stats_get_all(rule); -} - -stc_error_e _stc_stats_foreach_all(stc_all_stats_info_h info, - stc_stats_info_cb info_cb, void *user_data) -{ - GSList *list; - stc_callback_ret_e ret = STC_CALLBACK_CANCEL; - GSList *stats_list = (GSList *)info; - - if (g_slist_length(stats_list) == 0) { - STC_LOGD("There is no stats info"); - return STC_ERROR_NONE; - } - - for (list = stats_list; list; list = list->next) { - stc_stats_info_s *stats_info = (stc_stats_info_s *)list->data; - STC_LOGD("App id[%s] Ifname[%s] Sub id[%s] Roaming[%u]", stats_info->app_id, - stats_info->iface_name, stats_info->subscriber_id, stats_info->roaming_type); - ret = info_cb(STC_ERROR_NONE, (stc_stats_info_h)stats_info, user_data); - if (ret == STC_CALLBACK_CANCEL) - break; - } - - return STC_ERROR_NONE; -} - -stc_error_e _stc_stats_get_total(stc_stats_rule_h rule) -{ - STC_RETURN_VAL_IF(_stc_event_get_ref_count() < 1, - STC_ERROR_NOT_INITIALIZED, - "Event callback is not registered"); - - return __stc_stats_get_total(rule); -} - EXPORT_API int stc_stats_rule_create(stc_h stc, stc_stats_rule_h *rule) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } if (rule == NULL) { STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } stc_stats_rule_s *stats_rule = g_try_malloc0(sizeof(stc_stats_rule_s)); if (stats_rule == NULL) { STC_LOGE("Memory allocation failed"); //LCOV_EXCL_LINE + STC_UNLOCK; return STC_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE } __stc_stats_init_rule(stats_rule); + __stc_stats_add_rule((stc_stats_rule_h)stats_rule); + *rule = (stc_stats_rule_h)stats_rule; STC_LOGI("Stats rule successfully created"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -818,14 +855,20 @@ EXPORT_API int stc_stats_rule_destroy(stc_stats_rule_h rule) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL) { + STC_LOCK; + + if (__stc_stats_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } + __stc_stats_remove_rule(rule); __stc_stats_deinit_rule(rule); + STC_LOGI("Stats rule successfully destroyed"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -834,8 +877,11 @@ EXPORT_API int stc_stats_rule_set_app_id(stc_stats_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL) { + STC_LOCK; + + if (__stc_stats_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -848,6 +894,7 @@ EXPORT_API int stc_stats_rule_set_app_id(stc_stats_rule_h rule, STC_LOGI("App id [%s]", stats_rule->app_id); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -856,13 +903,17 @@ EXPORT_API int stc_stats_rule_set_time_interval(stc_stats_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL) { + STC_LOCK; + + if (__stc_stats_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } if (from < 0 || to < 0) { STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } @@ -873,6 +924,7 @@ EXPORT_API int stc_stats_rule_set_time_interval(stc_stats_rule_h rule, STC_LOGI("Time interval from[%lu] to[%lu]", stats_rule->interval.from, stats_rule->interval.to); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -881,8 +933,11 @@ EXPORT_API int stc_stats_rule_set_iface_type( { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL) { + STC_LOCK; + + if (__stc_stats_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -899,12 +954,14 @@ EXPORT_API int stc_stats_rule_set_iface_type( break; default: STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } STC_LOGI("Iface type [%s]", _stc_convert_iface_type_to_string(stats_rule->iface_type)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -913,8 +970,11 @@ EXPORT_API int stc_stats_rule_set_time_period(stc_stats_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL) { + STC_LOCK; + + if (__stc_stats_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -930,12 +990,14 @@ EXPORT_API int stc_stats_rule_set_time_period(stc_stats_rule_h rule, break; default: STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } STC_LOGI("Time period [%s]", _stc_convert_time_period_to_string(stats_rule->time_period)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -943,19 +1005,31 @@ EXPORT_API int stc_stats_rule_get_app_id(stc_stats_rule_h rule, char **app_id) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL || app_id == NULL) { + STC_LOCK; + + if (__stc_stats_check_rule_validity(rule) == false) { + STC_LOGE("Invalid parameter"); + STC_UNLOCK; + return STC_ERROR_INVALID_PARAMETER; + } + + if (app_id == NULL) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } stc_stats_rule_s *stats_rule = (stc_stats_rule_s *)rule; *app_id = g_strdup(stats_rule->app_id); - if (*app_id == NULL) + if (*app_id == NULL) { + STC_UNLOCK; return STC_ERROR_OUT_OF_MEMORY; + } STC_LOGI("App id [%s]", *app_id); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -964,8 +1038,11 @@ EXPORT_API int stc_stats_rule_get_time_interval(stc_stats_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL) { + STC_LOCK; + + if (__stc_stats_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -976,6 +1053,7 @@ EXPORT_API int stc_stats_rule_get_time_interval(stc_stats_rule_h rule, STC_LOGI("Time interval from[%lu] to[%lu]", *from, *to); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -984,8 +1062,11 @@ EXPORT_API int stc_stats_rule_get_iface_type(stc_stats_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL) { + STC_LOCK; + + if (__stc_stats_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -995,6 +1076,7 @@ EXPORT_API int stc_stats_rule_get_iface_type(stc_stats_rule_h rule, STC_LOGI("Iftype [%s]", _stc_convert_iface_type_to_string(*iface_type)); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -1003,8 +1085,11 @@ EXPORT_API int stc_stats_rule_get_time_period(stc_stats_rule_h rule, { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); - if (rule == NULL) { + STC_LOCK; + + if (__stc_stats_check_rule_validity(rule) == false) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } @@ -1015,6 +1100,7 @@ EXPORT_API int stc_stats_rule_get_time_period(stc_stats_rule_h rule, STC_LOGI("Time period [%s]", _stc_convert_time_period_to_string(*time_period)); + STC_UNLOCK; return STC_ERROR_NONE; } diff --git a/src/stc.c b/src/stc.c index bd6136b..a0fbef3 100755 --- a/src/stc.c +++ b/src/stc.c @@ -62,33 +62,36 @@ EXPORT_API int stc_initialize(stc_h *stc) CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (stc == NULL) { STC_LOGE("Invalid parameter"); //LCOV_EXCL_LINE + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE } - if (_stc_handle_check_validity(*stc)) { - STC_LOGE("Already initialized"); //LCOV_EXCL_LINE - return STC_ERROR_ALREADY_INITIALIZED; //LCOV_EXCL_LINE - } - - ret = _stc_initialize(); + ret = _stc_handle_create(stc); if (ret != STC_ERROR_NONE) { - STC_LOGE("Init failed [%s]", //LCOV_EXCL_LINE + STC_LOGE("Create handle failed [%s]", //LCOV_EXCL_LINE _stc_convert_error_type_to_string(ret)); + STC_UNLOCK; return ret; //LCOV_EXCL_LINE } - ret = _stc_handle_create(stc); + ret = _stc_initialize(*stc); if (ret != STC_ERROR_NONE) { - STC_LOGE("Create handle failed [%s]", //LCOV_EXCL_LINE + STC_LOGE("Init failed [%s]", //LCOV_EXCL_LINE _stc_convert_error_type_to_string(ret)); + FREE(*stc); + *stc = NULL; + STC_UNLOCK; return ret; //LCOV_EXCL_LINE } - _stc_handle_add(stc); + _stc_handle_add(*stc); STC_LOGE("STC successfully initialized"); + STC_UNLOCK; return STC_ERROR_NONE; } @@ -96,24 +99,21 @@ EXPORT_API int stc_deinitialize(stc_h stc) { CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC); + STC_LOCK; + if (!(_stc_handle_check_validity(stc))) { STC_LOGE("Invalid parameter"); + STC_UNLOCK; return STC_ERROR_INVALID_PARAMETER; } STC_LOGI("Destroy handle [%p]", stc); _stc_handle_remove(stc); - if (_stc_handle_get_count() == 0) { - int ret = _stc_deinitialize(); - if (ret != STC_ERROR_NONE) { - STC_LOGE("Deinit failed [%s]", //LCOV_EXCL_LINE - _stc_convert_error_type_to_string(ret)); - return ret; //LCOV_EXCL_LINE - } - } + _stc_deinitialize(stc); STC_LOGI("STC successfully de-initialized"); + STC_UNLOCK; return STC_ERROR_NONE; } diff --git a/test/firewall.c b/test/firewall.c index 1e2f300..c813e80 100755 --- a/test/firewall.c +++ b/test/firewall.c @@ -728,7 +728,7 @@ static int _test_stc_fw_add_rule(MManager *mm, struct menu_data *menu) if (ret != STC_ERROR_NONE) return ret; - ret = stc_firewall_rule_add(g_fw_rule_h); + ret = stc_firewall_rule_add(g_stc, g_fw_rule_h); if (ret == STC_ERROR_NONE) msg(LOG_GREEN "Success to add firewall rule" LOG_END); else @@ -773,7 +773,7 @@ static int _test_stc_fw_update_rule(MManager *mm, struct menu_data *menu) if (ret != STC_ERROR_NONE) return ret; - ret = stc_firewall_rule_update(rule_h); + ret = stc_firewall_rule_update(g_stc, rule_h); if (ret == STC_ERROR_NONE) msg(LOG_GREEN "Success to update firewall rule" LOG_END); else @@ -794,7 +794,7 @@ static int _test_stc_fw_remove_rule(MManager *mm, struct menu_data *menu) return STC_ERROR_INVALID_PARAMETER; } - ret = stc_firewall_rule_remove(rule_h); + ret = stc_firewall_rule_remove(g_stc, rule_h); if (ret == STC_ERROR_NONE) { msg(LOG_GREEN "Success to remove firewall rule" LOG_END); g_rule_list = g_slist_remove(g_rule_list, rule_h); @@ -932,7 +932,7 @@ static int _test_stc_fw_add_chain(MManager *mm, struct menu_data *menu) if (ret != STC_ERROR_NONE) return ret; - ret = stc_firewall_chain_add(g_fw_chain_h); + ret = stc_firewall_chain_add(g_stc, g_fw_chain_h); if (ret == STC_ERROR_NONE) msg(LOG_GREEN "Success to add firewall chain" LOG_END); else @@ -972,7 +972,7 @@ static int _test_stc_fw_flush_chain(MManager *mm, struct menu_data *menu) return STC_ERROR_INVALID_PARAMETER; } - ret = stc_firewall_chain_flush(chain_h); + ret = stc_firewall_chain_flush(g_stc, chain_h); if (ret == STC_ERROR_NONE) { msg(LOG_GREEN "Success to flush firewall chain" LOG_END); @@ -994,7 +994,7 @@ static int _test_stc_fw_remove_chain(MManager *mm, struct menu_data *menu) return STC_ERROR_INVALID_PARAMETER; } - ret = stc_firewall_chain_remove(chain_h); + ret = stc_firewall_chain_remove(g_stc, chain_h); if (ret == STC_ERROR_NONE) { msg(LOG_GREEN "Success to remove firewall chain" LOG_END); g_chain_list = g_slist_remove(g_chain_list, chain_h); @@ -1028,7 +1028,7 @@ static int _test_stc_fw_set_chain(MManager *mm, struct menu_data *menu) return STC_ERROR_INVALID_PARAMETER; } - ret = stc_firewall_chain_set(chain_h, target); + ret = stc_firewall_chain_set(g_stc, chain_h, target); if (ret == STC_ERROR_NONE) msg(LOG_GREEN "Success to set firewall chain" LOG_END); else @@ -1049,7 +1049,7 @@ static int _test_stc_fw_unset_chain(MManager *mm, struct menu_data *menu) return STC_ERROR_INVALID_PARAMETER; } - ret = stc_firewall_chain_unset(chain_h); + ret = stc_firewall_chain_unset(g_stc, chain_h); if (ret == STC_ERROR_NONE) msg(LOG_GREEN "Success to unset firewall chain" LOG_END); else diff --git a/test/restriction.c b/test/restriction.c index bc0636a..0b8ec5e 100755 --- a/test/restriction.c +++ b/test/restriction.c @@ -86,7 +86,8 @@ static stc_callback_ret_e __test_stc_restriction_rule_cb( stc_roaming_type_e roaming; msg(HR_SINGLE); - msg("Index: " LOG_CYAN "[%d]" LOG_END, g_restriction_rule_index++); + if (rule) + msg("Index: " LOG_CYAN "[%d]" LOG_END, g_restriction_rule_index++); ret = stc_restriction_rule_get_app_id(rule, &app_id); if (ret == STC_ERROR_NONE) @@ -170,7 +171,7 @@ static void __test_stc_warn_threshold_crossed_cb(stc_restriction_rule_h rule, void *user_data) { int ret = STC_ERROR_NONE; - char *app_id; + char *app_id = NULL; msg(HR_SINGLE); @@ -186,7 +187,7 @@ static void __test_stc_restriction_threshold_crossed_cb(stc_restriction_rule_h r void *user_data) { int ret = STC_ERROR_NONE; - char *app_id; + char *app_id = NULL; msg(HR_SINGLE);