2 * Copyright (c) 2016 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 #include "table-restrictions.h"
19 #include "stc-restriction.h"
20 #include "stc-manager-gdbus.h"
21 #include "stc-monitor.h"
23 #define RESTRICTION_DBUS_ERROR_NAME "net.stc.restriction.Error.Failed"
25 #define STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, err_num) \
26 g_dbus_method_invocation_return_dbus_error((invocation), \
27 RESTRICTION_DBUS_ERROR_NAME, \
28 stc_err_strs[-(err_num)])
30 static const gchar *stc_err_strs[] = {
43 void __initialize_rstn_rule(table_restrictions_info *rule)
47 rule->iftype = STC_IFACE_ALL;
48 rule->rstn_type = STC_RSTN_TYPE_UNKNOWN;
50 rule->data_warn_limit = 0;
51 rule->roaming = STC_ROAMING_DISABLE;
52 rule->subscriber_id = NULL;
55 gboolean __validate_rstn_rule(table_restrictions_info *rule)
57 __STC_LOG_FUNC_ENTER__;
60 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
61 return FALSE; //LCOV_EXCL_LINE
64 if (rule->iftype <= STC_IFACE_UNKNOWN ||
65 rule->iftype >= STC_IFACE_LAST_ELEM) {
66 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
67 return FALSE; //LCOV_EXCL_LINE
70 if (rule->roaming >= STC_ROAMING_LAST_ELEM) {
71 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
72 return FALSE; //LCOV_EXCL_LINE
75 if (rule->subscriber_id == NULL) {
76 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
77 return FALSE; //LCOV_EXCL_LINE
80 if (rule->app_id == NULL) {
81 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
82 return FALSE; //LCOV_EXCL_LINE
85 __STC_LOG_FUNC_EXIT__;
89 void __stc_restriction_app_info_builder_add(GVariantBuilder *builder,
90 const table_restrictions_info *info)
92 __STC_LOG_FUNC_ENTER__;
94 if (!builder || !info) {
95 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
96 return; //LCOV_EXCL_LINE
99 g_variant_builder_add(builder, "{sv}", "app_id",
100 g_variant_new_string(info->app_id));
102 g_variant_builder_add(builder, "{sv}", "ifname",
103 g_variant_new_string(info->ifname));
105 g_variant_builder_add(builder, "{sv}", "iftype",
106 g_variant_new_uint16(info->iftype));
108 g_variant_builder_add(builder, "{sv}", "rstn_type",
109 g_variant_new_uint16(info->rstn_type));
111 g_variant_builder_add(builder, "{sv}", "data_limit",
112 g_variant_new_int64(info->data_limit));
114 g_variant_builder_add(builder, "{sv}", "data_warn_limit",
115 g_variant_new_int64(info->data_warn_limit));
117 g_variant_builder_add(builder, "{sv}", "roaming",
118 g_variant_new_uint16(info->roaming));
120 g_variant_builder_add(builder, "{sv}", "subscriber_id",
121 g_variant_new_string(info->subscriber_id));
123 __STC_LOG_FUNC_EXIT__;
126 stc_cb_ret_e __table_restrictions_foreach_app_cb(const table_restrictions_info *info,
129 __STC_LOG_FUNC_ENTER__;
130 GVariantBuilder *builder = (GVariantBuilder *)user_data;
131 GVariantBuilder sub_builder;
133 if (!info || !builder) {
134 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
135 return STC_CANCEL; //LCOV_EXCL_LINE
138 g_variant_builder_init(&sub_builder, G_VARIANT_TYPE("a{sv}"));
139 __stc_restriction_app_info_builder_add(&sub_builder, info);
141 g_variant_builder_add_value(builder,
142 g_variant_builder_end(&sub_builder));
144 __STC_LOG_FUNC_EXIT__;
148 stc_cb_ret_e __table_restrictions_per_app_cb(const table_restrictions_info *info,
151 __STC_LOG_FUNC_ENTER__;
152 GVariantBuilder *builder = (GVariantBuilder *)user_data;
154 if (!info || !builder) {
155 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
156 return STC_CANCEL; //LCOV_EXCL_LINE
159 __stc_restriction_app_info_builder_add(builder, info);
161 __STC_LOG_FUNC_EXIT__;
165 static void __stc_extract_restriction_rule(const char *key, GVariant *value,
168 __STC_LOG_FUNC_ENTER__;
170 table_restrictions_info *rule =
171 (table_restrictions_info *) user_data;
173 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
174 return; //LCOV_EXCL_LINE
177 if (!g_strcmp0(key, "app_id")) {
179 const gchar *str = g_variant_get_string(value, &str_length);
180 rule->app_id = g_strdup(str);
181 STC_LOGD("app_id: [%s]", rule->app_id);
183 } else if (!g_strcmp0(key, "ifname")) {
185 const gchar *str = g_variant_get_string(value, &str_length);
186 rule->ifname = g_strdup(str);
187 STC_LOGD("ifname: [%s]", rule->ifname);
189 } else if (!g_strcmp0(key, "iftype")) {
190 rule->iftype = g_variant_get_uint16(value);
191 STC_LOGD("iftype: [%u]", (unsigned int) rule->iftype);
193 } else if (!g_strcmp0(key, "data_limit")) {
194 rule->data_limit = g_variant_get_int64(value);
195 STC_LOGD("data_limit: [%lld]", rule->data_limit);
197 } else if (!g_strcmp0(key, "data_warn_limit")) {
198 rule->data_warn_limit = g_variant_get_int64(value);
199 STC_LOGD("data_warn_limit: [%lld]", rule->data_warn_limit);
201 } else if (!g_strcmp0(key, "roaming")) {
202 rule->roaming = g_variant_get_uint16(value);
203 STC_LOGD("roaming: [%u]", rule->roaming);
205 } else if (!g_strcmp0(key, "subscriber_id")) {
207 const gchar *str = g_variant_get_string(value, &str_length);
208 rule->subscriber_id = g_strdup(str);
209 STC_LOGD("subscriber_id: [%s]", rule->subscriber_id);
211 } else if (!g_strcmp0(key, "type")) {
212 rule->rstn_type = g_variant_get_uint16(value);
213 STC_LOGD("type: [%u]", (unsigned int) rule->rstn_type);
216 STC_LOGD("Unknown select rule"); //LCOV_EXCL_LINE
219 __STC_LOG_FUNC_EXIT__;
222 gboolean handle_restriction_set(StcRestriction *object,
223 GDBusMethodInvocation *invocation,
224 GVariant *parameters,
227 __STC_LOG_FUNC_ENTER__;
228 GVariantIter *iter = NULL;
229 table_restrictions_info rule;
231 memset(&rule, 0, sizeof(table_restrictions_info));
232 __initialize_rstn_rule(&rule);
234 g_variant_get(parameters, "a{sv}", &iter);
236 stc_manager_gdbus_dict_foreach(iter,
237 __stc_extract_restriction_rule,
239 g_variant_iter_free(iter);
242 if (__validate_rstn_rule(&rule) == FALSE) {
243 STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
244 STC_ERROR_INVALID_PARAMETER);
245 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
249 table_restrictions_update(&rule);
250 /* update restriction rule in runtime structure */
251 stc_monitor_rstns_tree_add(&rule);
253 STC_DBUS_REPLY_ERROR_NONE(invocation);
254 __STC_LOG_FUNC_EXIT__;
258 gboolean handle_restriction_unset(StcRestriction *object,
259 GDBusMethodInvocation *invocation,
260 GVariant *parameters,
263 __STC_LOG_FUNC_ENTER__;
264 GVariantIter *iter = NULL;
265 table_restrictions_info rule;
267 memset(&rule, 0, sizeof(table_restrictions_info));
268 __initialize_rstn_rule(&rule);
270 g_variant_get(parameters, "a{sv}", &iter);
272 stc_manager_gdbus_dict_foreach(iter,
273 __stc_extract_restriction_rule,
275 g_variant_iter_free(iter);
278 if (__validate_rstn_rule(&rule) == FALSE) {
279 STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, //LCOV_EXCL_LINE
280 STC_ERROR_INVALID_PARAMETER);
281 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
285 table_restrictions_delete(rule.app_id, rule.iftype, rule.subscriber_id);
286 /* remove restriction rule from runtime structure */
287 stc_monitor_rstns_tree_remove(&rule);
289 STC_DBUS_REPLY_ERROR_NONE(invocation);
290 __STC_LOG_FUNC_EXIT__;
294 gboolean handle_restriction_get(StcRestriction *object,
295 GDBusMethodInvocation *invocation,
299 __STC_LOG_FUNC_ENTER__;
300 GVariantBuilder *builder = NULL;
301 GVariant *return_parameters = NULL;
304 builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
306 ret = table_restrictions_per_app(app_id,
307 __table_restrictions_per_app_cb,
309 if (ret < STC_ERROR_NONE) {
310 g_variant_builder_unref(builder); //LCOV_EXCL_LINE
311 STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
312 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
313 return TRUE; //LCOV_EXCL_LINE
316 return_parameters = g_variant_new("(ia{sv})", STC_ERROR_NONE, builder);
317 g_variant_builder_unref(builder);
319 DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
320 STC_DBUS_REPLY(invocation, return_parameters);
321 __STC_LOG_FUNC_EXIT__;
325 gboolean handle_restriction_get_all(StcRestriction *object,
326 GDBusMethodInvocation *invocation,
329 __STC_LOG_FUNC_ENTER__;
330 GVariantBuilder *builder = NULL;
331 GVariant *return_parameters = NULL;
334 builder = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}"));
336 ret = table_restrictions_foreach(__table_restrictions_foreach_app_cb,
338 if (ret < STC_ERROR_NONE) {
339 g_variant_builder_unref(builder); //LCOV_EXCL_LINE
340 STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
341 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
342 return TRUE; //LCOV_EXCL_LINE
345 return_parameters = g_variant_new("(iaa{sv})", STC_ERROR_NONE, builder);
346 g_variant_builder_unref(builder);
348 DEBUG_GDBUS_VARIANT("Return parameters: ", return_parameters);
349 STC_DBUS_REPLY(invocation, return_parameters);
350 __STC_LOG_FUNC_EXIT__;
354 gboolean handle_restriction_get_type(StcRestriction *object,
355 GDBusMethodInvocation *invocation,
360 __STC_LOG_FUNC_ENTER__;
361 GVariant *return_parameters = NULL;
362 stc_rstn_type_e type = STC_RSTN_TYPE_UNKNOWN;
365 ret = table_restrictions_get_restriction_type(app_id, iftype, &type);
366 if (ret < STC_ERROR_NONE) {
367 STC_RESTRICTION_DBUS_REPLY_ERROR(invocation, ret); //LCOV_EXCL_LINE
368 __STC_LOG_FUNC_EXIT__; //LCOV_EXCL_LINE
372 return_parameters = g_variant_new("(ii)", STC_ERROR_NONE, type);
373 STC_DBUS_REPLY(invocation, return_parameters);
374 __STC_LOG_FUNC_EXIT__;