Merge "[Add] tethering client monitoring" into tizen

diff --git a/packaging/stc-manager.spec b/packaging/stc-manager.spec
index 81d341a..b57a246 100644 (file)
--- a/packaging/stc-manager.spec
+++ b/packaging/stc-manager.spec
@@ -69,9 +69,8 @@ chmod 644 %{SOURCE0}
 
 %build
 
-export CFLAGS="$CFLAGS -DTIZEN_DEBUG_ENABLE -D_GNU_SOURCE"
-export CXXFLAGS="$CXXFLAGS -DTIZEN_DEBUG_ENABLE -D_GNU_SOURCE"
-export FFLAGS="$FFLAGS -DTIZEN_DEBUG_ENABLE"
+export CFLAGS="$CFLAGS -D_GNU_SOURCE"
+export CXXFLAGS="$CXXFLAGS -D_GNU_SOURCE"
 
 %cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} \
        -DBIN_DIR=%{_bindir} \

diff --git a/src/database/tables/table-firewall.c b/src/database/tables/table-firewall.c
old mode 100644 (file)
new mode 100755 (executable)
index 3eac6cf..3df1f52
--- a/src/database/tables/table-firewall.c
+++ b/src/database/tables/table-firewall.c
@@ -368,7 +368,9 @@ stc_error_e table_firewall_get_lock(char *name, int *state)
 
        switch (rc) {
        case SQLITE_DONE:
-               break;
+               STC_LOGD("There is no lock state [%s]", name);
+               error_code = STC_ERROR_NO_DATA;
+               goto handle_error;
        case SQLITE_ROW:
                *state = sqlite3_column_int(stmt, 0);
                break;

diff --git a/src/helper/helper-firewall.c b/src/helper/helper-firewall.c
index 14dff41..644ab75 100755 (executable)
--- a/src/helper/helper-firewall.c
+++ b/src/helper/helper-firewall.c
@@ -31,8 +31,10 @@
 #define STC_FIREWALL6_DBUS_METHOD_FLUSH_CHAIN        "Ip6tFlushChain"
 
 #define STC_FIREWALL_DBUS_METHOD_ADD_RULE            "IptAddRule"
+#define STC_FIREWALL_DBUS_METHOD_INSERT_RULE         "IptInsertRule"
 #define STC_FIREWALL_DBUS_METHOD_REMOVE_RULE         "IptRemoveRule"
 #define STC_FIREWALL6_DBUS_METHOD_ADD_RULE           "Ip6tAddRule"
+#define STC_FIREWALL6_DBUS_METHOD_INSERT_RULE        "Ip6tInsertRule"
 #define STC_FIREWALL6_DBUS_METHOD_REMOVE_RULE        "Ip6tRemoveRule"
 
 #define BUF_SIZE_FOR_IP 64
@@ -46,33 +48,21 @@ static void __fw_add_rule_info_to_builder(GVariantBuilder *builder,
        g_variant_builder_add(builder, "{sv}", RULE_CHAIN,
                        g_variant_new_string(rule->chain));
 
-       if (rule->direction != STC_FW_DIRECTION_NONE)
+       if (rule->direction != STC_FW_DIRECTION_NONE) {
                g_variant_builder_add(builder, "{sv}", RULE_DIRECTION,
                                g_variant_new_uint16(rule->direction));
 
-       if (rule->s_ip_type != STC_FW_IP_NONE)
-               g_variant_builder_add(builder, "{sv}", RULE_SIPTYPE,
-                               g_variant_new_uint16(rule->s_ip_type));
-
-       if (rule->d_ip_type != STC_FW_IP_NONE)
-               g_variant_builder_add(builder, "{sv}", RULE_DIPTYPE,
-                               g_variant_new_uint16(rule->d_ip_type));
-
-       if (rule->s_port_type != STC_FW_PORT_NONE)
-               g_variant_builder_add(builder, "{sv}", RULE_SPORTTYPE,
-                               g_variant_new_uint16(rule->s_port_type));
-
-       if (rule->d_port_type != STC_FW_PORT_NONE)
-               g_variant_builder_add(builder, "{sv}", RULE_DPORTTYPE,
-                               g_variant_new_uint16(rule->d_port_type));
-
-       if (rule->protocol != STC_FW_PROTOCOL_NONE)
-               g_variant_builder_add(builder, "{sv}", RULE_PROTOCOL,
-                               g_variant_new_uint16(rule->protocol));
+               if (rule->ifname && rule->ifname[0] != '\0')
+                       g_variant_builder_add(builder, "{sv}", RULE_IFNAME,
+                                       g_variant_new_string(rule->ifname));
+       }
 
        switch (rule->family) {
        case STC_FW_FAMILY_V4:
                if (rule->s_ip_type != STC_FW_IP_NONE) {
+                       g_variant_builder_add(builder, "{sv}", RULE_SIPTYPE,
+                               g_variant_new_uint16(rule->s_ip_type));
+
                        if (rule->s_ip1.Ipv4.s_addr)
                                g_variant_builder_add(builder, "{sv}", RULE_SIP1,
                                                g_variant_new_uint32(rule->s_ip1.Ipv4.s_addr));
@@ -83,6 +73,9 @@ static void __fw_add_rule_info_to_builder(GVariantBuilder *builder,
                }
 
                if (rule->d_ip_type != STC_FW_IP_NONE) {
+                       g_variant_builder_add(builder, "{sv}", RULE_DIPTYPE,
+                               g_variant_new_uint16(rule->d_ip_type));
+
                        if (rule->d_ip1.Ipv4.s_addr)
                                g_variant_builder_add(builder, "{sv}", RULE_DIP1,
                                                g_variant_new_uint32(rule->d_ip1.Ipv4.s_addr));
@@ -98,6 +91,9 @@ static void __fw_add_rule_info_to_builder(GVariantBuilder *builder,
                        char buf[BUF_SIZE_FOR_IP];
 
                        if (rule->s_ip_type != STC_FW_IP_NONE) {
+                               g_variant_builder_add(builder, "{sv}", RULE_SIPTYPE,
+                                       g_variant_new_uint16(rule->s_ip_type));
+
                                if (rule->s_ip1.Ipv6.s6_addr32[0] || rule->s_ip1.Ipv6.s6_addr32[1] ||
                                        rule->s_ip1.Ipv6.s6_addr32[2] || rule->s_ip1.Ipv6.s6_addr32[3]) {
                                        memset(buf, 0, sizeof(buf));
@@ -120,6 +116,9 @@ static void __fw_add_rule_info_to_builder(GVariantBuilder *builder,
                        }
 
                        if (rule->d_ip_type != STC_FW_IP_NONE) {
+                               g_variant_builder_add(builder, "{sv}", RULE_DIPTYPE,
+                                       g_variant_new_uint16(rule->d_ip_type));
+
                                if (rule->d_ip1.Ipv6.s6_addr32[0] || rule->d_ip1.Ipv6.s6_addr32[1] ||
                                        rule->d_ip1.Ipv6.s6_addr32[2] || rule->d_ip1.Ipv6.s6_addr32[3]) {
                                        memset(buf, 0, sizeof(buf));
@@ -147,30 +146,35 @@ static void __fw_add_rule_info_to_builder(GVariantBuilder *builder,
                break;
        }
 
-       if (rule->s_port_type != STC_FW_PORT_NONE) {
-               if (rule->s_port1)
-                       g_variant_builder_add(builder, "{sv}", RULE_SPORT1,
-                                       g_variant_new_uint32(rule->s_port1));
+       if (rule->protocol != STC_FW_PROTOCOL_NONE) {
+               g_variant_builder_add(builder, "{sv}", RULE_PROTOCOL,
+                               g_variant_new_uint16(rule->protocol));
 
-               if (rule->s_port2)
-                       g_variant_builder_add(builder, "{sv}", RULE_SPORT2,
-                                       g_variant_new_uint32(rule->s_port2));
-       }
+               if (rule->s_port_type != STC_FW_PORT_NONE) {
+                       g_variant_builder_add(builder, "{sv}", RULE_SPORTTYPE,
+                                       g_variant_new_uint16(rule->s_port_type));
 
-       if (rule->s_port_type != STC_FW_PORT_NONE) {
-               if (rule->d_port1)
-                       g_variant_builder_add(builder, "{sv}", RULE_DPORT1,
-                                       g_variant_new_uint32(rule->d_port1));
+                       if (rule->s_port1)
+                               g_variant_builder_add(builder, "{sv}", RULE_SPORT1,
+                                               g_variant_new_uint32(rule->s_port1));
 
-               if (rule->d_port2)
-                       g_variant_builder_add(builder, "{sv}", RULE_DPORT2,
-                                       g_variant_new_uint32(rule->d_port2));
-       }
+                       if (rule->s_port2)
+                               g_variant_builder_add(builder, "{sv}", RULE_SPORT2,
+                                               g_variant_new_uint32(rule->s_port2));
+               }
 
-       if (rule->direction != STC_FW_DIRECTION_NONE) {
-               if (rule->ifname && rule->ifname[0] != '\0')
-                       g_variant_builder_add(builder, "{sv}", RULE_IFNAME,
-                                       g_variant_new_string(rule->ifname));
+               if (rule->d_port_type != STC_FW_PORT_NONE) {
+                       g_variant_builder_add(builder, "{sv}", RULE_DPORTTYPE,
+                                       g_variant_new_uint16(rule->d_port_type));
+
+                       if (rule->d_port1)
+                               g_variant_builder_add(builder, "{sv}", RULE_DPORT1,
+                                               g_variant_new_uint32(rule->d_port1));
+
+                       if (rule->d_port2)
+                               g_variant_builder_add(builder, "{sv}", RULE_DPORT2,
+                                               g_variant_new_uint32(rule->d_port2));
+               }
        }
 
        if (rule->target_str && rule->target_str[0] != '\0')
@@ -377,7 +381,7 @@ static int __fw_set_chain(firewall_chain_s *chain)
        }
 
        rule.target_str = g_strdup(chain->chain);
-       ret = firewall_rule_add(&rule);
+       ret = firewall_rule_insert(&rule);
 
        g_free(rule.chain);
        g_free(rule.target_str);
@@ -411,7 +415,7 @@ static int __fw_unset_chain(firewall_chain_s *chain)
        return ret;
 }
 
-static int __fw_add_rule(GDBusConnection *connection,
+static int __fw_append_rule(GDBusConnection *connection,
                               firewall_rule_s *rule)
 {
        int result = 0;
@@ -444,7 +448,40 @@ static int __fw_add_rule(GDBusConnection *connection,
        return STC_ERROR_NONE;
 }
 
-static int __fw6_add_rule(GDBusConnection *connection,
+static int __fw_insert_rule(GDBusConnection *connection,
+                              firewall_rule_s *rule)
+{
+       int result = 0;
+       GVariantBuilder *builder = NULL;
+       GVariant *params = NULL;
+       GVariant *message = NULL;
+
+       builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+       __fw_add_rule_info_to_builder(builder, rule);
+       params = g_variant_new("(a{sv})", builder);
+       g_variant_builder_unref(builder);
+
+       message = stc_manager_gdbus_call_sync(connection,
+                                             STC_FIREWALL_DBUS_SERVICE,
+                                             STC_FIREWALL_DBUS_RULE_PATH,
+                                             STC_FIREWALL_DBUS_RULE_INTERFACE,
+                                             STC_FIREWALL_DBUS_METHOD_INSERT_RULE,
+                                             params);
+
+       if (message == NULL) {
+               STC_LOGE("Failed to invoke dbus method");
+               return STC_ERROR_FAIL;
+       }
+
+       g_variant_get(message, "(i)", &result);
+       STC_LOGD("Successfully inserted firewall rule [%d:%s]",
+                               result, rule->chain);
+       g_variant_unref(message);
+
+       return STC_ERROR_NONE;
+}
+
+static int __fw6_append_rule(GDBusConnection *connection,
                                firewall_rule_s *rule)
 {
        int result = 0;
@@ -477,6 +514,39 @@ static int __fw6_add_rule(GDBusConnection *connection,
        return STC_ERROR_NONE;
 }
 
+static int __fw6_insert_rule(GDBusConnection *connection,
+                               firewall_rule_s *rule)
+{
+       int result = 0;
+       GVariantBuilder *builder = NULL;
+       GVariant *params = NULL;
+       GVariant *message = NULL;
+
+       builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+       __fw_add_rule_info_to_builder(builder, rule);
+       params = g_variant_new("(a{sv})", builder);
+       g_variant_builder_unref(builder);
+
+       message = stc_manager_gdbus_call_sync(connection,
+                                             STC_FIREWALL_DBUS_SERVICE,
+                                             STC_FIREWALL_DBUS_RULE_PATH,
+                                             STC_FIREWALL_DBUS_RULE_INTERFACE,
+                                             STC_FIREWALL6_DBUS_METHOD_INSERT_RULE,
+                                             params);
+
+       if (message == NULL) {
+               STC_LOGE("Failed to invoke dbus method");
+               return STC_ERROR_FAIL;
+       }
+
+       g_variant_get(message, "(i)", &result);
+       STC_LOGD("Successfully inserted firewall6 rule [%d:%s]",
+                               result, rule->chain);
+       g_variant_unref(message);
+
+       return STC_ERROR_NONE;
+}
+
 static int __fw_remove_rule(GDBusConnection *connection,
                                  firewall_rule_s *rule)
 {
@@ -649,7 +719,50 @@ stc_error_e firewall_chain_unset(firewall_chain_s *chain)
        return ret;
 }
 
-stc_error_e firewall_rule_add(firewall_rule_s *rule)
+stc_error_e firewall_rule_append(firewall_rule_s *rule)
+{
+       stc_error_e ret = STC_ERROR_NONE;
+       stc_s *stc = stc_get_manager();
+
+       if (!stc || !stc->connection) {
+               __STC_LOG_FUNC_EXIT__;
+               return STC_ERROR_UNINITIALIZED;
+       }
+
+       switch (rule->family) {
+       case STC_FW_FAMILY_V4:
+               ret = __fw_append_rule(stc->connection, rule);
+               if (ret != STC_ERROR_NONE) {
+                       __STC_LOG_FUNC_EXIT__;
+                       return ret;
+               }
+               break;
+       case STC_FW_FAMILY_V6:
+               ret = __fw6_append_rule(stc->connection, rule);
+               if (ret != STC_ERROR_NONE) {
+                       __STC_LOG_FUNC_EXIT__;
+                       return ret;
+               }
+               break;
+       default:
+               ret = __fw_append_rule(stc->connection, rule);
+               if (ret != STC_ERROR_NONE) {
+                       __STC_LOG_FUNC_EXIT__;
+                       return ret;
+               }
+
+               ret = __fw6_append_rule(stc->connection, rule);
+               if (ret != STC_ERROR_NONE) {
+                       __STC_LOG_FUNC_EXIT__;
+                       return ret;
+               }
+               break;
+       }
+
+       return ret;
+}
+
+stc_error_e firewall_rule_insert(firewall_rule_s *rule)
 {
        stc_error_e ret = STC_ERROR_NONE;
        stc_s *stc = stc_get_manager();
@@ -661,27 +774,27 @@ stc_error_e firewall_rule_add(firewall_rule_s *rule)
 
        switch (rule->family) {
        case STC_FW_FAMILY_V4:
-               ret = __fw_add_rule(stc->connection, rule);
+               ret = __fw_insert_rule(stc->connection, rule);
                if (ret != STC_ERROR_NONE) {
                        __STC_LOG_FUNC_EXIT__;
                        return ret;
                }
                break;
        case STC_FW_FAMILY_V6:
-               ret = __fw6_add_rule(stc->connection, rule);
+               ret = __fw6_insert_rule(stc->connection, rule);
                if (ret != STC_ERROR_NONE) {
                        __STC_LOG_FUNC_EXIT__;
                        return ret;
                }
                break;
        default:
-               ret = __fw_add_rule(stc->connection, rule);
+               ret = __fw_insert_rule(stc->connection, rule);
                if (ret != STC_ERROR_NONE) {
                        __STC_LOG_FUNC_EXIT__;
                        return ret;
                }
 
-               ret = __fw6_add_rule(stc->connection, rule);
+               ret = __fw6_insert_rule(stc->connection, rule);
                if (ret != STC_ERROR_NONE) {
                        __STC_LOG_FUNC_EXIT__;
                        return ret;

diff --git a/src/helper/helper-firewall.h b/src/helper/helper-firewall.h
index 2c779bb..4966769 100755 (executable)
--- a/src/helper/helper-firewall.h
+++ b/src/helper/helper-firewall.h
@@ -22,8 +22,8 @@
 #include "stc-manager.h"
 #include "stc-error.h"
 
-#define FIREWALL_CHAIN_TARGET_IN     "STC_IN"
-#define FIREWALL_CHAIN_TARGET_OUT    "STC_OUT"
+#define FIREWALL_CHAIN_TARGET_IN     "INPUT"
+#define FIREWALL_CHAIN_TARGET_OUT    "OUTPUT"
 
 #define FIREWALL_RULE_TARGET_ACCEPT  "ACCEPT"
 #define FIREWALL_RULE_TARGET_DROP    "DROP"
@@ -111,7 +111,8 @@ stc_error_e firewall_chain_flush(firewall_chain_s *chain);
 stc_error_e firewall_chain_set(firewall_chain_s *chain);
 stc_error_e firewall_chain_unset(firewall_chain_s *chain);
 
-stc_error_e firewall_rule_add(firewall_rule_s *rule);
+stc_error_e firewall_rule_append(firewall_rule_s *rule);
+stc_error_e firewall_rule_insert(firewall_rule_s *rule);
 stc_error_e firewall_rule_remove(firewall_rule_s *rule);
 
 #endif /*__STC_HELPER_FIREWALL_H__*/

diff --git a/src/monitor/include/stc-monitor.h b/src/monitor/include/stc-monitor.h
old mode 100644 (file)
new mode 100755 (executable)
index 4b5375c..187035f
--- a/src/monitor/include/stc-monitor.h
+++ b/src/monitor/include/stc-monitor.h
@@ -41,6 +41,11 @@ typedef enum {
        STC_RSTN_LIMIT_TYPE_MAX
 } stc_rstn_limit_type_e;
 
+typedef enum {
+       STC_RSTN_STATE_INIT = -1,
+       STC_RSTN_STATE_UNSET,
+       STC_RSTN_STATE_SET,
+} stc_rstn_noti_state_e;
 
 /**
  * @brief key for processes tree

diff --git a/src/monitor/stc-monitor.c b/src/monitor/stc-monitor.c
old mode 100644 (file)
new mode 100755 (executable)
index fbed5e3..7f28d9c
--- a/src/monitor/stc-monitor.c
+++ b/src/monitor/stc-monitor.c
@@ -34,7 +34,14 @@
 
 #define GRANULARITY 10
 #define MAX_INT_LENGTH 128
+
+#ifndef VCONFKEY_STC_BACKGROUND_STATE
 #define VCONFKEY_STC_BACKGROUND_STATE "db/stc/background_state"
+#endif
+
+#ifndef VCONFKEY_SETAPPL_DATA_RESTRICTION_INT
+#define VCONFKEY_SETAPPL_DATA_RESTRICTION_INT "db/setting/data_restriction"
+#endif
 
 typedef struct {
        time_t now;
@@ -58,6 +65,34 @@ typedef struct {
 
 static stc_system_s *g_system = NULL;
 
+//LCOV_EXCL_START
+static int __vconf_get_int(const char *key, int *value)
+{
+       int ret = 0;
+
+       ret = vconf_get_int(key, value);
+       if (ret != VCONF_OK) {
+               STC_LOGE("Failed to get vconfkey [%s] value", key); //LCOV_EXCL_LINE
+               return -1; //LCOV_EXCL_LINE
+       }
+
+       return 0;
+}
+
+static int __vconf_set_int(const char *key, int value)
+{
+       int ret = 0;
+
+       ret = vconf_set_int(key, value);
+       if (ret != VCONF_OK) {
+               STC_LOGE("Failed to set vconfkey [%s] value", key); //LCOV_EXCL_LINE
+               return -1; //LCOV_EXCL_LINE
+       }
+
+       return 0;
+}
+//LCOV_EXCL_STOP
+
 static nfacct_rule_jump __get_jump_by_intend(struct nfacct_rule *counter)
 {
        if (counter->intend == NFACCT_WARN)
@@ -795,6 +830,22 @@ static void __del_iptables_rule(int64_t classid, nfacct_rule_intend intend,
        __del_ip6tables_out(&counter);
 }
 
+static void __set_rstn_noti_state(int value)
+{
+       int state = STC_RSTN_STATE_INIT;
+
+       if (__vconf_get_int(VCONFKEY_SETAPPL_DATA_RESTRICTION_INT, &state))
+               return;
+
+       if (state == value) {
+               STC_LOGI("No need to change a restriction status: %d", state);
+               return;
+       }
+
+       vconf_set_int(VCONFKEY_SETAPPL_DATA_RESTRICTION_INT, value);
+       return;
+}
+
 typedef struct {
        time_t month_start_ts;
        time_t week_start_ts;
@@ -940,6 +991,8 @@ static void __process_restriction(enum traffic_restriction_type rstn_type,
                for (i = 0; i < STC_RSTN_LIMIT_TYPE_MAX; i++)
                        if (rstn_value->limit[i] >= 0)
                                rstn_value->counter[i] = 0;
+
+               __set_rstn_noti_state(STC_RSTN_STATE_UNSET);
        }
        break;
        default:
@@ -1121,6 +1174,8 @@ static void __action_when_rstn_limit_exceeded(stc_rstn_limit_type_e limit_type,
                context->counter->intend = NFACCT_COUNTER;
 
                rstn_value->limit_exceeded |= (1 << limit_type);
+
+               __set_rstn_noti_state(STC_RSTN_STATE_SET);
        }
        break;
        default:
@@ -2058,33 +2113,6 @@ static void __add_application_by_interface(const char *app_id)
        FREE(app_key.app_id);
 }
 
-static int __vconf_get_int(const char *key, int *value)
-{
-       int ret = 0;
-
-       ret = vconf_get_int(key, value);
-       if (ret != VCONF_OK) {
-               STC_LOGE("Failed to get vconfkey [%s] value", key); //LCOV_EXCL_LINE
-               return -1; //LCOV_EXCL_LINE
-       }
-
-       return 0;
-}
-
-//LCOV_EXCL_START
-static int __vconf_set_int(const char *key, int value)
-{
-       int ret = 0;
-
-       ret = vconf_set_int(key, value);
-       if (ret != VCONF_OK) {
-               STC_LOGE("Failed to set vconfkey [%s] value", key); //LCOV_EXCL_LINE
-               return -1; //LCOV_EXCL_LINE
-       }
-
-       return 0;
-}
-
 static guint __get_background_state(void)
 {
        return g_system->background_state;;

diff --git a/src/stc-firewall.c b/src/stc-firewall.c
old mode 100644 (file)
new mode 100755 (executable)
index bec6c27..ec1f674
--- a/src/stc-firewall.c
+++ b/src/stc-firewall.c
@@ -629,7 +629,7 @@ static void __fw_rule_set_to_chain(gpointer data, gpointer user_data)
                break;
        }
 
-       firewall_rule_add(rule);
+       firewall_rule_append(rule);
 }
 
 static void __fw_rule_print_rules(gpointer data, gpointer user_data)
@@ -1030,7 +1030,7 @@ static void __fw_rule_extract(const char *key, GVariant *value,
                }
 
        } else if (g_strcmp0(key, RULE_DPORT1) == 0) {
-               if (rule->s_port_type != STC_FW_PORT_NONE) {
+               if (rule->d_port_type != STC_FW_PORT_NONE) {
                        rule->d_port1 = g_variant_get_uint32(value);
                        STC_LOGD("%s: [%04x]", RULE_DPORT1, rule->d_port1);
                }