* @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
* @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.
* @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
* @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.
* @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
* @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.
* @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
*
* @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);
/**
* @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
* @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.
* @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
* @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.
* @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
* @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.
* @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
* @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.
* 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
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);
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
}
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
}
/*****************************************************************************
* Smart Traffic Control (STC) library headers
*****************************************************************************/
-#include "stc-private.h"
/*****************************************************************************
* Macros and Typedefs
/*****************************************************************************
* 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
/*****************************************************************************
* Standard headers
*****************************************************************************/
+
#include <glib.h>
/*****************************************************************************
/*****************************************************************************
* Smart Traffic Control (STC) library headers
*****************************************************************************/
+
#include "stc.h"
/*****************************************************************************
} stc_request_table_e;
typedef struct {
+ stc_h handle;
stc_event_e event;
stc_error_e error;
int datalength;
typedef struct {
stc_event_cb event_callback;
void* user_data;
- int ref_count;
- guint handler_id;
} stc_event_handle_info_s;
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
*****************************************************************************/
/*****************************************************************************
* 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);
/*****************************************************************************
* Standard headers
*****************************************************************************/
+#include <glib.h>
+#include <gio/gio.h>
/*****************************************************************************
* System headers
*****************************************************************************/
#include "stc.h"
#include "stc_internal.h"
+#include "stc-event.h"
+#include "stc-dbus.h"
/*****************************************************************************
* Macros and Typedefs
#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;
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);
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
* System headers
*****************************************************************************/
+#include "stc-private.h"
+
/*****************************************************************************
* Smart Traffic Control (STC) library headers
*****************************************************************************/
/*****************************************************************************
* 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
/*****************************************************************************
* 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,
}
}
-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,
NULL,
G_DBUS_CALL_FLAGS_NONE,
STC_DBUS_REPLY_TIMEOUT,
- _stc_dbus_get_cancellable(),
+ cancellable,
&error);
if (reply == NULL) {
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;
}
#include "stc.h"
#include "stc-private.h"
-
#include "stc-dbus.h"
#include "stc-log.h"
#include "stc-util.h"
/*****************************************************************************
* 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)
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;
#include <stdbool.h>
#include <errno.h>
-#include <glib.h>
-#include <gio/gio.h>
-
/*****************************************************************************
* System headers
*****************************************************************************/
#include "stc-private.h"
-#include "stc-dbus.h"
#include "stc-log.h"
#include "stc-util.h"
#include "stc-event.h"
/*****************************************************************************
* 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
}
//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
}
}
-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)
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)
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,
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
*****************************************************************************/
#include "stc.h"
-#include "stc-private.h"
#include "stc-dbus.h"
#include "stc-log.h"
#include "stc-util.h"
/*****************************************************************************
* 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);
+ }
}
}
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,
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,
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);
}
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,
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,
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,
}
-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;
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,
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;
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,
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;
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,
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;
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,
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;
}
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;
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,
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;
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,
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;
__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,
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;
__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,
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;
__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,
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;
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,
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;
}
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;
}
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;
}
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;
}
{
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;
}
STC_LOGI("Firewall chain successfully created");
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Firewall chain successfully cloned");
+ STC_UNLOCK;
return 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;
}
STC_LOGI("Firewall rule successfully destroyed");
+ STC_UNLOCK;
return 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 (!name) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Chain [%s]", *name);
+ STC_UNLOCK;
return 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 (!target) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Target [%s]", _stc_convert_fw_chain_target_to_string(*target));
+ STC_UNLOCK;
return 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 (!priority) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
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;
}
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));
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;
}
{
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;
}
STC_LOGI("Firewall rule successfully created");
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Firewall rule successfully cloned");
+ STC_UNLOCK;
return 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;
}
STC_LOGI("Firewall rule successfully destroyed");
+ STC_UNLOCK;
return 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 (!chain || strlen(chain) == 0) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Chain [%s]", fw_rule->chain);
+ STC_UNLOCK;
return 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 (direction > STC_FIREWALL_DIRECTION_OUT) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Direction [%u]", fw_rule->direction);
+ STC_UNLOCK;
return 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 (type > STC_FIREWALL_IP_RANGE) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Source IP type [%u]", fw_rule->s_ip_type);
+ STC_UNLOCK;
return 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 (type > STC_FIREWALL_IP_RANGE) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Destination IP type [%u]", fw_rule->d_ip_type);
+ STC_UNLOCK;
return 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 (type > STC_FIREWALL_PORT_RANGE) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Source port type [%u]", fw_rule->s_port_type);
+ STC_UNLOCK;
return 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 (type > STC_FIREWALL_PORT_RANGE) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Destination port type [%u]", fw_rule->d_port_type);
+ STC_UNLOCK;
return 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 (type > STC_FIREWALL_PROTOCOL_ALL) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Protocol type [%u]", fw_rule->protocol);
+ STC_UNLOCK;
return 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 (type > STC_FIREWALL_FAMILY_V6) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Family type [%u]", fw_rule->family);
+ STC_UNLOCK;
return 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;
}
STC_LOGI("Source IP [%s:%s]", fw_rule->s_ip1, fw_rule->s_ip2);
+ STC_UNLOCK;
return 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;
}
STC_LOGI("Destination IP [%s:%s]", fw_rule->d_ip1, fw_rule->d_ip2);
+ STC_UNLOCK;
return 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;
}
STC_LOGI("Source port [%u:%u]", fw_rule->s_port1, fw_rule->s_port2);
+ STC_UNLOCK;
return 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;
}
STC_LOGI("Destination port [%u:%u]", fw_rule->d_port1, fw_rule->d_port2);
+ STC_UNLOCK;
return 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;
}
STC_LOGI("Interface name [%s]", fw_rule->ifname);
+ STC_UNLOCK;
return 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;
}
STC_LOGI("Target [%s]",
_stc_convert_fw_rule_target_to_string(fw_rule->target));
+ STC_UNLOCK;
return 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;
}
STC_LOGI("Log level [%u]", fw_rule->log_level);
+ STC_UNLOCK;
return 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;
}
STC_LOGI("Log prefix [%s]", fw_rule->log_prefix);
+ STC_UNLOCK;
return 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;
}
STC_LOGI("Nflog group [%d]", fw_rule->nflog_group);
+ STC_UNLOCK;
return 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;
}
STC_LOGI("Nflog prefix [%s]", fw_rule->nflog_prefix);
+ STC_UNLOCK;
return 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;
}
STC_LOGI("Nflog range [%d]", fw_rule->nflog_range);
+ STC_UNLOCK;
return 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;
}
STC_LOGI("Nflog threshold [%d]", fw_rule->nflog_threshold);
+ STC_UNLOCK;
return 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 (!chain) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Chain [%s]", *chain);
+ STC_UNLOCK;
return 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 (!direction) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Direction [%s]", _stc_convert_fw_direction_to_string(*direction));
+ STC_UNLOCK;
return 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 (!type) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Source IP type [%s]", _stc_convert_fw_ip_type_to_string(*type));
+ STC_UNLOCK;
return 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 (!type) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Destination IP type [%s]", _stc_convert_fw_ip_type_to_string(*type));
+ STC_UNLOCK;
return 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 (!type) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Source port type [%s]", _stc_convert_fw_port_type_to_string(*type));
+ STC_UNLOCK;
return 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 (!type) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Destination port type [%s]", _stc_convert_fw_port_type_to_string(*type));
+ STC_UNLOCK;
return 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 (!type) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Protocol type [%s]", _stc_convert_fw_protocol_type_to_string(*type));
+ STC_UNLOCK;
return 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 (!type) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Address family type [%s]", _stc_convert_fw_family_type_to_string(*type));
+ STC_UNLOCK;
return 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 (!ip1 || !ip2) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Source IP [%s:%s]", *ip1, *ip2);
+ STC_UNLOCK;
return 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 (!ip1 || !ip2) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Destination IP [%s:%s]", *ip1, *ip2);
+ STC_UNLOCK;
return 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 (!port1 || !port2) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Source port [%u:%u]", *port1, *port2);
+ STC_UNLOCK;
return 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 (!port1 || !port2) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Destination port [%u:%u]", *port1, *port2);
+ STC_UNLOCK;
return 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 (!ifname) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Interface name [%s]", *ifname);
+ STC_UNLOCK;
return 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 (!target) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Target [%s]", _stc_convert_fw_rule_target_to_string(*target));
+ STC_UNLOCK;
return 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 (!level) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Log level [%u]", *level);
+ STC_UNLOCK;
return 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 (!prefix) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Log prefix [%s]", *prefix);
+ STC_UNLOCK;
return 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 (!group) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Nflog group [%d]", *group);
+ STC_UNLOCK;
return 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 (!prefix) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Nflog prefix [%s]", *prefix);
+ STC_UNLOCK;
return 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 (!range) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Nflog range [%d]", *range);
+ STC_UNLOCK;
return 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 (!threshold) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
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,
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));
*****************************************************************************/
//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;
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,
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;
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,
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 (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
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
}
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;
}
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
}
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;
}
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
}
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,
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
}
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;
}
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 (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;
}
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 (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;
}
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;
}
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;
}
{
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;
}
{
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;
}
{
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;
}
{
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;
}
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;
}
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;
}
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 (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;
}
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;
}
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;
}
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;
}
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)
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;
}
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;
}
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;
}
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
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;
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);
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;
__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,
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;
__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,
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;
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,
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;
}
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;
_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,
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
{
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;
}
STC_LOGI("Successfully created pcap handle");
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Successfully destroyed pcap handle");
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
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;
}
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;
}
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));
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;
}
{
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;
}
STC_LOGI("Interface name [%s]", pcap->ifname);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Nflog group [%d]", pcap->nflog_group);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Interface name [%s]", *ifname);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Nflog group [%d]", *group);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC);
+ STC_LOCK;
+
if (!name) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Device name [%s]", *name);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC);
+ STC_LOCK;
+
if (!decs) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Device description [%s]", *decs);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC);
+ STC_LOCK;
+
if (!net) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Device net [%s]", *net);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC);
+ STC_LOCK;
+
if (!mask) {
STC_LOGE("Invalid parameter");
+ STC_UNLOCK;
return STC_ERROR_INVALID_PARAMETER;
}
STC_LOGI("Device mask [%s]", *mask);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
//LCOV_EXCL_STOP
* Global Variables
*****************************************************************************/
+static GSList *g_reset_rule = NULL;
+
/*****************************************************************************
* Local Functions Definition
*****************************************************************************/
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;
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;
__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,
{
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;
}
{
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;
}
{
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_LOGI("App id [%s]", reset_rule->app_id);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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_LOGI("Subscriber ID [%s]", reset_rule->subscriber_id);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
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;
}
{
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;
}
STC_LOGI("Time interval from[%lu] to[%lu]",
reset_rule->interval.from, reset_rule->interval.to);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
{
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;
}
{
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_LOGI("Iftype [%s]", _stc_convert_iface_type_to_string(*iface_type));
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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_LOGI("Time interval from[%lu] to[%lu]", *from, *to);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
//LCOV_EXCL_STOP
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);
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);
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(
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);
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)
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;
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);
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);
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");
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;
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,
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;
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,
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;
__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,
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;
__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,
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)
{
__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,
{
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;
}
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;
}
*rule = (stc_restriction_rule_h)restriction_rule;
STC_LOGI("Restriction rule successfully created");
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Restriction rule successfully destroyed");
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("App id [%s]", restriction_rule->app_id);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Ifname [%s]", restriction_rule->iface_name);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
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;
}
{
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;
}
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;
}
{
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;
}
STC_LOGI("Data limit [%lld] bytes", restriction_rule->data_limit);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Data warn limit [%lld] bytes",
restriction_rule->data_warn_limit);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Monthly limit [%lld] bytes",
restriction_rule->monthly_limit);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Weekly data limit [%lld] bytes",
restriction_rule->weekly_limit);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Daily data limit [%lld] bytes",
restriction_rule->daily_limit);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Month start date [%d]",
restriction_rule->month_start_date);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
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;
}
{
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;
}
STC_LOGI("Subscriber ID [%s]", restriction_rule->subscriber_id);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
(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;
}
{
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;
}
(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;
}
{
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;
}
STC_LOGI("Iftype [%s]", _stc_convert_iface_type_to_string(*iface_type));
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Type [%s]", _stc_convert_rstn_type_to_string(*type));
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Data limit [%lld] bytes", *data_limit);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Data Warn limit [%lld] bytes", *data_warn_limit);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Monthly data limit [%lld] bytes", *limit);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Weekly data limit [%lld] bytes", *limit);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Daily data limit [%lld] bytes", *limit);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Month start date [%d]", *date);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
STC_LOGI("Roaming type [%s]",
_stc_convert_roaming_to_string(*roaming_type));
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
(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;
}
{
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;
}
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;
}
*list_h = (stc_restriction_list_h)restriction_list;
STC_LOGI("Restriction list successfully created");
+ STC_UNLOCK;
return 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_LOGI("Restriction list successfully destroyed");
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
//LCOV_EXCL_STOP
* Global Variables
*****************************************************************************/
+static GSList *g_stats_rule = NULL;
+
/*****************************************************************************
* Local Functions Definition
*****************************************************************************/
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);
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(
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);
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(
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);
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(
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);
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;
__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,
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
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;
__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,
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
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;
__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,
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
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;
__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,
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
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;
}
{
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;
}
{
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_LOGI("App id [%s]", stats_rule->app_id);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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
}
STC_LOGI("Time interval from[%lu] to[%lu]",
stats_rule->interval.from, stats_rule->interval.to);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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;
}
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;
}
{
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;
}
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;
}
{
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;
}
{
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_LOGI("Time interval from[%lu] to[%lu]", *from, *to);
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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_LOGI("Iftype [%s]", _stc_convert_iface_type_to_string(*iface_type));
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
{
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_LOGI("Time period [%s]",
_stc_convert_time_period_to_string(*time_period));
+ STC_UNLOCK;
return STC_ERROR_NONE;
}
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;
}
{
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;
}
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
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
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);
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
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);
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);
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
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
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)
void *user_data)
{
int ret = STC_ERROR_NONE;
- char *app_id;
+ char *app_id = NULL;
msg(HR_SINGLE);
void *user_data)
{
int ret = STC_ERROR_NONE;
- char *app_id;
+ char *app_id = NULL;
msg(HR_SINGLE);
projects / platform / core / api / smart-traffic-control.git / commitdiff