#include "table-restrictions.h"
#include "stc-restriction.h"
#include "stc-manager-gdbus.h"
-#include "stc-monitor.h"
+#include "stc-manager-plugin-monitor.h"
#define RESTRICTION_DBUS_ERROR_NAME "net.stc.restriction.Error.Failed"
"OUT_OF_MEMORY",
"INVALID_PARAMETER",
"NO_DATA",
+ "ALREADY_DATA",
"UNINITIALIZED",
+ "PERMISSION_DENIED",
"NOTIMPL"
};
void __initialize_rstn_rule(table_restrictions_info *rule)
{
rule->app_id = NULL;
- rule->ifname = NULL;
+
rule->iftype = STC_IFACE_ALL;
- rule->rst_state = STC_RESTRICTION_REMOVED;
- rule->rcv_limit = 0;
- rule->send_limit = 0;
- rule->rcv_warn_limit = 0;
- rule->send_warn_limit = 0;
+ rule->ifname = NULL;
+
+ rule->subscriber_id = NULL;
rule->roaming = STC_ROAMING_DISABLE;
- rule->imsi = NULL;
+
+ rule->rstn_type = STC_RSTN_TYPE_UNKNOWN;
+ rule->data_limit = -1;
+ rule->data_warn_limit = -1;
+
+ rule->month_start_date = 1;
+ rule->monthly_limit = -1;
+ rule->weekly_limit = -1;
+ rule->daily_limit = -1;
+
+ rule->mac = NULL;
}
-gboolean __validate_rstn_rule(table_restrictions_info *rule,
- enum traffic_restriction_type rst_type)
+gboolean __validate_rstn_rule(table_restrictions_info *rule)
{
__STC_LOG_FUNC_ENTER__;
if (rule == NULL) {
- __STC_LOG_FUNC_EXIT__;
- return FALSE;
- }
-
- if (rst_type <= RST_UNDEFINDED || rst_type >= RST_MAX_VALUE) {
- __STC_LOG_FUNC_EXIT__;
- return FALSE;
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return FALSE; //LCOV_EXCL_LINE
}
if (rule->iftype <= STC_IFACE_UNKNOWN ||
rule->iftype >= STC_IFACE_LAST_ELEM) {
- __STC_LOG_FUNC_EXIT__;
- return FALSE;
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return FALSE; //LCOV_EXCL_LINE
}
- if (rule->roaming >= STC_ROAMING_LAST_ELEM) {
- __STC_LOG_FUNC_EXIT__;
- return FALSE;
+ if (rule->roaming > STC_ROAMING_DISABLE) {
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return FALSE; //LCOV_EXCL_LINE
}
- if (rule->imsi == NULL) {
- __STC_LOG_FUNC_EXIT__;
- return FALSE;
+ if (rule->subscriber_id == NULL) {
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return FALSE; //LCOV_EXCL_LINE
}
if (rule->app_id == NULL) {
- __STC_LOG_FUNC_EXIT__;
- return FALSE;
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return FALSE; //LCOV_EXCL_LINE
}
__STC_LOG_FUNC_EXIT__;
__STC_LOG_FUNC_ENTER__;
if (!builder || !info) {
- __STC_LOG_FUNC_EXIT__;
- return;
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return; //LCOV_EXCL_LINE
}
g_variant_builder_add(builder, "{sv}", "app_id",
g_variant_builder_add(builder, "{sv}", "iftype",
g_variant_new_uint16(info->iftype));
- g_variant_builder_add(builder, "{sv}", "rst_state",
- g_variant_new_uint16(info->rst_state));
+ g_variant_builder_add(builder, "{sv}", "rstn_type",
+ g_variant_new_uint16(info->rstn_type));
+
+ g_variant_builder_add(builder, "{sv}", "data_limit",
+ g_variant_new_int64(info->data_limit));
- g_variant_builder_add(builder, "{sv}", "rcv_limit",
- g_variant_new_int64(info->rcv_limit));
+ g_variant_builder_add(builder, "{sv}", "data_warn_limit",
+ g_variant_new_int64(info->data_warn_limit));
- g_variant_builder_add(builder, "{sv}", "send_limit",
- g_variant_new_int64(info->send_limit));
+ g_variant_builder_add(builder, "{sv}", "month_start_date",
+ g_variant_new_int32(info->month_start_date));
- g_variant_builder_add(builder, "{sv}", "rcv_warn_limit",
- g_variant_new_int64(info->rcv_warn_limit));
+ g_variant_builder_add(builder, "{sv}", "monthly_limit",
+ g_variant_new_int64(info->monthly_limit));
- g_variant_builder_add(builder, "{sv}", "send_warn_limit",
- g_variant_new_int64(info->send_warn_limit));
+ g_variant_builder_add(builder, "{sv}", "weekly_limit",
+ g_variant_new_int64(info->weekly_limit));
+
+ g_variant_builder_add(builder, "{sv}", "daily_limit",
+ g_variant_new_int64(info->daily_limit));
g_variant_builder_add(builder, "{sv}", "roaming",
g_variant_new_uint16(info->roaming));
- g_variant_builder_add(builder, "{sv}", "imsi",
- g_variant_new_string(info->imsi));
+ g_variant_builder_add(builder, "{sv}", "subscriber_id",
+ g_variant_new_string(info->subscriber_id));
__STC_LOG_FUNC_EXIT__;
}
GVariantBuilder sub_builder;
if (!info || !builder) {
- __STC_LOG_FUNC_EXIT__;
- return STC_CANCEL;
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return STC_CANCEL; //LCOV_EXCL_LINE
}
g_variant_builder_init(&sub_builder, G_VARIANT_TYPE("a{sv}"));
GVariantBuilder *builder = (GVariantBuilder *)user_data;
if (!info || !builder) {
- __STC_LOG_FUNC_EXIT__;
- return STC_CANCEL;
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return STC_CANCEL; //LCOV_EXCL_LINE
}
__stc_restriction_app_info_builder_add(builder, info);
static void __stc_extract_restriction_rule(const char *key, GVariant *value,
void *user_data)
{
- __STC_LOG_FUNC_ENTER__;
-
table_restrictions_info *rule =
(table_restrictions_info *) user_data;
if (rule == NULL) {
- __STC_LOG_FUNC_EXIT__;
- return;
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return; //LCOV_EXCL_LINE
}
if (!g_strcmp0(key, "app_id")) {
- guint str_length;
+ gsize str_length;
const gchar *str = g_variant_get_string(value, &str_length);
rule->app_id = g_strdup(str);
- STC_LOGD("app_id: [%s]", (unsigned int) rule->app_id);
+ STC_LOGD("app_id: [%s]", rule->app_id);
} else if (!g_strcmp0(key, "ifname")) {
- guint str_length;
+ gsize str_length;
const gchar *str = g_variant_get_string(value, &str_length);
rule->ifname = g_strdup(str);
STC_LOGD("ifname: [%s]", rule->ifname);
rule->iftype = g_variant_get_uint16(value);
STC_LOGD("iftype: [%u]", (unsigned int) rule->iftype);
- } else if (!g_strcmp0(key, "rcv_limit")) {
- rule->rcv_limit = g_variant_get_uint64(value);
- STC_LOGD("rcv_limit: [%lld]", rule->rcv_limit);
+ } else if (!g_strcmp0(key, "data_limit")) {
+ rule->data_limit = g_variant_get_int64(value);
+ STC_LOGD("data_limit: [%lld]", rule->data_limit);
+
+ } else if (!g_strcmp0(key, "data_warn_limit")) {
+ rule->data_warn_limit = g_variant_get_int64(value);
+ STC_LOGD("data_warn_limit: [%lld]", rule->data_warn_limit);
+
+ } else if (!g_strcmp0(key, "month_start_date")) {
+ rule->month_start_date = g_variant_get_int32(value);
+ STC_LOGD("month_start_date: [%d]", rule->month_start_date);
- } else if (!g_strcmp0(key, "send_limit")) {
- rule->send_limit = g_variant_get_uint64(value);
- STC_LOGD("send_limit: [%lld]", rule->send_limit);
+ } else if (!g_strcmp0(key, "monthly_limit")) {
+ rule->monthly_limit = g_variant_get_int64(value);
+ STC_LOGD("monthly_limit: [%lld]", rule->monthly_limit);
- } else if (!g_strcmp0(key, "rcv_warn_limit")) {
- rule->rcv_warn_limit = g_variant_get_uint64(value);
- STC_LOGD("rcv_warn_limit: [%lld]", rule->rcv_warn_limit);
+ } else if (!g_strcmp0(key, "weekly_limit")) {
+ rule->weekly_limit = g_variant_get_int64(value);
+ STC_LOGD("weekly_limit: [%lld]", rule->weekly_limit);
- } else if (!g_strcmp0(key, "send_warn_limit")) {
- rule->send_warn_limit = g_variant_get_uint64(value);
- STC_LOGD("send_warn_limit: [%lld]", rule->send_warn_limit);
+ } else if (!g_strcmp0(key, "daily_limit")) {
+ rule->daily_limit = g_variant_get_int64(value);
+ STC_LOGD("daily_limit: [%lld]", rule->daily_limit);
} else if (!g_strcmp0(key, "roaming")) {
rule->roaming = g_variant_get_uint16(value);
STC_LOGD("roaming: [%u]", rule->roaming);
- } else if (!g_strcmp0(key, "imsi")) {
- guint str_length;
+ } else if (!g_strcmp0(key, "subscriber_id")) {
+ gsize str_length;
const gchar *str = g_variant_get_string(value, &str_length);
- rule->imsi = g_strdup(str);
- STC_LOGD("imsi: [%s]", rule->imsi);
+ rule->subscriber_id = g_strdup(str);
+ STC_LOGD("subscriber_id: [%s]", rule->subscriber_id);
+
+ } else if (!g_strcmp0(key, "rstn_type")) {
+ rule->rstn_type = g_variant_get_uint16(value);
+ STC_LOGD("type: [%u]", (unsigned int) rule->rstn_type);
+
+ } else if (!g_strcmp0(key, "mac")) {
+ gsize str_length;
+ const gchar *str = g_variant_get_string(value, &str_length);
+ rule->mac = g_strdup(str);
+ STC_LOGD("mac: [%s]", rule->mac);
} else {
- STC_LOGD("Unknown select rule");
+ STC_LOGD("Unknown select rule"); //LCOV_EXCL_LINE
}
+}
- __STC_LOG_FUNC_EXIT__;
+static void __stc_free_restriction_rule_members(table_restrictions_info *rule)
+{
+ FREE(rule->app_id);
+ FREE(rule->ifname);
+ FREE(rule->subscriber_id);
+ FREE(rule->mac);
}
gboolean handle_restriction_set(StcRestriction *object,
__STC_LOG_FUNC_ENTER__;
GVariantIter *iter = NULL;
table_restrictions_info rule;
+ stc_error_e ret = STC_ERROR_NONE;
+
+ stc_set_keep_alive(TRUE);
memset(&rule, 0, sizeof(table_restrictions_info));
__initialize_rstn_rule(&rule);
g_variant_iter_free(iter);
}
- rule.rst_state = STC_RESTRICTION_REMOVED;
-
- if (__validate_rstn_rule(&rule, RST_SET) == FALSE) {
- STC_RESTRICTION_DBUS_REPLY_ERROR(invocation,
+ if (__validate_rstn_rule(&rule) == FALSE) {
+ STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
STC_ERROR_INVALID_PARAMETER);
- __STC_LOG_FUNC_EXIT__;
+ __stc_free_restriction_rule_members(&rule);
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
return TRUE;
}
- table_restrictions_update(&rule);
- /* update restriction rule in runtime structure */
- stc_monitor_rstns_tree_add(&rule);
+ ret = table_restrictions_update(&rule);
+ if (ret != STC_ERROR_NONE) {
+ STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
+ STC_ERROR_DB_FAILED);
+ __stc_free_restriction_rule_members(&rule);
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return TRUE;
+ }
+ ret = stc_plugin_monitor_add_rstn(&rule);
+ if (ret == STC_ERROR_UNINITIALIZED) {
+ STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
+ STC_ERROR_UNINITIALIZED);
+ table_restrictions_delete(rule.app_id, rule.iftype, rule.ifname,
+ rule.subscriber_id, rule.roaming);
+ __stc_free_restriction_rule_members(&rule);
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return TRUE;
+ } else if (ret == STC_ERROR_NO_DATA || ret == STC_ERROR_OUT_OF_MEMORY) {
+ STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
+ ret);
+ __stc_free_restriction_rule_members(&rule);
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return TRUE;
+ }
STC_DBUS_REPLY_ERROR_NONE(invocation);
+ __stc_free_restriction_rule_members(&rule);
__STC_LOG_FUNC_EXIT__;
return TRUE;
}
-gboolean handle_restriction_exclude(StcRestriction *object,
- GDBusMethodInvocation *invocation,
- GVariant *parameters,
- void *user_data)
+gboolean handle_restriction_unset(StcRestriction *object,
+ GDBusMethodInvocation *invocation,
+ GVariant *parameters,
+ void *user_data)
{
__STC_LOG_FUNC_ENTER__;
GVariantIter *iter = NULL;
table_restrictions_info rule;
+ stc_error_e ret = STC_ERROR_NONE;
+
+ stc_set_keep_alive(TRUE);
memset(&rule, 0, sizeof(table_restrictions_info));
__initialize_rstn_rule(&rule);
g_variant_iter_free(iter);
}
- rule.rst_state = STC_RESTRICTION_EXCLUDED;
-
- if (__validate_rstn_rule(&rule, RST_EXCLUDE) == FALSE) {
- STC_RESTRICTION_DBUS_REPLY_ERROR(invocation,
+ if (__validate_rstn_rule(&rule) == FALSE) {
+ STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
STC_ERROR_INVALID_PARAMETER);
- __STC_LOG_FUNC_EXIT__;
+ __stc_free_restriction_rule_members(&rule);
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
return TRUE;
}
- table_restrictions_update(&rule);
- /* update restriction rule in runtime structure */
- stc_monitor_rstns_tree_add(&rule);
+ ret = table_restrictions_delete(rule.app_id, rule.iftype, rule.ifname,
+ rule.subscriber_id, rule.roaming);
+ if (ret != STC_ERROR_NONE) {
+ STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
+ STC_ERROR_DB_FAILED);
+ __stc_free_restriction_rule_members(&rule);
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return TRUE;
+ }
+
+ ret = stc_plugin_monitor_remove_rstn(&rule);
+ if (ret == STC_ERROR_UNINITIALIZED) {
+ STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
+ STC_ERROR_UNINITIALIZED);
+ __stc_free_restriction_rule_members(&rule);
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return TRUE;
+ } else if (ret == STC_ERROR_NO_DATA) {
+ table_restrictions_update(&rule);
+ STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
+ STC_ERROR_NO_DATA);
+ __stc_free_restriction_rule_members(&rule);
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return TRUE;
+ }
STC_DBUS_REPLY_ERROR_NONE(invocation);
+ __stc_free_restriction_rule_members(&rule);
__STC_LOG_FUNC_EXIT__;
return TRUE;
}
-gboolean handle_restriction_remove(StcRestriction *object,
+gboolean handle_restriction_set_list(StcRestriction *object,
+ GDBusMethodInvocation *invocation,
+ GVariant *parameters,
+ void *user_data)
+{
+ __STC_LOG_FUNC_ENTER__;
+ GVariantIter *iter = NULL;
+ GVariantIter *iter_row = NULL;
+ stc_error_e ret = STC_ERROR_NONE;
+
+ stc_set_keep_alive(TRUE);
+
+ g_variant_get(parameters, "aa{sv}", &iter);
+ while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
+ table_restrictions_info rule;
+
+ memset(&rule, 0, sizeof(table_restrictions_info));
+ __initialize_rstn_rule(&rule);
+
+ stc_manager_gdbus_dict_foreach(iter_row,
+ __stc_extract_restriction_rule, &rule);
+
+ if (__validate_rstn_rule(&rule)) {
+ ret = table_restrictions_update(&rule);
+ if (ret != STC_ERROR_NONE) {
+ STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
+ g_variant_iter_free(iter_row);
+ g_variant_iter_free(iter);
+ __stc_free_restriction_rule_members(&rule);
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return TRUE;
+ }
+
+ ret = stc_plugin_monitor_add_rstn(&rule);
+ if (ret != STC_ERROR_NONE) {
+ STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
+ g_variant_iter_free(iter_row);
+ g_variant_iter_free(iter);
+ __stc_free_restriction_rule_members(&rule);
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return TRUE;
+ }
+ }
+
+ __stc_free_restriction_rule_members(&rule);
+ g_variant_iter_free(iter_row);
+ }
+ g_variant_iter_free(iter);
+
+ STC_DBUS_REPLY_ERROR_NONE(invocation);
+ __STC_LOG_FUNC_EXIT__;
+ return TRUE;
+}
+
+gboolean handle_restriction_unset_list(StcRestriction *object,
GDBusMethodInvocation *invocation,
GVariant *parameters,
void *user_data)
{
__STC_LOG_FUNC_ENTER__;
GVariantIter *iter = NULL;
- table_restrictions_info rule;
-
- memset(&rule, 0, sizeof(table_restrictions_info));
- __initialize_rstn_rule(&rule);
-
- g_variant_get(parameters, "a{sv}", &iter);
- if (iter != NULL) {
- stc_manager_gdbus_dict_foreach(iter,
- __stc_extract_restriction_rule,
- &rule);
- g_variant_iter_free(iter);
- }
-
- if (__validate_rstn_rule(&rule, RST_UNSET) == FALSE) {
- STC_RESTRICTION_DBUS_REPLY_ERROR(invocation,
- STC_ERROR_INVALID_PARAMETER);
- __STC_LOG_FUNC_EXIT__;
- return TRUE;
+ GVariantIter *iter_row = NULL;
+ stc_error_e ret = STC_ERROR_NONE;
+
+ stc_set_keep_alive(TRUE);
+
+ g_variant_get(parameters, "aa{sv}", &iter);
+ while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
+ table_restrictions_info rule;
+
+ memset(&rule, 0, sizeof(table_restrictions_info));
+ __initialize_rstn_rule(&rule);
+
+ stc_manager_gdbus_dict_foreach(iter_row,
+ __stc_extract_restriction_rule, &rule);
+
+ if (__validate_rstn_rule(&rule)) {
+ ret = table_restrictions_delete(rule.app_id, rule.iftype,
+ rule.ifname, rule.subscriber_id, rule.roaming);
+ if (ret != STC_ERROR_NONE) {
+ STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
+ g_variant_iter_free(iter_row);
+ g_variant_iter_free(iter);
+ __stc_free_restriction_rule_members(&rule);
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return TRUE;
+ }
+
+ ret = stc_plugin_monitor_remove_rstn(&rule);
+ if (ret != STC_ERROR_NONE) {
+ STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
+ g_variant_iter_free(iter_row);
+ g_variant_iter_free(iter);
+ __stc_free_restriction_rule_members(&rule);
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return TRUE;
+ }
+ }
+
+ __stc_free_restriction_rule_members(&rule);
+ g_variant_iter_free(iter_row);
}
-
- table_restrictions_delete(rule.app_id, rule.iftype, rule.imsi);
- /* remove restriction rule from runtime structure */
- stc_monitor_rstns_tree_remove(&rule);
+ g_variant_iter_free(iter);
STC_DBUS_REPLY_ERROR_NONE(invocation);
__STC_LOG_FUNC_EXIT__;
GVariant *return_parameters = NULL;
stc_error_e ret;
+ stc_set_keep_alive(TRUE);
+
builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
ret = table_restrictions_per_app(app_id,
__table_restrictions_per_app_cb,
builder);
if (ret < STC_ERROR_NONE) {
- g_variant_builder_unref(builder);
- STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, ret);
- __STC_LOG_FUNC_EXIT__;
- return TRUE;
+ g_variant_builder_unref(builder); //LCOV_EXCL_LINE
+ STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return TRUE; //LCOV_EXCL_LINE
}
return_parameters = g_variant_new("(ia{sv})", STC_ERROR_NONE, builder);
GVariant *return_parameters = NULL;
stc_error_e ret;
+ stc_set_keep_alive(TRUE);
+
builder = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}"));
ret = table_restrictions_foreach(__table_restrictions_foreach_app_cb,
builder);
if (ret < STC_ERROR_NONE) {
- g_variant_builder_unref(builder);
- STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, ret);
- __STC_LOG_FUNC_EXIT__;
- return TRUE;
+ g_variant_builder_unref(builder); //LCOV_EXCL_LINE
+ STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
+ return TRUE; //LCOV_EXCL_LINE
}
return_parameters = g_variant_new("(iaa{sv})", STC_ERROR_NONE, builder);
return TRUE;
}
-gboolean handle_restriction_get_state(StcRestriction *object,
+gboolean handle_restriction_get_type(StcRestriction *object,
GDBusMethodInvocation *invocation,
const gchar *app_id,
int iftype,
{
__STC_LOG_FUNC_ENTER__;
GVariant *return_parameters = NULL;
- stc_restriction_state_e state = STC_RESTRICTION_UNKNOWN;
+ stc_rstn_type_e type = STC_RSTN_TYPE_UNKNOWN;
stc_error_e ret;
- ret = table_restrictions_get_restriction_state(app_id, iftype, &state);
+ stc_set_keep_alive(TRUE);
+
+ ret = table_restrictions_get_restriction_type(app_id, iftype, &type);
if (ret < STC_ERROR_NONE) {
- STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, ret);
- __STC_LOG_FUNC_EXIT__;
+ STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
+ __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
return TRUE;
}
- return_parameters = g_variant_new("(ii)", STC_ERROR_NONE, state);
+ return_parameters = g_variant_new("(ii)", STC_ERROR_NONE, type);
STC_DBUS_REPLY(invocation, return_parameters);
__STC_LOG_FUNC_EXIT__;
return TRUE;
projects / platform / core / connectivity / stc-manager.git / blobdiff