Add to load restriction list

Change-Id: If7e251612c9ca07fed94e0bca183f64671c8d741
Signed-off-by: hyunuktak <hyunuk.tak@samsung.com>

diff --git a/include/stc_mgr_internal.h b/include/stc_mgr_internal.h
index a16fdd9792e8d3ff83da344e5f7b7c5a8ba84bdb..d131e146481b997256ce6cce2abe4e539848ef36 100755 (executable)
--- a/include/stc_mgr_internal.h
+++ b/include/stc_mgr_internal.h
@@ -534,6 +534,53 @@ int stc_remove_restriction_rule_from_list(stc_restriction_list_h list_h,
  */
 int stc_save_restriction_list(stc_restriction_list_h list_h);
 
+/**
+ * @brief Loads the restriction list.
+ * @since_tizen 5.5
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/network.get
+ *
+ * @param[in] stc The stc handle
+ * @param[in] list_cb The callback is called for each restriction list
+ * @param[in] user_data User data will be passed to the callback function
+ *
+ * @return 0 on success, otherwise a negative error value
+ * @retval #STC_ERROR_NONE Successful
+ * @retval #STC_ERROR_OPERATION_FAILED General error
+ * @retval #STC_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #STC_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #STC_ERROR_INVALID_OPERATION Invalid operation
+ * @retval #STC_ERROR_NOT_INITIALIZED Not initialized
+ * @retval #STC_ERROR_NOT_SUPPORTED Not supported
+ * @retval #STC_ERROR_PERMISSION_DENIED Permission denied
+ *
+ * @see #stc_restriction_list_h
+ * @see #stc_restriction_rule_h
+ * @see stc_initialize()
+ * @see stc_restriction_rule_create()
+ * @see stc_restriction_rule_destroy()
+ * @see stc_restriction_rule_set_app_id()
+ * @see stc_restriction_rule_set_iface_name()
+ * @see stc_restriction_rule_set_iface_type()
+ * @see stc_restriction_rule_set_limit()
+ * @see stc_restriction_rule_set_warning_limit()
+ * @see stc_restriction_rule_set_roaming_type()
+ * @see stc_restriction_rule_set_subscriber_id()
+ * @see stc_restriction_rule_get_app_id()
+ * @see stc_restriction_rule_get_iface_type()
+ * @see stc_restriction_rule_get_limit()
+ * @see stc_restriction_rule_get_warning_limit()
+ * @see stc_restriction_rule_get_roaming_type()
+ * @see stc_restriction_rule_get_subscriber_id()
+ * @see stc_restriction_rule_get_process_state()
+ * @see stc_restriction_list_create()
+ * @see stc_add_restriction_rule_to_list()
+ * @see stc_remove_restriction_rule_from_list()
+ * @see stc_set_restriction_list()
+ * @see stc_unset_restriction_list()
+ */
+int stc_load_restriction_list(stc_h stc, stc_restriction_list_cb list_cb, void *user_data);
+
 /**
  * @brief Sets the restriction list.
  * @since_tizen 5.5

diff --git a/include/stc_rstn_internal.h b/include/stc_rstn_internal.h
index df15b398a794b1e88eea7068d3a60eeb2b8bd2fd..0fc34749d894080381ae08d3bd354ae73ac54bed 100755 (executable)
--- a/include/stc_rstn_internal.h
+++ b/include/stc_rstn_internal.h
@@ -80,6 +80,17 @@ typedef enum {
        STC_RSTN_TYPE_LAST_ELEM,
 } stc_restriction_type_e;
 
+/**
+ * @brief Enumeration for network restriction state.
+ * @since_tizen 5.5
+ */
+typedef enum {
+       STC_RSTN_STATE_UNKNOWN,
+       STC_RSTN_STATE_ACTIVATED,
+       STC_RSTN_STATE_DEACTIVATED,
+       STC_RSTN_STATE_LAST_ELEM
+} stc_restriction_state_e;
+
 /**
 * @}
 */

diff --git a/src/include/stc-restriction.h b/src/include/stc-restriction.h
index 34853de20a0b8a4e09900f95855a9369f27c7cd7..0f313c6b574e1719c8953afff1d7153781fd450a 100755 (executable)
--- a/src/include/stc-restriction.h
+++ b/src/include/stc-restriction.h
@@ -61,6 +61,9 @@ extern "C" {
 #define STC_RESTRICTION_RULE_DAILY_LIMIT               "daily_limit"
 #define STC_RESTRICTION_RULE_MONTH_START_DATE  "month_start_date"
 
+#define STC_RESTRICTION_LIST_NAME               "name"
+#define STC_RESTRICTION_LIST_STATE              "state"
+
 typedef struct {
        char app_id[STC_APP_ID_LEN];
        char iface_name[STC_IFNAME_LEN];
@@ -79,6 +82,7 @@ typedef struct {
 typedef struct {
        char name[STC_LIST_NAME_LEN];
        GSList *rules;
+       stc_restriction_state_e state;
 } stc_restriction_list_s;
 
 /*****************************************************************************
@@ -102,7 +106,12 @@ void _stc_restriction_add_list(stc_restriction_list_h list);
 void _stc_restriction_remove_list(stc_restriction_list_h list);
 bool _stc_restriction_check_list_validity(stc_restriction_list_h list);
 
+void _stc_restriction_add_to_load_list(stc_restriction_list_h list);
+void _stc_restriction_remove_from_load_list(stc_restriction_list_h list);
+void _stc_restriction_clear_load_list(void);
+
 stc_error_e _stc_restriction_save_list(stc_restriction_list_h list);
+stc_error_e _stc_restriction_load_list(void);
 
 stc_error_e _stc_restriction_validate_rule(
                stc_restriction_rule_h rule);

diff --git a/src/internal/include/stc-dbus.h b/src/internal/include/stc-dbus.h
index d30b2be874b7a006300948260f2ea4a4dce064f5..1d74d60d2c16fee23f465288e3ceabd46306bdb1 100755 (executable)
--- a/src/internal/include/stc-dbus.h
+++ b/src/internal/include/stc-dbus.h
@@ -74,6 +74,7 @@ extern "C" {
 #define STC_MANAGER_METHOD_RESTRICTION_UNSET            "Unset"
 
 #define STC_MANAGER_METHOD_RESTRICTION_SAVE_LIST        "SaveList"
+#define STC_MANAGER_METHOD_RESTRICTION_LOAD_LIST        "LoadList"
 
 #define STC_MANAGER_METHOD_IPTABLES_COMMIT              "CommitIptables"
 #define STC_MANAGER_METHOD_IP6TABLES_COMMIT             "CommitIp6tables"

diff --git a/src/internal/include/stc-event.h b/src/internal/include/stc-event.h
index 15c6eed94f0d0e38e14e067ae7d55ff6c7ea85fd..9d91ccd6546118b714ba820d41eb30b21ee3673e 100755 (executable)
--- a/src/internal/include/stc-event.h
+++ b/src/internal/include/stc-event.h
@@ -57,6 +57,7 @@ typedef enum {
        STC_EVENT_STATS_GET_TOTAL_RSP,
        STC_EVENT_RESTRICTION_GET_RSP,
        STC_EVENT_RESTRICTION_GET_ALL_RSP,
+       STC_EVENT_RESTRICTION_LOAD_LIST_RSP,
        STC_EVENT_WARN_THRESHOLD_CROSSED_RSP,
        STC_EVENT_RESTRICTION_THRESHOLD_CROSSED_RSP,
        STC_EVENT_PCAP_FIND_ALL_DEVS_RSP,
@@ -70,6 +71,7 @@ typedef enum {
        STC_REQUEST_TABLE_STATS_GET_TOTAL,
        STC_REQUEST_TABLE_RESTRICTION_GET,
        STC_REQUEST_TABLE_RESTRICTION_GET_ALL,
+       STC_REQUEST_TABLE_RESTRICTION_LOAD_LIST,
        STC_REQUEST_TABLE_PCAP_FIND_ALL_DEVS,
        STC_REQUEST_TABLE_LAST_ELEM,
 } stc_request_table_e;

diff --git a/src/internal/include/stc-private.h b/src/internal/include/stc-private.h
index 7ac0a39a4c69667f19e1cbd975a182d67f642913..c534b57611f9d0ca7f10dbb42608601f4a816ab7 100755 (executable)
--- a/src/internal/include/stc-private.h
+++ b/src/internal/include/stc-private.h
@@ -70,6 +70,9 @@ typedef struct {
        stc_restriction_rule_cb restriction_all_cb;
        void *restriction_all_user_data;
 
+       stc_restriction_list_cb restriction_list_cb;
+       void *restriction_list_user_data;
+
        stc_threshold_crossed_cb restriction_crossed_cb;
        void *restriction_crossed_user_data;
        stc_threshold_crossed_cb warn_crossed_cb;
@@ -142,6 +145,8 @@ void _stc_callback_set_restriction_rule(stc_h stc,
                        stc_restriction_rule_cb user_cb, void *user_data);
 void _stc_callback_set_restriction_all_rule(stc_h stc,
                        stc_restriction_rule_cb user_cb, void *user_data);
+void _stc_callback_set_restriction_list(stc_h stc,
+                       stc_restriction_list_cb user_cb, void *user_data);
 
 void _stc_callback_set_restriction_threshold_crossed(stc_h stc,
                        stc_threshold_crossed_cb user_cb, void *user_data);

diff --git a/src/internal/stc-private.c b/src/internal/stc-private.c
index eeeffa3f80a87cd2add7b3473c6d44323c70a0c8..5012762c36c89ccc7b990070f626465714da8198 100755 (executable)
--- a/src/internal/stc-private.c
+++ b/src/internal/stc-private.c
@@ -510,6 +510,28 @@ static void __stc_callback_foreach(stc_event_e e,
                                handle->restriction_all_user_data = NULL;
                        }
                        break;
+               case STC_EVENT_RESTRICTION_LOAD_LIST_RSP:
+                       if (handle->restriction_list_cb) {
+                               if (err == STC_ERROR_NONE) {
+                                       if (info_data != NULL) {
+                                               for (data = info_data; data; data = data->next) {
+                                                       stc_restriction_list_h load_list = data->data;
+                                                       ret = handle->restriction_list_cb(err,
+                                                               load_list, handle->restriction_list_user_data);
+                                                       if (ret == STC_CALLBACK_CANCEL)
+                                                               break;
+                                               }
+                                       } else {
+                                               handle->restriction_all_cb(err, NULL, NULL);
+                                       }
+                               } else {
+                                       handle->restriction_list_cb(err, NULL, NULL);
+                               }
+
+                               handle->restriction_list_cb = NULL;
+                               handle->restriction_list_user_data = NULL;
+                       }
+                       break;
                case STC_EVENT_PCAP_FIND_ALL_DEVS_RSP:
                        if (handle->pcap_info_cb) {
                                if (err == STC_ERROR_NONE) {
@@ -590,6 +612,13 @@ static void __stc_event_cb(stc_event_info_s *event_info, void *user_data)
                        g_slist_free(info_data);
                }
                break;
+       case STC_EVENT_RESTRICTION_LOAD_LIST_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);
+               }
+               break;
        //LCOV_EXCL_START
        case STC_EVENT_WARN_THRESHOLD_CROSSED_RSP:
        case STC_EVENT_RESTRICTION_THRESHOLD_CROSSED_RSP:
@@ -720,6 +749,15 @@ void _stc_callback_set_restriction_all_rule(stc_h stc,
        handle->restriction_all_user_data = user_data;
 }
 
+void _stc_callback_set_restriction_list(stc_h stc,
+                       stc_restriction_list_cb user_cb, void *user_data)
+{
+       stc_handle_s *handle = (stc_handle_s *)stc;
+
+       handle->restriction_list_cb = user_cb;
+       handle->restriction_list_user_data = user_data;
+}
+
 void _stc_callback_set_restriction_threshold_crossed(stc_h stc,
                        stc_threshold_crossed_cb user_cb, void *user_data)
 {

diff --git a/src/stc-manager.c b/src/stc-manager.c
index b1933884b5456775ac465d547b21d0009baa2250..e45d5d6ad262b804550f8e4af6f8a81daab6bf74 100755 (executable)
--- a/src/stc-manager.c
+++ b/src/stc-manager.c
@@ -630,6 +630,35 @@ EXPORT_API int stc_save_restriction_list(stc_restriction_list_h list_h)
        return STC_ERROR_NONE;
 }
 
+EXPORT_API int stc_load_restriction_list(stc_h stc,
+                               stc_restriction_list_cb list_cb, void *user_data)
+{
+       int ret = STC_ERROR_NONE;
+
+       CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC);
+
+       if (!(_stc_handle_check_validity(stc))) {
+               STC_LOGE("Invalid parameter");
+               return STC_ERROR_INVALID_PARAMETER;
+       }
+
+       if (list_cb == NULL) {
+               STC_LOGE("Invalid parameter");
+               return STC_ERROR_INVALID_PARAMETER;
+       }
+
+       _stc_callback_set_restriction_list(stc, list_cb, user_data);
+
+       ret = _stc_restriction_load_list();
+       if (ret != STC_ERROR_NONE) {
+               STC_LOGE("Failed to request restriction list [%s]",
+                       _stc_convert_error_type_to_string(ret));
+               return ret;
+       }
+
+       return STC_ERROR_NONE;
+}
+
 EXPORT_API int stc_iptables_commit(stc_h stc, const char *option,
                int *err_num, char **err_str)
 {

diff --git a/src/stc-restriction.c b/src/stc-restriction.c
index 83e74dbf1aeffa41e5d180c5a7e3f91249497d36..a5587569438d6745fd9b85fcddd1a5272838eaae 100755 (executable)
--- a/src/stc-restriction.c
+++ b/src/stc-restriction.c
@@ -59,6 +59,7 @@
 
 static GSList *g_restriction_rule = NULL;
 static GSList *g_restriction_list = NULL;
+static GSList *g_restriction_load_list = NULL;
 
 /*****************************************************************************
  *  Local Functions Definition
@@ -91,11 +92,14 @@ static void __stc_restriction_init_list(stc_restriction_list_s *list,
 {
        g_strlcpy(list->name, name, STC_LIST_NAME_LEN);
        list->rules = NULL;
+       list->state = STC_RSTN_STATE_DEACTIVATED;
 }
 
-static void __stc_restriction_deinit_list(stc_restriction_list_h list)
+static void __stc_restriction_deinit_list(stc_restriction_list_h list_h)
 {
-       g_free(list);
+       stc_restriction_list_s *data = (stc_restriction_list_s *)list_h;
+       g_slist_free_full(data->rules, __stc_restriction_deinit_rule);
+       g_free(list_h);
 }
 
 static void __stc_restriction_rule_make_params(
@@ -306,8 +310,28 @@ static void __stc_restriction_extract_rule_cb(const char *key,
 
 }
 
-static void __stc_restriction_print_rule(
-                       stc_restriction_rule_s *rule)
+static void __stc_restriction_extract_list_cb(const char *key,
+                       GVariant *value, void *user_data)
+{
+       stc_restriction_list_s *restriction_list =
+               (stc_restriction_list_s *)user_data;
+
+       if (restriction_list == NULL)
+               return;
+
+       if (!g_strcmp0(key, STC_RESTRICTION_LIST_NAME)) {
+               const char *name = g_variant_get_string(value, NULL);
+               if (name != NULL)
+                       g_strlcpy(restriction_list->name, name, STC_LIST_NAME_LEN);
+
+       } else if (!g_strcmp0(key, STC_RESTRICTION_LIST_STATE)) {
+               restriction_list->state = g_variant_get_uint16(value);
+
+       }
+
+}
+
+static void __stc_restriction_print_rule(stc_restriction_rule_s *rule)
 {
        STC_LOGD(STC_HR_SINGLE);
 
@@ -345,6 +369,86 @@ static void __stc_restriction_print_rule(
        STC_LOGD(STC_HR_SINGLE);
 }
 
+static void __stc_restriction_print_list(stc_restriction_list_s *list)
+{
+       STC_LOGD(STC_HR_SINGLE);
+
+       STC_LOGD("Name:    [%s]", list->name);
+       STC_LOGD("State:   [%u]", list->state);
+
+       STC_LOGD(STC_HR_SINGLE);
+}
+
+bool __stc_restriction_check_list_validity(stc_restriction_list_h list_h)
+{
+       if (!list_h)
+               return false;
+
+       if (g_slist_find(g_restriction_list, list_h))
+               return true;
+
+       return false;
+}
+
+static void __stc_restriction_load_list_reply(
+                       GObject *source_object, GAsyncResult *res, gpointer user_data)
+{
+       GDBusConnection *conn = NULL;
+       GError *dbus_error = NULL;
+       GVariant *dbus_data = NULL;
+       GVariantIter *iter = NULL;
+       GVariantIter *iter_row = NULL;
+       stc_error_e dbus_result = STC_ERROR_NONE;
+       stc_error_e error = STC_ERROR_NONE;
+       stc_restriction_list_s *restriction_list = NULL;
+       stc_event_info_s event_data = { 0, };
+
+       conn = G_DBUS_CONNECTION(source_object);
+       dbus_data = g_dbus_connection_call_finish(conn, res, &dbus_error);
+       if (dbus_error != NULL) {
+               error = _stc_convert_error_string_to_enum(dbus_error->message);
+               g_error_free(dbus_error);
+       }
+
+       if (_stc_event_get_request_table_state(STC_REQUEST_TABLE_RESTRICTION_LOAD_LIST))
+               _stc_event_set_request_table_state(STC_REQUEST_TABLE_RESTRICTION_LOAD_LIST, false);
+
+       if (error == STC_ERROR_NONE) {
+               g_variant_get(dbus_data, "(iaa{sv})", &dbus_result, &iter);
+
+               _stc_restriction_clear_load_list();
+
+               while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
+                       restriction_list = g_try_malloc0(sizeof(stc_restriction_list_s));
+                       if (restriction_list) {
+                               _stc_dbus_dictionary_foreach(iter_row,
+                                       __stc_restriction_extract_list_cb, restriction_list);
+
+                               __stc_restriction_print_list(restriction_list);
+
+                               _stc_restriction_add_to_load_list(restriction_list);
+                       }
+                       g_variant_iter_free(iter_row);
+               }
+               g_variant_iter_free(iter);
+
+               event_data.event = STC_EVENT_RESTRICTION_LOAD_LIST_RSP;
+               event_data.info_data = g_restriction_load_list;
+               event_data.datalength = 0;
+               event_data.error = dbus_result;
+       } else {
+               STC_LOGE("Load restriction list response error [%s]",
+                       _stc_convert_error_type_to_string(error));
+
+               event_data.event = STC_EVENT_RESTRICTION_LOAD_LIST_RSP;
+               event_data.info_data = NULL;
+               event_data.datalength = 0;
+               event_data.error = error;
+       }
+
+       _stc_event_add_client_idle_cb(&event_data, user_data);
+}
+
 static void __stc_restriction_get_per_app_id_reply(
                        GObject *source_object, GAsyncResult *res, gpointer user_data)
 {
@@ -557,51 +661,92 @@ bool _stc_restriction_check_rule_validity(stc_restriction_rule_h rule)
                return false;
 }
 
-bool _stc_restriction_add_rule_to_list(stc_restriction_list_h list,
+bool _stc_restriction_add_rule_to_list(stc_restriction_list_h list_h,
                        stc_restriction_rule_h rule)
 {
-       GSList *find = g_slist_find(g_restriction_list, list);
+       GSList *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);
                return true;
        } else {
-               return false;
+               find = g_slist_find(g_restriction_load_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);
+                       return true;
+               } else {
+                       return false;
+               }
        }
 }
 
-bool _stc_restriction_remove_rule_from_list(stc_restriction_list_h list,
+bool _stc_restriction_remove_rule_from_list(stc_restriction_list_h list_h,
                        stc_restriction_rule_h rule)
 {
-       GSList *find = g_slist_find(g_restriction_list, list);
+       GSList *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);
+               list_data->rules = g_slist_remove(list_data->rules, rule);
                return true;
        } else {
-               return false;
+               find = g_slist_find(g_restriction_load_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);
+                       return true;
+               } else {
+                       return false;
+               }
        }
 }
 
-void _stc_restriction_add_list(stc_restriction_list_h list)
+void _stc_restriction_add_to_list(stc_restriction_list_h list_h)
 {
-       g_restriction_list = g_slist_append(g_restriction_list, list);
+       g_restriction_list = g_slist_append(g_restriction_list, list_h);
 }
 
-void _stc_restriction_remove_list(stc_restriction_list_h list)
+void _stc_restriction_remove_from_list(stc_restriction_list_h list_h)
 {
-       g_restriction_list = g_slist_remove(g_restriction_list, list);
+       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)
+bool _stc_restriction_check_list_validity(stc_restriction_list_h list_h)
 {
-       if (!list)
+       if (!list_h)
                return false;
 
-       if (g_slist_find(g_restriction_list, list))
+       if (g_slist_find(g_restriction_list, list_h))
                return true;
-       else
-               return false;
+       else if (g_slist_find(g_restriction_load_list, list_h))
+               return true;
+
+       return false;
+}
+
+GSList * _stc_restriction_get_load_list_handle(void)
+{
+       return g_restriction_load_list;
+}
+
+void _stc_restriction_add_to_load_list(stc_restriction_list_h list_h)
+{
+       g_restriction_load_list = g_slist_append(g_restriction_load_list, list_h);
+}
+
+void _stc_restriction_remove_from_load_list(stc_restriction_list_h list_h)
+{
+       g_restriction_load_list = g_slist_remove(g_restriction_load_list, list_h);
+       __stc_restriction_deinit_list(list_h);
+}
+
+void _stc_restriction_clear_load_list(void)
+{
+       if (g_restriction_load_list) {
+               g_slist_free_full(g_restriction_load_list, __stc_restriction_deinit_list);
+               g_restriction_load_list = NULL;
+       }
 }
 
 stc_error_e _stc_restriction_save_list(stc_restriction_list_h list_h)
@@ -636,6 +781,44 @@ stc_error_e _stc_restriction_save_list(stc_restriction_list_h list_h)
        return STC_ERROR_NONE;
 }
 
+stc_error_e _stc_restriction_load_list(void)
+{
+       stc_error_e error = STC_ERROR_NONE;
+
+       STC_RETURN_VAL_IF(_stc_event_get_ref_count() < 1,
+               STC_ERROR_NOT_INITIALIZED,
+               "Event callback is not registered");
+
+       STC_RETURN_VAL_IF(
+               _stc_event_get_request_table_state(
+               STC_REQUEST_TABLE_RESTRICTION_LOAD_LIST),
+               STC_ERROR_IN_PROGRESS,
+               "Request in progress");
+
+       _stc_event_set_request_table_state(
+               STC_REQUEST_TABLE_RESTRICTION_LOAD_LIST, true);
+
+       error = _stc_dbus_invoke_method_nonblock(
+               STC_MANAGER_SERVICE,
+               STC_MANAGER_RESTRICTION_PATH,
+               STC_MANAGER_RESTRICTION_INTERFACE,
+               STC_MANAGER_METHOD_RESTRICTION_LOAD_LIST,
+               NULL,
+               STC_DBUS_REPLY_TIMEOUT,
+               __stc_restriction_load_list_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_LOAD_LIST, false);
+               return error;
+       }
+
+       return STC_ERROR_NONE;
+}
+
 stc_error_e _stc_restriction_validate_rule(
                stc_restriction_rule_h rule)
 
@@ -1655,7 +1838,7 @@ EXPORT_API int stc_restriction_list_create(const char *name,
        }
 
        __stc_restriction_init_list(restriction_list, name);
-       _stc_restriction_add_list((stc_restriction_list_h)restriction_list);
+       _stc_restriction_add_to_list((stc_restriction_list_h)restriction_list);
 
        *list_h = (stc_restriction_list_h)restriction_list;
        STC_LOGI("Restriction list successfully created [%s]", name);
@@ -1663,17 +1846,16 @@ EXPORT_API int stc_restriction_list_create(const char *name,
        return STC_ERROR_NONE;
 }
 
-EXPORT_API int stc_restriction_list_destroy(stc_restriction_list_h list)
+EXPORT_API int stc_restriction_list_destroy(stc_restriction_list_h list_h)
 {
        CHECK_FEATURE_SUPPORTED(TIZEN_FEATURE_STC);
 
-       if (_stc_restriction_check_list_validity(list) == false) {
+       if (__stc_restriction_check_list_validity(list_h) == false) {
                STC_LOGE("Invalid parameter");
                return STC_ERROR_INVALID_PARAMETER;
        }
 
-       _stc_restriction_remove_list(list);
-       __stc_restriction_deinit_list(list);
+       _stc_restriction_remove_from_list(list_h);
 
        STC_LOGI("Restriction list successfully destroyed");