Bug fix: remove unused signal

[platform/core/api/tethering.git] / src / tethering.c

diff --git a/src/tethering.c b/src/tethering.c
index f3780d8..2f577de 100755 (executable)
--- a/src/tethering.c
+++ b/src/tethering.c
@@ -125,8 +125,7 @@ static __tethering_sig_t sigs[] = {
        {0, SIGNAL_NAME_SECURITY_TYPE_CHANGED, __handle_security_type_changed},
        {0, SIGNAL_NAME_SSID_VISIBILITY_CHANGED, __handle_ssid_visibility_changed},
        {0, SIGNAL_NAME_PASSPHRASE_CHANGED, __handle_passphrase_changed},
-       {0, SIGNAL_NAME_DHCP_STATUS, __handle_dhcp},
-       {0, "", NULL} };
+       {0, SIGNAL_NAME_DHCP_STATUS, __handle_dhcp} };
 
 static int retry = 0;
 
@@ -319,7 +318,7 @@ static tethering_error_e __get_error(int agent_error)
                err = TETHERING_ERROR_PERMISSION_DENIED;
                break;
        //LCOV_EXCL_STOP
-       default :
+       default:
                ERR("Not defined error : %d\n", agent_error);
                err = TETHERING_ERROR_OPERATION_FAILED;
                break;
@@ -755,7 +754,7 @@ static void __handle_passphrase_changed(GDBusConnection *connection, const gchar
 static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
                gpointer user_data)
 {
-       DBG("+\n");
+       INFO("+\n");
 
        _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
        GError *g_error = NULL;
@@ -787,18 +786,20 @@ static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
        }
        retry = 0;
 
+       INFO("cfm event : wifi tethering enable info : %d\n", error);
+
        sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
                        NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_ON].name,
                        TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
                        sigs[E_SIGNAL_WIFI_TETHER_ON].cb, (gpointer)th, NULL);
 
        if (!ecb) {
-               DBG("-\n");
+               INFO("-\n");
                return;
        }
        ecb(error, TETHERING_TYPE_WIFI, true, data);
        g_variant_unref(g_var);
-       DBG("-\n");
+       INFO("-\n");
 }
 
 static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
@@ -908,7 +909,7 @@ static void __usb_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
 static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res,
                gpointer user_data)
 {
-       DBG("+\n");
+       INFO("+\n");
 
        _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
        GError *g_error = NULL;
@@ -931,10 +932,10 @@ static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res,
                //LCOV_EXCL_STOP
        }
        g_variant_get(g_var, "(uu)", &event_type, &info);
-       DBG("cfm event : %d info : %d\n", event_type, info);
+       INFO("cfm event : %d info : %d\n", event_type, info);
        g_variant_unref(g_var);
        error = __get_error(info);
-       DBG("cfm event : %d info : %d\n", event_type, error);
+       INFO("cfm event : %d info : %d\n", event_type, error);
        switch (event_type) {
        case MOBILE_AP_DISABLE_WIFI_TETHERING_CFM:
                sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
@@ -1006,7 +1007,7 @@ static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res,
                ERR("Invalid event\n");
                break;
        }
-       DBG("-\n");
+       INFO("-\n");
 }
 
 static void __get_data_usage_cb(GObject *source_object, GAsyncResult *res,
@@ -1227,7 +1228,7 @@ static bool __get_wifi_mode_type(tethering_wifi_mode_type_e type, char **buf)
 
 static int __prepare_wifi_settings(tethering_h tethering, _softap_settings_t *set)
 {
-       DBG("+\n");
+       INFO("+\n");
 
        __tethering_h *th = (__tethering_h *)tethering;
        tethering_error_e ret = TETHERING_ERROR_NONE;
@@ -1296,7 +1297,11 @@ static int __prepare_wifi_settings(tethering_h tethering, _softap_settings_t *se
 
                g_strlcpy(set->key, passphrase, sizeof(set->key));
        }
-       DBG("-\n");
+
+       INFO("ssid: %s security: %d mode: %s channel: %d visibility: %s\n",
+                set->ssid, set->sec_type, set->mode, set->channel,
+                (set->visibility) ? "true" : "false");
+       INFO("-\n");
        return TETHERING_ERROR_NONE;
 }
 
@@ -1309,21 +1314,30 @@ static bool __check_precondition(tethering_type_e type)
        /* data network through cellular */
        vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &cellular_state);
        if (cellular_state == VCONFKEY_NETWORK_CELLULAR_ON) {
-               ERR("Data Network can be connected later");
+               INFO("Data Network can be connected later");
                return TRUE;
        }
 
+#ifdef TIZEN_TV_EXT
+       /* data network through ethernet */
+       vconf_get_int(VCONFKEY_NETWORK_STATUS, &dnet_state);
+       if (dnet_state == VCONFKEY_NETWORK_ETHERNET) {
+               INFO("Data Network is connected");
+               return TRUE;
+       }
+#else
        vconf_get_int(VCONFKEY_DNET_STATE, &dnet_state);
        if (dnet_state > VCONFKEY_DNET_OFF) {
-               ERR("Data Network is connected");
+               INFO("Data Network is connected");
                return TRUE;
        }
+#endif/*TIZEN_TV_EXT*/
 
        /* data network through wifi */
        if (type != TETHERING_TYPE_WIFI) {
                vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state);
                if (wifi_state > VCONFKEY_WIFI_UNCONNECTED) {
-                       ERR("Wi-Fi is connected!");
+                       INFO("Wi-Fi is connected!");
                        return TRUE;
                }
        }
@@ -1352,7 +1366,7 @@ API int tethering_create(tethering_h *tethering)
        CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
-       DBG("+\n");
+       INFO("+\n");
 
        __tethering_h *th = NULL;
        GError *error = NULL;
@@ -1369,6 +1383,7 @@ API int tethering_create(tethering_h *tethering)
        th->channel = 6;
        th->mode_type = TETHERING_WIFI_MODE_TYPE_G;
        th->wifi_max_connected = TETHERING_WIFI_MAX_STA;
+       th->change_mac = false;
 
        if (__generate_initial_passphrase(th->passphrase,
                        sizeof(th->passphrase)) == 0) {
@@ -1418,8 +1433,8 @@ API int tethering_create(tethering_h *tethering)
        __connect_signals((tethering_h)th);
 
        *tethering = (tethering_h)th;
-       DBG("Tethering Handle : 0x%X\n", th);
-       DBG("-\n");
+       INFO("Tethering Handle : 0x%X\n", th);
+       INFO("-\n");
        return TETHERING_ERROR_NONE;
 }
 
@@ -1437,14 +1452,22 @@ API int tethering_create(tethering_h *tethering)
  */
 API int tethering_destroy(tethering_h tethering)
 {
-       DBG("+\n");
+       INFO("+\n");
        CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
 
+       GVariant *result = NULL;
        __tethering_h *th = (__tethering_h *)tethering;
 
-       DBG("Tethering Handle : 0x%X\n", th);
+       INFO("Tethering Handle : 0x%X\n", th);
+
+       if (th->change_mac) {
+               result = g_dbus_proxy_call_sync(th->client_bus_proxy, "reset_mac", NULL,
+                               G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL);
+               g_variant_unref(result);
+       }
+
        __disconnect_signals(tethering);
 
        if (th->ssid)
@@ -1456,7 +1479,7 @@ API int tethering_destroy(tethering_h tethering)
        memset(th, 0x00, sizeof(__tethering_h));
        free(th);
 
-       DBG("-\n");
+       INFO("-\n");
        return TETHERING_ERROR_NONE;
 }
 
@@ -1477,7 +1500,7 @@ API int tethering_destroy(tethering_h tethering)
  */
 API int tethering_enable(tethering_h tethering, tethering_type_e type)
 {
-       DBG("+ type :  %d\n", type);
+       INFO("+ type :  %d\n", type);
        CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
        if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
        else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
@@ -1495,7 +1518,7 @@ API int tethering_enable(tethering_h tethering, tethering_type_e type)
 
        if (__check_precondition(type) == FALSE) {
                //LCOV_EXCL_START
-               DBG("-\n");
+               INFO("-\n");
                return TETHERING_ERROR_OPERATION_FAILED;
                //LCOV_EXCL_STOP
        }
@@ -1525,7 +1548,7 @@ API int tethering_enable(tethering_h tethering, tethering_type_e type)
                                sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
 
                g_dbus_proxy_call(proxy, "enable_wifi_tethering",
-                               g_variant_new("(sssiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type),
+                               g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, TETHERING_ADDRESS_FAMILY_IPV4),
                                G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
                                (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
                break;
@@ -1588,10 +1611,124 @@ API int tethering_enable(tethering_h tethering, tethering_type_e type)
        }
 
        g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
+       INFO("-\n");
+       return TETHERING_ERROR_NONE;
+}
+
+API int tethering_ipv6_enable(tethering_h tethering, tethering_type_e type)
+{
+       DBG("+ type :  %d\n", type);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
+
+       _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+                       "parameter(tethering) is NULL\n");
+
+       __tethering_h *th = (__tethering_h *)tethering;
+       GDBusProxy *proxy = th->client_bus_proxy;
+       GDBusConnection *connection = th->client_bus;
+       int ret = 0;
+
+       g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
+
+       if (__check_precondition(type) == FALSE) {
+               //LCOV_EXCL_START
+               DBG("-\n");
+               return TETHERING_ERROR_OPERATION_FAILED;
+               //LCOV_EXCL_STOP
+       }
+
+       switch (type) {
+       //LCOV_EXCL_START
+       case TETHERING_TYPE_WIFI: {
+               _softap_settings_t set = {"", "", "", 0, false, false, 0, 0};
+
+               ret = __prepare_wifi_settings(tethering, &set);
+               if (ret != TETHERING_ERROR_NONE) {
+                       ERR("softap settings initialization failed\n");
+                       DBG("-\n");
+                       return TETHERING_ERROR_OPERATION_FAILED;
+               }
+               g_dbus_connection_signal_unsubscribe(connection,
+                               sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
+                       g_dbus_proxy_call(proxy, "enable_wifi_tethering",
+                               g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, TETHERING_ADDRESS_FAMILY_IPV6),
+                               G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
+                               (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
+               break;
+        }
+       case TETHERING_TYPE_BT: {
+               g_dbus_connection_signal_unsubscribe(connection,
+                               sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
+
+               /* For TEST */
+               g_dbus_proxy_call(proxy, "enable_bt_tethering", g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
+                               G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
+                               (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
+
+               break;
+       }
+
+       default: {
+               ERR("Unknown type : %d\n", type);
+
+               g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
+
+               DBG("-\n");
+               return TETHERING_ERROR_INVALID_PARAMETER;
+       }
+       }
+
+       g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
        DBG("-\n");
        return TETHERING_ERROR_NONE;
 }
 
+API int tethering_ipv6_disable(tethering_h tethering, tethering_type_e type)
+{
+       DBG("+ type :  %d\n", type);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
+
+       _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+                       "parameter(tethering) is NULL\n");
+
+       __tethering_h *th = (__tethering_h *)tethering;
+       GDBusProxy *proxy = th->client_bus_proxy;
+       GDBusConnection *connection = th->client_bus;
+
+       switch (type) {
+       case TETHERING_TYPE_WIFI:
+               DBG("Disable wifi tethering..");
+               g_dbus_connection_signal_unsubscribe(connection,
+                               sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
+
+               g_dbus_proxy_call(proxy, "disable_wifi_tethering",
+                               g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
+                               G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
+                               (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
+               break;
+       case TETHERING_TYPE_BT:
+               g_dbus_connection_signal_unsubscribe(connection,
+                               sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
+
+               g_dbus_proxy_call(proxy, "disable_bt_tethering",
+                               g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6), G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
+                               (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
+               break;
+
+       default:
+               ERR("Not supported tethering type [%d]\n", type);
+               DBG("-\n");
+               return TETHERING_ERROR_INVALID_PARAMETER;
+       }
+       DBG("-\n");
+       return TETHERING_ERROR_NONE;
+}
 /**
  * @internal
  * @brief Disables the tethering, asynchronously.
@@ -1609,10 +1746,11 @@ API int tethering_enable(tethering_h tethering, tethering_type_e type)
  */
 API int tethering_disable(tethering_h tethering, tethering_type_e type)
 {
-       DBG("+ type :  %d\n", type);
-       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
-       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
+       INFO("+ type :  %d\n", type);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -1680,7 +1818,7 @@ API int tethering_disable(tethering_h tethering, tethering_type_e type)
                DBG("-\n");
                return TETHERING_ERROR_INVALID_PARAMETER;
        }
-       DBG("-\n");
+       INFO("-\n");
        return TETHERING_ERROR_NONE;
 }
 
@@ -1696,6 +1834,7 @@ API int tethering_disable(tethering_h tethering, tethering_type_e type)
  */
 API bool tethering_is_enabled(tethering_h tethering, tethering_type_e type)
 {
+       INFO("+ type :  %d\n", type);
        int is_on = 0;
        int vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_NONE;
 
@@ -1721,6 +1860,7 @@ API bool tethering_is_enabled(tethering_h tethering, tethering_type_e type)
                ERR("Not supported type : %d\n", type);
                break;
        }
+       INFO("- enabled:  %s\n", (is_on & vconf_type) ? "true" : "false");
        return is_on & vconf_type ? true : false;
 }
 
@@ -1746,9 +1886,10 @@ API bool tethering_is_enabled(tethering_h tethering, tethering_type_e type)
  */
 API int tethering_get_mac_address(tethering_h tethering, tethering_type_e type, char **mac_address)
 {
-       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
-       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering_is_enabled(tethering, type) == false,
                        TETHERING_ERROR_NOT_ENABLED,
@@ -1814,9 +1955,10 @@ API int tethering_get_mac_address(tethering_h tethering, tethering_type_e type,
  */
 API int tethering_get_network_interface_name(tethering_h tethering, tethering_type_e type, char **interface_name)
 {
-       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
-       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering_is_enabled(tethering, type) == false,
                        TETHERING_ERROR_NOT_ENABLED,
@@ -1861,10 +2003,10 @@ API int tethering_get_network_interface_name(tethering_h tethering, tethering_ty
  */
 API int tethering_get_ip_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **ip_address)
 {
-
-       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
-       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering_is_enabled(tethering, type) == false,
                        TETHERING_ERROR_NOT_ENABLED,
@@ -1923,10 +2065,10 @@ API int tethering_get_ip_address(tethering_h tethering, tethering_type_e type, t
  */
 API int tethering_get_gateway_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **gateway_address)
 {
-
-       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
-       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering_is_enabled(tethering, type) == false,
                        TETHERING_ERROR_NOT_ENABLED,
@@ -1970,9 +2112,10 @@ API int tethering_get_gateway_address(tethering_h tethering, tethering_type_e ty
  */
 API int tethering_get_subnet_mask(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **subnet_mask)
 {
-       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
-       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering_is_enabled(tethering, type) == false,
                        TETHERING_ERROR_NOT_ENABLED,
@@ -2051,10 +2194,10 @@ API int tethering_get_data_usage(tethering_h tethering, tethering_data_usage_cb
  */
 API int tethering_foreach_connected_clients(tethering_h tethering, tethering_type_e type, tethering_connected_client_cb callback, void *user_data)
 {
-       DBG("+\n");
-       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
-       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2167,9 +2310,11 @@ API int tethering_foreach_connected_clients(tethering_h tethering, tethering_typ
  */
 API int tethering_set_enabled_cb(tethering_h tethering, tethering_type_e type, tethering_enabled_cb callback, void *user_data)
 {
-       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
-       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
+       INFO("+ type: %d\n", type);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2192,6 +2337,7 @@ API int tethering_set_enabled_cb(tethering_h tethering, tethering_type_e type, t
                th->enabled_user_data[ti] = user_data;
        }
 
+       INFO("-\n");
        return TETHERING_ERROR_NONE;
 }
 
@@ -2209,9 +2355,10 @@ API int tethering_set_enabled_cb(tethering_h tethering, tethering_type_e type, t
  */
 API int tethering_unset_enabled_cb(tethering_h tethering, tethering_type_e type)
 {
-       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
-       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2251,9 +2398,11 @@ API int tethering_unset_enabled_cb(tethering_h tethering, tethering_type_e type)
  */
 API int tethering_set_disabled_cb(tethering_h tethering, tethering_type_e type, tethering_disabled_cb callback, void *user_data)
 {
-       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
-       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
+       INFO("+ type: %d\n", type);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2275,7 +2424,7 @@ API int tethering_set_disabled_cb(tethering_h tethering, tethering_type_e type,
                th->disabled_cb[ti] = callback;
                th->disabled_user_data[ti] = user_data;
        }
-
+       INFO("-\n");
        return TETHERING_ERROR_NONE;
 }
 
@@ -2293,9 +2442,10 @@ API int tethering_set_disabled_cb(tethering_h tethering, tethering_type_e type,
  */
 API int tethering_unset_disabled_cb(tethering_h tethering, tethering_type_e type)
 {
-       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
-       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2335,9 +2485,11 @@ API int tethering_unset_disabled_cb(tethering_h tethering, tethering_type_e type
  */
 API int tethering_set_connection_state_changed_cb(tethering_h tethering, tethering_type_e type, tethering_connection_state_changed_cb callback, void *user_data)
 {
-       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
-       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
+       INFO("+ type: %d\n", type);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2359,7 +2511,7 @@ API int tethering_set_connection_state_changed_cb(tethering_h tethering, tetheri
                th->changed_cb[ti] = callback;
                th->changed_user_data[ti] = user_data;
        }
-
+       INFO("-\n");
        return TETHERING_ERROR_NONE;
 }
 
@@ -2377,9 +2529,10 @@ API int tethering_set_connection_state_changed_cb(tethering_h tethering, tetheri
  */
 API int tethering_unset_connection_state_changed_cb(tethering_h tethering, tethering_type_e type)
 {
-       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
-       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
-       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
+       else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+       else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2418,7 +2571,8 @@ API int tethering_unset_connection_state_changed_cb(tethering_h tethering, tethe
  */
 API int tethering_wifi_set_security_type_changed_cb(tethering_h tethering, tethering_wifi_security_type_changed_cb callback, void *user_data)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2448,7 +2602,8 @@ API int tethering_wifi_set_security_type_changed_cb(tethering_h tethering, tethe
  */
 API int tethering_wifi_unset_security_type_changed_cb(tethering_h tethering)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2476,7 +2631,8 @@ API int tethering_wifi_unset_security_type_changed_cb(tethering_h tethering)
  */
 API int tethering_wifi_set_ssid_visibility_changed_cb(tethering_h tethering, tethering_wifi_ssid_visibility_changed_cb callback, void *user_data)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2504,7 +2660,8 @@ API int tethering_wifi_set_ssid_visibility_changed_cb(tethering_h tethering, tet
  */
 API int tethering_wifi_unset_ssid_visibility_changed_cb(tethering_h tethering)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2532,7 +2689,8 @@ API int tethering_wifi_unset_ssid_visibility_changed_cb(tethering_h tethering)
  */
 API int tethering_wifi_set_passphrase_changed_cb(tethering_h tethering, tethering_wifi_passphrase_changed_cb callback, void *user_data)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2560,7 +2718,8 @@ API int tethering_wifi_set_passphrase_changed_cb(tethering_h tethering, tetherin
  */
 API int tethering_wifi_unset_passphrase_changed_cb(tethering_h tethering)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2590,7 +2749,8 @@ API int tethering_wifi_unset_passphrase_changed_cb(tethering_h tethering)
  */
 API int tethering_wifi_set_security_type(tethering_h tethering, tethering_wifi_security_type_e type)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2636,7 +2796,8 @@ API int tethering_wifi_set_security_type(tethering_h tethering, tethering_wifi_s
  */
 API int tethering_wifi_get_security_type(tethering_h tethering, tethering_wifi_security_type_e *type)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(type) is NULL\n");
@@ -2661,7 +2822,8 @@ API int tethering_wifi_get_security_type(tethering_h tethering, tethering_wifi_s
  */
 API int tethering_wifi_set_ssid(tethering_h tethering, const char *ssid)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2706,7 +2868,8 @@ API int tethering_wifi_set_ssid(tethering_h tethering, const char *ssid)
  */
 API int tethering_wifi_get_ssid(tethering_h tethering, char **ssid)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2762,7 +2925,8 @@ API int tethering_wifi_get_ssid(tethering_h tethering, char **ssid)
  */
 API int tethering_wifi_set_ssid_visibility(tethering_h tethering, bool visible)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2798,7 +2962,8 @@ API int tethering_wifi_set_ssid_visibility(tethering_h tethering, bool visible)
  */
 API int tethering_wifi_get_ssid_visibility(tethering_h tethering, bool *visible)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(visible == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(visible) is NULL\n");
@@ -2823,7 +2988,8 @@ API int tethering_wifi_get_ssid_visibility(tethering_h tethering, bool *visible)
  */
 API int tethering_wifi_set_passphrase(tethering_h tethering, const char *passphrase)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2892,7 +3058,8 @@ API int tethering_wifi_set_passphrase(tethering_h tethering, const char *passphr
  */
 API int tethering_wifi_get_passphrase(tethering_h tethering, char **passphrase)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -2933,7 +3100,9 @@ API int tethering_wifi_get_passphrase(tethering_h tethering, char **passphrase)
 
 API int tethering_wifi_set_channel(tethering_h tethering, int channel)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
 
@@ -2945,7 +3114,9 @@ API int tethering_wifi_set_channel(tethering_h tethering, int channel)
 
 API int tethering_wifi_get_channel(tethering_h tethering, int *channel)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
 
@@ -2960,7 +3131,9 @@ API int tethering_wifi_get_channel(tethering_h tethering, int *channel)
 
 API int tethering_wifi_set_mode(tethering_h tethering, tethering_wifi_mode_type_e type)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
 
@@ -2973,7 +3146,9 @@ API int tethering_wifi_set_mode(tethering_h tethering, tethering_wifi_mode_type_
 
 API int tethering_wifi_get_mode(tethering_h tethering, tethering_wifi_mode_type_e *type)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
        _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
@@ -3004,7 +3179,8 @@ API int tethering_wifi_get_mode(tethering_h tethering, tethering_wifi_mode_type_
 API int tethering_wifi_reload_settings(tethering_h tethering, tethering_wifi_settings_reloaded_cb callback, void *user_data)
 
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3042,7 +3218,8 @@ API int tethering_wifi_reload_settings(tethering_h tethering, tethering_wifi_set
 
 API int tethering_wifi_set_mac_filter(tethering_h tethering, bool mac_filter)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3055,7 +3232,8 @@ API int tethering_wifi_set_mac_filter(tethering_h tethering, bool mac_filter)
 
 API int tethering_wifi_get_mac_filter(tethering_h tethering, bool *mac_filter)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(mac_filter) is NULL\n");
@@ -3165,7 +3343,8 @@ static int __remove_mac_from_file(const char *filepath, const char *mac)
 
 API int tethering_wifi_add_allowed_mac_list(tethering_h tethering, const char *mac)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3177,7 +3356,9 @@ API int tethering_wifi_add_allowed_mac_list(tethering_h tethering, const char *m
 
 API int tethering_wifi_remove_allowed_mac_list(tethering_h tethering, const char *mac)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
        _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
@@ -3188,7 +3369,9 @@ API int tethering_wifi_remove_allowed_mac_list(tethering_h tethering, const char
 
 API int tethering_wifi_get_allowed_mac_list(tethering_h tethering, void **allowed_mac_list)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
        _retvm_if(allowed_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
@@ -3200,7 +3383,9 @@ API int tethering_wifi_get_allowed_mac_list(tethering_h tethering, void **allowe
 
 API int tethering_wifi_add_blocked_mac_list(tethering_h tethering, const char *mac)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
        _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
@@ -3211,7 +3396,9 @@ API int tethering_wifi_add_blocked_mac_list(tethering_h tethering, const char *m
 
 API int tethering_wifi_remove_blocked_mac_list(tethering_h tethering, const char *mac)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
        _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
@@ -3222,7 +3409,8 @@ API int tethering_wifi_remove_blocked_mac_list(tethering_h tethering, const char
 
 API int tethering_wifi_get_blocked_mac_list(tethering_h tethering, void **blocked_mac_list)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3235,7 +3423,8 @@ API int tethering_wifi_get_blocked_mac_list(tethering_h tethering, void **blocke
 
 API int tethering_wifi_enable_dhcp(tethering_h tethering, bool enable)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3278,7 +3467,8 @@ API int tethering_wifi_enable_dhcp(tethering_h tethering, bool enable)
 
 API int tethering_wifi_set_dhcp_range(tethering_h tethering, char *rangestart, char *rangestop)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3322,7 +3512,9 @@ API int tethering_wifi_set_dhcp_range(tethering_h tethering, char *rangestart, c
 
 API int tethering_wifi_is_dhcp_enabled(tethering_h tethering, bool *dhcp_enabled)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
        _retvm_if(dhcp_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
@@ -3336,8 +3528,10 @@ API int tethering_wifi_is_dhcp_enabled(tethering_h tethering, bool *dhcp_enabled
 
 API int tethering_wifi_set_txpower(tethering_h tethering, unsigned int txpower)
 {
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+
        GError *error = NULL;
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3360,9 +3554,11 @@ API int tethering_wifi_set_txpower(tethering_h tethering, unsigned int txpower)
 
 API int tethering_wifi_get_txpower(tethering_h tethering, unsigned int *txpower)
 {
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+
        GError *error = NULL;
        GVariant *result = NULL;
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3392,7 +3588,8 @@ API int tethering_wifi_get_txpower(tethering_h tethering, unsigned int *txpower)
 
 API int tethering_wifi_set_mtu(tethering_h tethering, unsigned int mtu)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3429,7 +3626,8 @@ API int tethering_wifi_set_mtu(tethering_h tethering, unsigned int mtu)
 
 API int tethering_wifi_change_mac(tethering_h tethering, char *mac)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3463,12 +3661,15 @@ API int tethering_wifi_change_mac(tethering_h tethering, char *mac)
 
        g_variant_unref(parameters);
 
+       th->change_mac = true;
+
        return TETHERING_ERROR_NONE;
 }
 
 API int tethering_wifi_set_max_connected_device(tethering_h tethering, int max_device)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3482,7 +3683,8 @@ API int tethering_wifi_set_max_connected_device(tethering_h tethering, int max_d
 
 API int tethering_wifi_get_max_connected_device(tethering_h tethering, int *max_device)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3497,7 +3699,8 @@ API int tethering_wifi_get_max_connected_device(tethering_h tethering, int *max_
 
 API int tethering_wifi_enable_port_forwarding(tethering_h tethering, bool enable)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3535,7 +3738,8 @@ API int tethering_wifi_enable_port_forwarding(tethering_h tethering, bool enable
 
 API int tethering_wifi_add_port_forwarding_rule(tethering_h tethering, char *ifname, char *protocol, char *org_ip, int org_port, char *final_ip, int final_port)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3585,7 +3789,8 @@ API int tethering_wifi_add_port_forwarding_rule(tethering_h tethering, char *ifn
 
 API int tethering_wifi_reset_port_forwarding_rule(tethering_h tethering)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3621,7 +3826,8 @@ API int tethering_wifi_reset_port_forwarding_rule(tethering_h tethering)
 
 API int tethering_wifi_is_port_forwarding_enabled(tethering_h tethering, bool* forwarding_enabled)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3637,7 +3843,8 @@ API int tethering_wifi_is_port_forwarding_enabled(tethering_h tethering, bool* f
 
 API int tethering_wifi_get_port_forwarding_rule(tethering_h tethering, void **port_forwarding_list)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3650,7 +3857,8 @@ API int tethering_wifi_get_port_forwarding_rule(tethering_h tethering, void **po
 
 API int tethering_wifi_enable_port_filtering(tethering_h tethering, bool enable)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3688,7 +3896,8 @@ API int tethering_wifi_enable_port_filtering(tethering_h tethering, bool enable)
 
 API int tethering_wifi_add_port_filtering_rule(tethering_h tethering, int port, char *protocol, bool allow)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3743,7 +3952,8 @@ API int tethering_wifi_add_port_filtering_rule(tethering_h tethering, int port,
 
 API int tethering_wifi_add_custom_port_filtering_rule(tethering_h tethering, int port1, int port2, char *protocol, bool allow)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3798,7 +4008,8 @@ API int tethering_wifi_add_custom_port_filtering_rule(tethering_h tethering, int
 
 API int tethering_wifi_get_port_filtering_rule(tethering_h tethering, void **port_filtering_list)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3811,7 +4022,8 @@ API int tethering_wifi_get_port_filtering_rule(tethering_h tethering, void **por
 
 API int tethering_wifi_get_custom_port_filtering_rule(tethering_h tethering, void **custom_port_filtering_list)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3824,7 +4036,8 @@ API int tethering_wifi_get_custom_port_filtering_rule(tethering_h tethering, voi
 
 API int tethering_wifi_is_port_filtering_enabled(tethering_h tethering, bool* filtering_enabled)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3840,7 +4053,8 @@ API int tethering_wifi_is_port_filtering_enabled(tethering_h tethering, bool* fi
 
 API int tethering_wifi_set_vpn_passthrough_rule(tethering_h tethering, tethering_vpn_passthrough_type_e type, bool enable)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL\n");
@@ -3877,7 +4091,8 @@ API int tethering_wifi_set_vpn_passthrough_rule(tethering_h tethering, tethering
 
 API int tethering_wifi_push_wps_button(tethering_h tethering)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL");
@@ -3912,7 +4127,8 @@ API int tethering_wifi_push_wps_button(tethering_h tethering)
 
 API int tethering_wifi_set_wps_pin(tethering_h tethering, const char *wps_pin)
 {
-       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+       CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
 
        _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
                        "parameter(tethering) is NULL");