X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftethering.c;h=2f577de3e7be6a22d71f5fa4a35ce63301be2313;hb=977652da47e2a7a3fe42af57ff30d020c2716869;hp=9be81cf6963ea92b33174972636a62acc08097ca;hpb=67e8a557d6f890e310481b890876a1f007db5444;p=platform%2Fcore%2Fapi%2Ftethering.git diff --git a/src/tethering.c b/src/tethering.c index 9be81cf..2f577de 100755 --- a/src/tethering.c +++ b/src/tethering.c @@ -29,14 +29,32 @@ #include #include #include +#include #include "tethering_private.h" -#define ALLOWED_LIST "/etc/hostapd.accept" -#define BLOCKED_LIST "/etc/hostapd.deny" -#define TEMP_LIST "/etc/hostapd_tmp" +#define ALLOWED_LIST tzplatform_mkpath(TZ_SYS_VAR, "/lib/hostapd/hostapd.accept") +#define BLOCKED_LIST tzplatform_mkpath(TZ_SYS_VAR, "/lib/hostapd/hostapd.deny") +#define TEMP_LIST tzplatform_mkpath(TZ_SYS_VAR, "/lib/hostapd/.hostapd_tmp") #define MAC_ADDR_LEN 18 #define MAX_BUF_SIZE 80 +#define IPTABLES "/usr/sbin/iptables" +#define TABLE_NAT "nat" +#define TETH_NAT_PRE "teth_nat_pre" +#define TABLE_FILTER "filter" +#define TETH_FILTER_FW "teth_filter_fw" +#define ACTION_DROP "DROP" +#define ACTION_ACCEPT "ACCEPT" +#define PORT_FORWARD_RULE_STR "-t %s -A %s -i %s -p %s -d %s --dport %d -j DNAT --to %s:%d" +#define FILTERING_MULTIPORT_RULE_STR "-t %s -A %s -p %s -m multiport --dport %d,%d -j %s" +#define FILTERING_RULE_STR "-t %s -A %s -p %s --dport %d -j %s" + +static GSList *allowed_list = NULL; +static GSList *blocked_list = NULL; +static GSList *port_forwarding = NULL; +static GSList *port_filtering = NULL; +static GSList *custom_port_filtering = NULL; + static void __handle_wifi_tether_on(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path, const gchar *interface_name, const gchar *signal_name, GVariant *parameters, gpointer user_data); @@ -61,14 +79,6 @@ static void __handle_bt_tether_off(GDBusConnection *connection, const gchar *sen const gchar *object_path, const gchar *interface_name, const gchar *signal_name, GVariant *parameters, gpointer user_data); -static void __handle_wifi_ap_on(GDBusConnection *connection, const gchar *sender_name, - const gchar *object_path, const gchar *interface_name, const gchar *signal_name, - GVariant *parameters, gpointer user_data); - -static void __handle_wifi_ap_off(GDBusConnection *connection, const gchar *sender_name, - const gchar *object_path, const gchar *interface_name, const gchar *signal_name, - GVariant *parameters, gpointer user_data); - static void __handle_net_closed(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path, const gchar *interface_name, const gchar *signal_name, GVariant *parameters, gpointer user_data); @@ -109,23 +119,20 @@ static __tethering_sig_t sigs[] = { {0, SIGNAL_NAME_USB_TETHER_OFF, __handle_usb_tether_off}, {0, SIGNAL_NAME_BT_TETHER_ON, __handle_bt_tether_on}, {0, SIGNAL_NAME_BT_TETHER_OFF, __handle_bt_tether_off}, - {0, SIGNAL_NAME_WIFI_AP_ON, __handle_wifi_ap_on}, - {0, SIGNAL_NAME_WIFI_AP_OFF, __handle_wifi_ap_off}, {0, SIGNAL_NAME_NO_DATA_TIMEOUT, __handle_no_data_timeout}, {0, SIGNAL_NAME_LOW_BATTERY_MODE, __handle_low_battery_mode}, {0, SIGNAL_NAME_FLIGHT_MODE, __handle_flight_mode}, {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; static void __send_dbus_signal(GDBusConnection *conn, const char *signal_name, const char *arg) { if (conn == NULL || signal_name == NULL) - return; + return; //LCOV_EXCL_LINE GVariant *message = NULL; GError *error = NULL; @@ -136,8 +143,8 @@ static void __send_dbus_signal(GDBusConnection *conn, const char *signal_name, c g_dbus_connection_emit_signal(conn, NULL, TETHERING_SERVICE_OBJECT_PATH, TETHERING_SERVICE_INTERFACE, signal_name, message, &error); if (error) { - ERR("g_dbus_connection_emit_signal is failed because %s\n", error->message); - g_error_free(error); + ERR("g_dbus_connection_emit_signal is failed because %s\n", error->message); //LCOV_EXCL_LINE + g_error_free(error); //LCOV_EXCL_LINE } g_variant_unref(message); } @@ -146,8 +153,7 @@ static bool __any_tethering_is_enabled(tethering_h tethering) { if (tethering_is_enabled(tethering, TETHERING_TYPE_USB) || tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) || - tethering_is_enabled(tethering, TETHERING_TYPE_BT) || - tethering_is_enabled(tethering, TETHERING_TYPE_RESERVED)) + tethering_is_enabled(tethering, TETHERING_TYPE_BT)) return true; return false; @@ -156,7 +162,8 @@ static bool __any_tethering_is_enabled(tethering_h tethering) static tethering_error_e __set_security_type(const tethering_wifi_security_type_e security_type) { if (security_type != TETHERING_WIFI_SECURITY_TYPE_NONE && - security_type != TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK) { + security_type != TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK && + security_type != TETHERING_WIFI_SECURITY_TYPE_WPS) { ERR("Invalid param\n"); return TETHERING_ERROR_INVALID_PARAMETER; } @@ -264,9 +271,11 @@ static tethering_error_e __get_error(int agent_error) err = TETHERING_ERROR_NONE; break; + //LCOV_EXCL_START case MOBILE_AP_ERROR_RESOURCE: err = TETHERING_ERROR_OUT_OF_MEMORY; break; + //LCOV_EXCL_STOP case MOBILE_AP_ERROR_INTERNAL: err = TETHERING_ERROR_OPERATION_FAILED; @@ -300,6 +309,7 @@ static tethering_error_e __get_error(int agent_error) err = TETHERING_ERROR_OPERATION_FAILED; break; + //LCOV_EXCL_START case MOBILE_AP_ERROR_NOT_PERMITTED: err = TETHERING_ERROR_NOT_PERMITTED; break; @@ -307,7 +317,7 @@ static tethering_error_e __get_error(int agent_error) case MOBILE_AP_ERROR_PERMISSION_DENIED: err = TETHERING_ERROR_PERMISSION_DENIED; break; - + //LCOV_EXCL_STOP default: ERR("Not defined error : %d\n", agent_error); err = TETHERING_ERROR_OPERATION_FAILED; @@ -317,6 +327,7 @@ static tethering_error_e __get_error(int agent_error) return err; } +//LCOV_EXCL_START static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path, const gchar *interface_name, const gchar *signal_name, GVariant *parameters, gpointer user_data) @@ -356,9 +367,7 @@ static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name, type = TETHERING_TYPE_WIFI; else if (ap_type == MOBILE_AP_TYPE_BT) type = TETHERING_TYPE_BT; - else if (ap_type == MOBILE_AP_TYPE_WIFI_AP) { - type = TETHERING_TYPE_RESERVED; - } else { + else { ERR("Not supported tethering type [%d]\n", ap_type); goto DONE; } @@ -384,7 +393,9 @@ DONE: g_free(name); DBG("-\n"); } +//LCOV_EXCL_STOP +//LCOV_EXCL_START static void __handle_net_closed(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path, const gchar *interface_name, const gchar *signal_name, GVariant *parameters, gpointer user_data) @@ -410,6 +421,7 @@ static void __handle_net_closed(GDBusConnection *connection, const gchar *sender DBG("-\n"); } +//LCOV_EXCL_STOP static void __handle_wifi_tether_on(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path, const gchar *interface_name, const gchar *signal_name, @@ -465,6 +477,7 @@ static void __handle_wifi_tether_off(GDBusConnection *connection, const gchar *s DBG("-\n"); } +//LCOV_EXCL_START static void __handle_usb_tether_on(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path, const gchar *interface_name, const gchar *signal_name, GVariant *parameters, gpointer user_data) @@ -516,6 +529,7 @@ static void __handle_usb_tether_off(GDBusConnection *connection, const gchar *se g_free(buf); DBG("-\n"); } +//LCOV_EXCL_STOP static void __handle_bt_tether_on(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path, const gchar *interface_name, const gchar *signal_name, @@ -571,60 +585,7 @@ static void __handle_bt_tether_off(GDBusConnection *connection, const gchar *sen DBG("-\n"); } -static void __handle_wifi_ap_on(GDBusConnection *connection, const gchar *sender_name, - const gchar *object_path, const gchar *interface_name, const gchar *signal_name, - GVariant *parameters, gpointer user_data) -{ - DBG("+\n"); - - _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); - - __tethering_h *th = (__tethering_h *)user_data; - tethering_type_e type = TETHERING_TYPE_RESERVED; - bool is_requested = false; - tethering_enabled_cb ecb = NULL; - void *data = NULL; - - ecb = th->enabled_cb[type]; - if (ecb == NULL) - return; - data = th->enabled_user_data[type]; - - ecb(TETHERING_ERROR_NONE, type, is_requested, data); - DBG("-\n"); -} - -static void __handle_wifi_ap_off(GDBusConnection *connection, const gchar *sender_name, - const gchar *object_path, const gchar *interface_name, const gchar *signal_name, - GVariant *parameters, gpointer user_data) -{ - DBG("+\n"); - - _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); - - __tethering_h *th = (__tethering_h *)user_data; - tethering_type_e type = TETHERING_TYPE_RESERVED; - tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS; - tethering_disabled_cb dcb = NULL; - void *data = NULL; - char *buf = NULL; - - dcb = th->disabled_cb[type]; - if (dcb == NULL) - return; - data = th->disabled_user_data[type]; - g_variant_get(parameters, "(s)", &buf); - if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE)) - code = TETHERING_DISABLED_BY_WIFI_ON; - else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT)) - code = TETHERING_DISABLED_BY_TIMEOUT; - g_free(buf); - - dcb(TETHERING_ERROR_NONE, type, code, data); - - DBG("-\n"); -} - +//LCOV_EXCL_START static void __handle_no_data_timeout(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path, const gchar *interface_name, const gchar *signal_name, GVariant *parameters, gpointer user_data) @@ -664,7 +625,7 @@ static void __handle_low_battery_mode(GDBusConnection *connection, const gchar * void *data = NULL; tethering_disabled_cause_e code = TETHERING_DISABLED_BY_LOW_BATTERY; - for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_RESERVED; type++) { + for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) { dcb = th->disabled_cb[type]; if (dcb == NULL) continue; @@ -689,7 +650,7 @@ static void __handle_flight_mode(GDBusConnection *connection, const gchar *sende void *data = NULL; tethering_disabled_cause_e code = TETHERING_DISABLED_BY_FLIGHT_MODE; - for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_RESERVED; type++) { + for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) { dcb = th->disabled_cb[type]; if (dcb == NULL) continue; @@ -699,6 +660,7 @@ static void __handle_flight_mode(GDBusConnection *connection, const gchar *sende } DBG("-\n"); } +//LCOV_EXCL_STOP static void __handle_security_type_changed(GDBusConnection *connection, const gchar *sender_name, const gchar *object_path, const gchar *interface_name, const gchar *signal_name, @@ -725,6 +687,8 @@ static void __handle_security_type_changed(GDBusConnection *connection, const gc security_type = TETHERING_WIFI_SECURITY_TYPE_NONE; else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR) == 0) security_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK; + else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_WPS_STR) == 0) + security_type = TETHERING_WIFI_SECURITY_TYPE_WPS; else { SERR("Unknown type : %s\n", buf); g_free(buf); @@ -790,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; @@ -803,6 +767,7 @@ static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error); if (g_error) { + //LCOV_EXCL_START ERR("DBus error [%s]\n", g_error->message); if (g_error->code == G_DBUS_ERROR_NO_REPLY && ++retry < TETHERING_ERROR_RECOVERY_MAX) { @@ -814,24 +779,27 @@ static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, else error = TETHERING_ERROR_OPERATION_FAILED; g_error_free(g_error); + //LCOV_EXCL_STOP } else { g_variant_get(g_var, "(u)", &info); error = __get_error(info); } 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, @@ -850,6 +818,7 @@ static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error); if (g_error) { + //LCOV_EXCL_START ERR("DBus error [%s]\n", g_error->message); if (g_error->code == G_DBUS_ERROR_NO_REPLY && ++retry < TETHERING_ERROR_RECOVERY_MAX) { @@ -863,6 +832,7 @@ static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, else error = TETHERING_ERROR_OPERATION_FAILED; g_error_free(g_error); + //LCOV_EXCL_STOP } else { g_variant_get(g_var, "(u)", &info); g_variant_unref(g_var); @@ -884,6 +854,7 @@ static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, DBG("-\n"); } +//LCOV_EXCL_START static void __usb_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, gpointer user_data) { @@ -933,61 +904,12 @@ static void __usb_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, ecb(error, TETHERING_TYPE_USB, true, data); DBG("-\n"); } - -static void __wifi_ap_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, - gpointer user_data) -{ - DBG("+\n"); - - _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); - __tethering_h *th = (__tethering_h *)user_data; - GError *g_error = NULL; - GVariant *g_var; - guint info; - tethering_error_e error; - tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_RESERVED]; - void *data = th->enabled_user_data[TETHERING_TYPE_RESERVED]; - - g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error); - if (g_error) { - ERR("DBus error [%s]\n", g_error->message); - if (g_error->code == G_DBUS_ERROR_NO_REPLY && - ++retry < TETHERING_ERROR_RECOVERY_MAX) { - g_error_free(g_error); - tethering_enable((tethering_h)th, TETHERING_TYPE_RESERVED); - DBG("-\n"); - return; - } - if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED) - error = TETHERING_ERROR_PERMISSION_DENIED; - else - error = TETHERING_ERROR_OPERATION_FAILED; - g_error_free(g_error); - } else { - g_variant_get(g_var, "(u)", &info); - g_variant_unref(g_var); - error = __get_error(info); - } - retry = 0; - - sigs[E_SIGNAL_WIFI_AP_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus, - NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_AP_ON].name, - TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE, - sigs[E_SIGNAL_WIFI_AP_ON].cb, (gpointer)th, NULL); - - if (!ecb) { - DBG("-\n"); - return; - } - - ecb(error, TETHERING_TYPE_RESERVED, true, data); - DBG("-\n"); -} +//LCOV_EXCL_STOP 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; @@ -1003,15 +925,17 @@ static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res, g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error); if (g_error) { + //LCOV_EXCL_START ERR("DBus error [%s]\n", g_error->message); g_error_free(g_error); return; + //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, @@ -1039,6 +963,7 @@ static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res, dcb(error, type, code, data); break; + //LCOV_EXCL_START case MOBILE_AP_DISABLE_USB_TETHERING_CFM: sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus, NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name, @@ -1051,19 +976,7 @@ static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res, if (dcb) dcb(error, type, code, data); break; - - case MOBILE_AP_DISABLE_WIFI_AP_CFM: - sigs[E_SIGNAL_WIFI_AP_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus, - NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_AP_OFF].name, - TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE, - sigs[E_SIGNAL_WIFI_AP_OFF].cb, (gpointer)th, NULL); - - type = TETHERING_TYPE_RESERVED; - dcb = th->disabled_cb[type]; - data = th->disabled_user_data[type]; - if (dcb) - dcb(error, type, code, data); - break; + //LCOV_EXCL_STOP case MOBILE_AP_DISABLE_CFM: @@ -1094,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, @@ -1114,6 +1027,7 @@ static void __get_data_usage_cb(GObject *source_object, GAsyncResult *res, g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error); if (g_error) { + //LCOV_EXCL_START ERR("DBus fail [%s]\n", g_error->message); if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED) tethering_error = TETHERING_ERROR_PERMISSION_DENIED; @@ -1121,6 +1035,7 @@ static void __get_data_usage_cb(GObject *source_object, GAsyncResult *res, tethering_error = TETHERING_ERROR_OPERATION_FAILED; flag = true; + //LCOV_EXCL_STOP } if (th->data_usage_cb == NULL) { ERR("There is no data_usage_cb\n"); @@ -1177,43 +1092,6 @@ static void __settings_reloaded_cb(GObject *source_object, GAsyncResult *res, DBG("-\n"); } -static void __ap_settings_reloaded_cb(GObject *source_object, GAsyncResult *res, - gpointer user_data) -{ - DBG("+\n"); - - _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); - GError *g_error = NULL; - GVariant *g_var; - guint info; - __tethering_h *th = (__tethering_h *)user_data; - tethering_error_e tethering_error; - - g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error); - if (g_error) { - ERR("DBus fail [%s]\n", g_error->message); - if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED) - tethering_error = TETHERING_ERROR_PERMISSION_DENIED; - else - tethering_error = TETHERING_ERROR_OPERATION_FAILED; - g_error_free(g_error); - } - if (th->ap_settings_reloaded_cb == NULL) { - DBG("There is no settings_reloaded_cb\n-\n"); - return; - } - g_variant_get(g_var, "(u)", &info); - tethering_error = __get_error(info); - g_variant_unref(g_var); - - th->ap_settings_reloaded_cb(tethering_error, - th->ap_settings_reloaded_user_data); - - th->ap_settings_reloaded_cb = NULL; - th->ap_settings_reloaded_user_data = NULL; - DBG("-\n"); -} - static void __connect_signals(tethering_h tethering) { DBG("+\n"); @@ -1255,10 +1133,11 @@ static bool __get_intf_name(tethering_type_e type, char *buf, unsigned int len) _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n"); switch (type) { + //LCOV_EXCL_START case TETHERING_TYPE_USB: g_strlcpy(buf, TETHERING_USB_IF, len); break; - + //LCOV_EXCL_STOP case TETHERING_TYPE_WIFI: g_strlcpy(buf, TETHERING_WIFI_IF, len); break; @@ -1267,10 +1146,6 @@ static bool __get_intf_name(tethering_type_e type, char *buf, unsigned int len) g_strlcpy(buf, TETHERING_BT_IF, len); break; - case TETHERING_TYPE_RESERVED: - g_strlcpy(buf, TETHERING_WIFI_IF, len); - break; - default: ERR("Not supported type : %d\n", type); return false; @@ -1295,10 +1170,6 @@ static bool __get_gateway_addr(tethering_type_e type, char *buf, unsigned int le g_strlcpy(buf, TETHERING_BT_GATEWAY, len); break; - case TETHERING_TYPE_RESERVED: - g_strlcpy(buf, TETHERING_WIFI_GATEWAY, len); - break; - default: ERR("Not supported type : %d\n", type); return false; @@ -1309,7 +1180,7 @@ static bool __get_gateway_addr(tethering_type_e type, char *buf, unsigned int le static int __get_common_ssid(char *ssid, unsigned int size) { if (ssid == NULL) { - ERR("ssid is null\n"); + ERR("ssid is null\n"); //LCOV_EXCL_LINE return TETHERING_ERROR_INVALID_PARAMETER; } @@ -1357,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; @@ -1382,6 +1253,7 @@ static int __prepare_wifi_settings(tethering_h tethering, _softap_settings_t *se set->visibility = th->visibility; set->mac_filter = th->mac_filter; + set->max_connected = th->wifi_max_connected; set->channel = th->channel; __get_wifi_mode_type(th->mode_type, &ptr); @@ -1405,6 +1277,7 @@ static int __prepare_wifi_settings(tethering_h tethering, _softap_settings_t *se NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { + //LCOV_EXCL_START ERR("g_dbus_proxy_call_sync failed because %s\n", error->message); if (error->code == G_DBUS_ERROR_ACCESS_DENIED) @@ -1414,6 +1287,7 @@ static int __prepare_wifi_settings(tethering_h tethering, _softap_settings_t *se g_error_free(error); return ret; + //LCOV_EXCL_STOP } if (parameters != NULL) { @@ -1423,31 +1297,11 @@ static int __prepare_wifi_settings(tethering_h tethering, _softap_settings_t *se g_strlcpy(set->key, passphrase, sizeof(set->key)); } - DBG("-\n"); - return TETHERING_ERROR_NONE; -} - -static int __prepare_wifi_ap_settings(tethering_h tethering, _softap_settings_t *set) -{ - DBG("+\n"); - - __tethering_h *th = (__tethering_h *)tethering; - - if (th == NULL || set == NULL) { - ERR("null parameter\n"); - return TETHERING_ERROR_INVALID_PARAMETER; - } - - g_strlcpy(set->ssid, th->ap_ssid, sizeof(set->ssid)); - set->sec_type = th->sec_type; - set->visibility = th->visibility; - if (set->sec_type == TETHERING_WIFI_SECURITY_TYPE_NONE) - g_strlcpy(set->key, "", sizeof(set->key)); - else - g_strlcpy(set->key, th->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; } @@ -1460,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; } } @@ -1503,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; @@ -1519,23 +1382,18 @@ API int tethering_create(tethering_h *tethering) th->mac_filter = false; 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) { - ERR("random passphrase generation failed\n"); + ERR("random passphrase generation failed\n"); //LCOV_EXCL_LINE free(th); return TETHERING_ERROR_OPERATION_FAILED; } if (__get_common_ssid(ssid, sizeof(ssid)) != TETHERING_ERROR_NONE) { - ERR("common ssid get failed\n"); - free(th); - return TETHERING_ERROR_OPERATION_FAILED; - } - - th->ap_ssid = g_strdup(ssid); - if (th->ap_ssid == NULL) { - ERR("g_strdup failed\n"); + ERR("common ssid get failed\n"); //LCOV_EXCL_LINE free(th); return TETHERING_ERROR_OPERATION_FAILED; } @@ -1546,13 +1404,14 @@ API int tethering_create(tethering_h *tethering) GCancellable *cancellable = g_cancellable_new(); th->client_bus = g_bus_get_sync(DBUS_BUS_SYSTEM, cancellable, &error); if (error) { + //LCOV_EXCL_START ERR("Couldn't connect to the System bus[%s]", error->message); g_error_free(error); g_cancellable_cancel(cancellable); g_object_unref(cancellable); - g_free(th->ap_ssid); free(th); return TETHERING_ERROR_OPERATION_FAILED; + //LCOV_EXCL_STOP } th->cancellable = cancellable; @@ -1560,21 +1419,22 @@ API int tethering_create(tethering_h *tethering) NULL, TETHERING_SERVICE_NAME, TETHERING_SERVICE_OBJECT_PATH, TETHERING_SERVICE_INTERFACE, th->cancellable, &error); if (!th->client_bus_proxy) { + //LCOV_EXCL_START if (error) ERR("Couldn't create the proxy object because of %s\n", error->message); g_cancellable_cancel(th->cancellable); g_object_unref(th->cancellable); g_object_unref(th->client_bus); - g_free(th->ap_ssid); free(th); return TETHERING_ERROR_OPERATION_FAILED; + //LCOV_EXCL_STOP } __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; } @@ -1592,20 +1452,26 @@ 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) free(th->ssid); - if (th->ap_ssid) - free(th->ap_ssid); g_object_unref(th->cancellable); g_object_unref(th->client_bus_proxy); @@ -1613,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; } @@ -1634,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); @@ -1650,13 +1516,15 @@ API int tethering_enable(tethering_h tethering, tethering_type_e type) g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE); - if (type != TETHERING_TYPE_RESERVED - && __check_precondition(type) == FALSE) { - DBG("-\n"); + if (__check_precondition(type) == FALSE) { + //LCOV_EXCL_START + INFO("-\n"); return TETHERING_ERROR_OPERATION_FAILED; + //LCOV_EXCL_STOP } switch (type) { + //LCOV_EXCL_START case TETHERING_TYPE_USB: g_dbus_connection_signal_unsubscribe(connection, sigs[E_SIGNAL_USB_TETHER_ON].sig_id); @@ -1665,6 +1533,7 @@ API int tethering_enable(tethering_h tethering, tethering_type_e type) G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable, (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering); break; + //LCOV_EXCL_STOP case TETHERING_TYPE_WIFI: { _softap_settings_t set = {"", "", "", 0, false}; @@ -1679,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("(sssiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, 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; @@ -1695,23 +1564,7 @@ API int tethering_enable(tethering_h tethering, tethering_type_e type) break; - case TETHERING_TYPE_RESERVED: { - _softap_settings_t set = {"", "", "", 0, false}; - - ret = __prepare_wifi_ap_settings(tethering, &set); - if (ret != TETHERING_ERROR_NONE) { - ERR("softap settings initialization failed\n"); - return TETHERING_ERROR_OPERATION_FAILED; - } - - g_dbus_connection_signal_unsubscribe(connection, - sigs[E_SIGNAL_WIFI_AP_ON].sig_id); - - g_dbus_proxy_call(proxy, "enable_wifi_ap", - g_variant_new("(ssii)", set.ssid, set.key, set.visibility, set.sec_type), - G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable, (GAsyncReadyCallback) __wifi_ap_enabled_cfm_cb, (gpointer)tethering); - break; - } + //LCOV_EXCL_START case TETHERING_TYPE_ALL: { _softap_settings_t set = {"", "", "", 0, false}; @@ -1746,6 +1599,7 @@ API int tethering_enable(tethering_h tethering, tethering_type_e type) G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable, (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering); break; + //LCOV_EXCL_STOP } default: ERR("Unknown type : %d\n", type); @@ -1757,31 +1611,17 @@ API int tethering_enable(tethering_h tethering, tethering_type_e type) } g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT); - DBG("-\n"); + INFO("-\n"); return TETHERING_ERROR_NONE; } -/** - * @internal - * @brief Disables the tethering, asynchronously. - * @since_tizen 2.3 - * @privlevel platform - * @privilege http://tizen.org/privilege/tethering.admin - * @param[in] tethering The handle of tethering - * @param[in] type The type of tethering - * @return 0 on success, otherwise negative error value. - * @retval #TETHERING_ERROR_NONE Successful - * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter - * @post tethering_disabled_cb() will be invoked. - * @see tethering_is_enabled() - * @see tethering_enable() - */ -API int tethering_disable(tethering_h tethering, tethering_type_e type) +API int tethering_ipv6_enable(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); + 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"); @@ -1789,43 +1629,163 @@ API int tethering_disable(tethering_h tethering, tethering_type_e type) __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) { - case TETHERING_TYPE_USB: + //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_USB_TETHER_OFF].sig_id); + 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); - g_dbus_proxy_call(proxy, "disable_usb_tethering", - NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable, - (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering); + /* 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; + } - case TETHERING_TYPE_WIFI: + 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", - NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable, + 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. + * @since_tizen 2.3 + * @privlevel platform + * @privilege http://tizen.org/privilege/tethering.admin + * @param[in] tethering The handle of tethering + * @param[in] type The type of tethering + * @return 0 on success, otherwise negative error value. + * @retval #TETHERING_ERROR_NONE Successful + * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter + * @post tethering_disabled_cb() will be invoked. + * @see tethering_is_enabled() + * @see tethering_enable() + */ +API int tethering_disable(tethering_h tethering, tethering_type_e 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); + 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_USB: + g_dbus_connection_signal_unsubscribe(connection, + sigs[E_SIGNAL_USB_TETHER_OFF].sig_id); + + g_dbus_proxy_call(proxy, "disable_usb_tethering", + NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable, + (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering); + + break; + + case TETHERING_TYPE_WIFI: + + g_dbus_connection_signal_unsubscribe(connection, + sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id); + + g_dbus_proxy_call(proxy, "disable_wifi_tethering", NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable, (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering); break; - case TETHERING_TYPE_RESERVED: + case TETHERING_TYPE_BT: + g_dbus_connection_signal_unsubscribe(connection, - sigs[E_SIGNAL_WIFI_AP_OFF].sig_id); + sigs[E_SIGNAL_BT_TETHER_OFF].sig_id); - g_dbus_proxy_call(proxy, "disable_wifi_ap", + g_dbus_proxy_call(proxy, "disable_bt_tethering", NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable, (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering); break; @@ -1858,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; } @@ -1874,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; @@ -1895,14 +1856,11 @@ API bool tethering_is_enabled(tethering_h tethering, tethering_type_e type) vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_BT; break; - case TETHERING_TYPE_RESERVED: - vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI_AP; - break; - default: 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; } @@ -1928,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, @@ -1996,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, @@ -2043,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, @@ -2105,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, @@ -2152,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, @@ -2233,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"); @@ -2278,8 +2239,6 @@ API int tethering_foreach_connected_clients(tethering_h tethering, tethering_typ client.interface = TETHERING_TYPE_WIFI; else if (interface == MOBILE_AP_TYPE_BT) client.interface = TETHERING_TYPE_BT; - else if (interface == MOBILE_AP_TYPE_WIFI_AP) - client.interface = TETHERING_TYPE_RESERVED; else { ERR("Invalid interface\n"); g_free(key); @@ -2287,8 +2246,7 @@ API int tethering_foreach_connected_clients(tethering_h tethering, tethering_typ break; } DBG("interface is %d\n", client.interface); - if (client.interface != type && (TETHERING_TYPE_ALL != type && - client.interface != TETHERING_TYPE_RESERVED)) { + if (client.interface != type && (TETHERING_TYPE_ALL != type)) { g_free(key); g_variant_unref(value); break; @@ -2352,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"); @@ -2377,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; } @@ -2394,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"); @@ -2436,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"); @@ -2460,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; } @@ -2478,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"); @@ -2520,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"); @@ -2544,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; } @@ -2562,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"); @@ -2603,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"); @@ -2633,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"); @@ -2661,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"); @@ -2689,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"); @@ -2717,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"); @@ -2745,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"); @@ -2775,22 +2749,33 @@ 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"); __tethering_h *th = (__tethering_h *)tethering; tethering_error_e ret = TETHERING_ERROR_NONE; + char *sec_str = NULL; ret = __set_security_type(type); if (ret == TETHERING_ERROR_NONE) { + switch (type) { + case TETHERING_WIFI_SECURITY_TYPE_NONE: + sec_str = TETHERING_WIFI_SECURITY_TYPE_OPEN_STR; + break; + case TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK: + sec_str = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR; + break; + case TETHERING_WIFI_SECURITY_TYPE_WPS: + sec_str = TETHERING_WIFI_SECURITY_TYPE_WPS_STR; + break; + } + __send_dbus_signal(th->client_bus, - SIGNAL_NAME_SECURITY_TYPE_CHANGED, - type == TETHERING_WIFI_SECURITY_TYPE_NONE ? - TETHERING_WIFI_SECURITY_TYPE_OPEN_STR : - TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR); + SIGNAL_NAME_SECURITY_TYPE_CHANGED, sec_str); } return ret; } @@ -2811,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"); @@ -2836,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"); @@ -2881,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"); @@ -2937,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"); @@ -2973,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"); @@ -2998,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"); @@ -3024,6 +3015,7 @@ API int tethering_wifi_set_passphrase(tethering_h tethering, const char *passphr g_variant_new("(s)", passphrase), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { + //LCOV_EXCL_START ERR("g_dbus_proxy_call_sync failed because %s\n", error->message); if (error->code == G_DBUS_ERROR_ACCESS_DENIED) @@ -3033,6 +3025,7 @@ API int tethering_wifi_set_passphrase(tethering_h tethering, const char *passphr g_error_free(error); return ret; + //LCOV_EXCL_STOP } g_variant_get(parameters, "(u)", &ret); @@ -3065,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"); @@ -3083,6 +3077,7 @@ API int tethering_wifi_get_passphrase(tethering_h tethering, char **passphrase) NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); if (error) { + //LCOV_EXCL_START ERR("g_dbus_proxy_call_sync failed because %s\n", error->message); if (error->code == G_DBUS_ERROR_ACCESS_DENIED) @@ -3092,6 +3087,7 @@ API int tethering_wifi_get_passphrase(tethering_h tethering, char **passphrase) g_error_free(error); return ret; + //LCOV_EXCL_STOP } if (parameters != NULL) { @@ -3104,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"); @@ -3116,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"); @@ -3131,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"); @@ -3144,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, @@ -3175,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"); @@ -3204,7 +3209,7 @@ API int tethering_wifi_reload_settings(tethering_h tethering, tethering_wifi_set th->settings_reloaded_user_data = user_data; g_dbus_proxy_call(proxy, "reload_wifi_settings", - g_variant_new("(sssiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.sec_type), + g_variant_new("(sssiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type), G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable, (GAsyncReadyCallback) __settings_reloaded_cb, (gpointer)tethering); @@ -3213,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"); @@ -3226,8 +3232,11 @@ 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"); _retvm_if(mac_filter == NULL, TETHERING_ERROR_INVALID_PARAMETER, "parameter(mac_filter) is NULL\n"); @@ -3242,6 +3251,13 @@ static int __add_mac_to_file(const char *filepath, const char *mac) FILE *fp = NULL; char line[MAX_BUF_SIZE] = "\0"; bool mac_exist = false; + char *p_mac = NULL; + + p_mac = strdup(mac); + if (p_mac == NULL) { + ERR("strdup failed\n"); + return TETHERING_ERROR_OUT_OF_MEMORY; + } fp = fopen(filepath, "a+"); if (!fp) { @@ -3257,9 +3273,15 @@ static int __add_mac_to_file(const char *filepath, const char *mac) } } - if (!mac_exist) + if (!mac_exist) { fprintf(fp, "%s\n", mac); + if ((strcmp(filepath, ALLOWED_LIST) == 0)) + allowed_list = g_slist_append(allowed_list, p_mac); + else if ((strcmp(filepath, BLOCKED_LIST) == 0)) + blocked_list = g_slist_append(blocked_list, p_mac); + } + fclose(fp); return TETHERING_ERROR_NONE; @@ -3285,10 +3307,27 @@ static int __remove_mac_from_file(const char *filepath, const char *mac) } while (fgets(line, MAX_BUF_SIZE, fp) != NULL) { - if (strncmp(mac, line, 17) == 0) + if (strncmp(mac, line, 17) == 0) { DBG("MAC %s found in the list\n", mac); - else + + if ((strcmp(filepath, ALLOWED_LIST) == 0)) { + GSList *list = NULL; + for (list = allowed_list; list != NULL; list = list->next) { + char *p_mac = (char *)list->data; + if (strncmp(mac, p_mac, strlen(mac)) == 0) + allowed_list = g_slist_remove(allowed_list, p_mac); + } + } else if ((strcmp(filepath, BLOCKED_LIST) == 0)) { + GSList *list = NULL; + for (list = blocked_list; list != NULL; list = list->next) { + char *p_mac = (char *)list->data; + if (strncmp(mac, p_mac, strlen(mac)) == 0) + blocked_list = g_slist_remove(blocked_list, p_mac); + } + } + } else { fprintf(fp1, "%s", line); + } } fclose(fp); @@ -3304,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"); @@ -3316,6 +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); + 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, @@ -3324,8 +3367,25 @@ API int tethering_wifi_remove_allowed_mac_list(tethering_h tethering, const char return __remove_mac_from_file(ALLOWED_LIST, mac); } +API int tethering_wifi_get_allowed_mac_list(tethering_h tethering, void **allowed_mac_list) +{ + 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, + "parameter(allowed_mac_list) is NULL\n"); + + *allowed_mac_list = g_slist_copy(allowed_list); + return TETHERING_ERROR_NONE; +} + API int tethering_wifi_add_blocked_mac_list(tethering_h tethering, const char *mac) { + 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, @@ -3336,6 +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); + 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, @@ -3344,9 +3407,24 @@ API int tethering_wifi_remove_blocked_mac_list(tethering_h tethering, const char return __remove_mac_from_file(BLOCKED_LIST, mac); } +API int tethering_wifi_get_blocked_mac_list(tethering_h tethering, void **blocked_mac_list) +{ + 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(blocked_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(blocked_mac_list) is NULL\n"); + + *blocked_mac_list = g_slist_copy(blocked_list); + return TETHERING_ERROR_NONE; +} + 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"); @@ -3389,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"); @@ -3433,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, @@ -3445,325 +3526,639 @@ API int tethering_wifi_is_dhcp_enabled(tethering_h tethering, bool *dhcp_enabled return TETHERING_ERROR_NONE; } -/** - * @internal - * @brief Sets the security type of Wi-Fi AP. - * @since_tizen 2.3 - * @privlevel platform - * @privilege http://tizen.org/privilege/tethering.admin - * @details If security type is not set, WPA2_PSK is used - * @param[in] tethering The handle of tethering - * @param[in] type The security type - * @return 0 on success, otherwise negative error value. - * @retval #TETHERING_ERROR_NONE Successful - * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter - * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed - * @see tethering_wifi_ap_get_security_type() - */ -API int tethering_wifi_ap_set_security_type(tethering_h tethering, tethering_wifi_security_type_e type) +API int tethering_wifi_set_txpower(tethering_h tethering, unsigned int txpower) { - 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"); + GError *error = NULL; + _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(tethering) is NULL\n"); + _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false, + TETHERING_ERROR_NOT_ENABLED, + "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI); __tethering_h *th = (__tethering_h *)tethering; - th->sec_type = type; + + g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_set_txpower", + g_variant_new("(u)", txpower), + G_DBUS_CALL_FLAGS_NONE, + -1, th->cancellable, &error); + if (error) { + ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message); + g_clear_error(&error); + return TETHERING_ERROR_OPERATION_FAILED; + } return TETHERING_ERROR_NONE; } -/** - * @internal - * @brief Gets the security type of Wi-Fi AP. - * @since_tizen 2.3 - * @privlevel platform - * @privilege http://tizen.org/privilege/tethering.admin - * @details If security type is not set, WPA2_PSK is used - * @param[in] tethering The handle of tethering - * @param[out] type The security type - * @return 0 on success, otherwise negative error value. - * @retval #TETHERING_ERROR_NONE Successful - * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter - * @see tethering_wifi_ap_set_security_type() - */ -API int tethering_wifi_ap_get_security_type(tethering_h tethering, tethering_wifi_security_type_e *type) +API int tethering_wifi_get_txpower(tethering_h tethering, unsigned int *txpower) { - 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"); + GError *error = NULL; + GVariant *result = NULL; + + _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(tethering) is NULL\n"); + _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false, + TETHERING_ERROR_NOT_ENABLED, + "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI); + + __tethering_h *th = (__tethering_h *)tethering; + + result = g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_get_txpower", + NULL, + G_DBUS_CALL_FLAGS_NONE, + -1, th->cancellable, &error); + + if (result != NULL) { + g_variant_get(result, "(u)", txpower); + g_variant_unref(result); + } else { + if (error) + ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message); + g_clear_error(&error); + return TETHERING_ERROR_OPERATION_FAILED; + } + g_clear_error(&error); + return TETHERING_ERROR_NONE; +} + +API int tethering_wifi_set_mtu(tethering_h tethering, unsigned int mtu) +{ + CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE); + CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE); + + _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(tethering) is NULL\n"); + + GVariant *parameters; + GError *error = NULL; + guint result; + + __tethering_h *th = (__tethering_h *)tethering; + + GDBusProxy *proxy = th->client_bus_proxy; + + parameters = g_dbus_proxy_call_sync(proxy, "set_mtu", + g_variant_new("(u)", mtu), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); + if (error) { + ERR("g_dbus_proxy_call_sync failed because %s\n", error->message); + + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) + result = TETHERING_ERROR_PERMISSION_DENIED; + else + result = TETHERING_ERROR_OPERATION_FAILED; + + g_error_free(error); + return result; + } + + g_variant_get(parameters, "(u)", &result); + + g_variant_unref(parameters); + + return TETHERING_ERROR_NONE; +} + +API int tethering_wifi_change_mac(tethering_h tethering, char *mac) +{ + 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, + "parameter(mac) is NULL\n"); + + GVariant *parameters; + GError *error = NULL; + guint result; + + __tethering_h *th = (__tethering_h *)tethering; + + GDBusProxy *proxy = th->client_bus_proxy; + + parameters = g_dbus_proxy_call_sync(proxy, "change_mac", + g_variant_new("(s)", mac), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); + if (error) { + ERR("g_dbus_proxy_call_sync failed because %s\n", error->message); + + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) + result = TETHERING_ERROR_PERMISSION_DENIED; + else + result = TETHERING_ERROR_OPERATION_FAILED; + + g_error_free(error); + return result; + } + + g_variant_get(parameters, "(u)", &result); + + 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); + CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE); + + _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(tethering) is NULL\n"); __tethering_h *th = (__tethering_h *)tethering; - *type = th->sec_type; + th->wifi_max_connected = max_device; + + return TETHERING_ERROR_NONE; +} + +API int tethering_wifi_get_max_connected_device(tethering_h tethering, int *max_device) +{ + 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(max_device == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(max_device) is NULL\n"); + + __tethering_h *th = (__tethering_h *)tethering; + + *max_device = th->wifi_max_connected; + return TETHERING_ERROR_NONE; +} + +API int tethering_wifi_enable_port_forwarding(tethering_h tethering, bool enable) +{ + CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE); + CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE); + + _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(tethering) is NULL\n"); + + GVariant *parameters; + GError *error = NULL; + guint result; + + __tethering_h *th = (__tethering_h *)tethering; + + GDBusProxy *proxy = th->client_bus_proxy; + + parameters = g_dbus_proxy_call_sync(proxy, "enable_port_forwarding", + g_variant_new("(b)", enable), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); + if (error) { + ERR("g_dbus_proxy_call_sync failed because %s\n", error->message); + + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) + result = TETHERING_ERROR_PERMISSION_DENIED; + else + result = TETHERING_ERROR_OPERATION_FAILED; + + g_error_free(error); + return result; + } + + g_variant_get(parameters, "(u)", &result); + g_variant_unref(parameters); + + th->port_forwarding = true; + + return TETHERING_ERROR_NONE; +} + +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); + CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE); + + _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(tethering) is NULL\n"); + _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(protocol) is NULL\n"); + + GVariant *parameters; + GError *error = NULL; + guint result; + char cmd[MAX_BUF_SIZE] = { 0, }; + char *list = NULL; + + __tethering_h *th = (__tethering_h *)tethering; + + GDBusProxy *proxy = th->client_bus_proxy; + + parameters = g_dbus_proxy_call_sync(proxy, "add_port_forwarding_rule", + g_variant_new("(sssisi)", ifname, protocol, org_ip, org_port, final_ip, final_port), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); + if (error) { + ERR("g_dbus_proxy_call_sync failed because %s\n", error->message); + + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) + result = TETHERING_ERROR_PERMISSION_DENIED; + else + result = TETHERING_ERROR_OPERATION_FAILED; + + g_error_free(error); + return result; + } + + g_variant_get(parameters, "(u)", &result); + g_variant_unref(parameters); + + snprintf(cmd, sizeof(cmd), "%s "PORT_FORWARD_RULE_STR, IPTABLES, TABLE_NAT, TETH_NAT_PRE, ifname, protocol, org_ip, org_port, final_ip, final_port); + + list = strdup(cmd); + if (list == NULL) { + ERR("strdup failed\n"); + return TETHERING_ERROR_OUT_OF_MEMORY; + } + + port_forwarding = g_slist_append(port_forwarding, list); + + return TETHERING_ERROR_NONE; +} + +API int tethering_wifi_reset_port_forwarding_rule(tethering_h tethering) +{ + CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE); + CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE); + + _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(tethering) is NULL\n"); + + GVariant *parameters; + GError *error = NULL; + guint result; + + __tethering_h *th = (__tethering_h *)tethering; + + GDBusProxy *proxy = th->client_bus_proxy; + + parameters = g_dbus_proxy_call_sync(proxy, "reset_port_forwarding_rule", + NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); + if (error) { + ERR("g_dbus_proxy_call_sync failed because %s\n", error->message); + + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) + result = TETHERING_ERROR_PERMISSION_DENIED; + else + result = TETHERING_ERROR_OPERATION_FAILED; + + g_error_free(error); + return result; + } + + g_variant_get(parameters, "(u)", &result); + + g_variant_unref(parameters); + + return TETHERING_ERROR_NONE; +} + +API int tethering_wifi_is_port_forwarding_enabled(tethering_h tethering, bool* forwarding_enabled) +{ + 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(forwarding_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(forwarding_enabled) is NULL\n"); + + __tethering_h *th = (__tethering_h *)tethering; + + *forwarding_enabled = th->port_forwarding; + + return TETHERING_ERROR_NONE; +} + +API int tethering_wifi_get_port_forwarding_rule(tethering_h tethering, void **port_forwarding_list) +{ + 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(port_forwarding_list == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(port_forwarding_list) is NULL\n"); + + *port_forwarding_list = g_slist_copy(port_forwarding); + return TETHERING_ERROR_NONE; +} + +API int tethering_wifi_enable_port_filtering(tethering_h tethering, bool enable) +{ + CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE); + CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE); + + _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(tethering) is NULL\n"); + + GVariant *parameters; + GError *error = NULL; + guint result; + + __tethering_h *th = (__tethering_h *)tethering; + + GDBusProxy *proxy = th->client_bus_proxy; + + parameters = g_dbus_proxy_call_sync(proxy, "enable_port_filtering", + g_variant_new("(b)", enable), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); + if (error) { + ERR("g_dbus_proxy_call_sync failed because %s\n", error->message); + + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) + result = TETHERING_ERROR_PERMISSION_DENIED; + else + result = TETHERING_ERROR_OPERATION_FAILED; + + g_error_free(error); + return result; + } + + g_variant_get(parameters, "(u)", &result); + g_variant_unref(parameters); + + th->port_filtering = true; + return TETHERING_ERROR_NONE; } -/** - * @internal - * @brief Sets the SSID (service set identifier) for Wi-Fi AP. The SSID cannot exceed 32 bytes. - * @since_tizen 2.3 - * @privlevel platform - * @privilege http://tizen.org/privilege/tethering.admin - * @details If SSID is not set, Device name is used as SSID - * @param[in] tethering The handle of tethering - * @param[in] ssid The SSID - * @return 0 on success, otherwise negative error value. - * @retval #TETHERING_ERROR_NONE Successful - * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter - * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory - */ -API int tethering_wifi_ap_set_ssid(tethering_h tethering, const char *ssid) +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"); - _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER, - "parameter(ssid) is NULL\n"); + _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(protocol) is NULL\n"); + + GVariant *parameters; + GError *error = NULL; + guint result; + char cmd[MAX_BUF_SIZE] = { 0, }; + char *list = NULL; __tethering_h *th = (__tethering_h *)tethering; - char *p_ssid = NULL; - int ssid_len = 0; - ssid_len = strlen(ssid); - if (ssid_len > TETHERING_WIFI_SSID_MAX_LEN) { - ERR("parameter(ssid) is too long"); - return TETHERING_ERROR_INVALID_PARAMETER; + GDBusProxy *proxy = th->client_bus_proxy; + + parameters = g_dbus_proxy_call_sync(proxy, "add_port_filtering_rule", + g_variant_new("(isb)", port, protocol, allow), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); + if (error) { + ERR("g_dbus_proxy_call_sync failed because %s\n", error->message); + + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) + result = TETHERING_ERROR_PERMISSION_DENIED; + else + result = TETHERING_ERROR_OPERATION_FAILED; + + g_error_free(error); + return result; } - p_ssid = strdup(ssid); - if (p_ssid == NULL) { + g_variant_get(parameters, "(u)", &result); + g_variant_unref(parameters); + + if (allow) + snprintf(cmd, sizeof(cmd), "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_ACCEPT); + else + snprintf(cmd, sizeof(cmd), "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_DROP); + + DBG("cmd:%s", cmd); + + list = strdup(cmd); + if (list == NULL) { ERR("strdup failed\n"); return TETHERING_ERROR_OUT_OF_MEMORY; } - if (th->ap_ssid) - g_free(th->ap_ssid); - th->ap_ssid = p_ssid; + port_filtering = g_slist_append(port_filtering, list); return TETHERING_ERROR_NONE; } -/** - * @internal - * @brief Gets the SSID (service set identifier) for Wi-Fi AP. - * @since_tizen 2.3 - * @privlevel platform - * @privilege http://tizen.org/privilege/tethering.admin - * @details If SSID is not set, Device name is used as SSID - * @remarks @a ssid must be released with free() by you. - * @param[in] tethering The handle of tethering - * @param[out] ssid The SSID - * @return 0 on success, otherwise negative error value. - * @retval #TETHERING_ERROR_NONE Successful - * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter - * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory - */ -API int tethering_wifi_ap_get_ssid(tethering_h tethering, char **ssid) +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"); - _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER, - "parameter(ssid) is NULL\n"); + _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(protocol) is NULL\n"); + + GVariant *parameters; + GError *error = NULL; + guint result; + char cmd[MAX_BUF_SIZE] = { 0, }; + char *list = NULL; __tethering_h *th = (__tethering_h *)tethering; - *ssid = g_strdup(th->ap_ssid); - if (*ssid == NULL) { + GDBusProxy *proxy = th->client_bus_proxy; + + parameters = g_dbus_proxy_call_sync(proxy, "add_custom_port_filtering_rule", + g_variant_new("(iisb)", port1, port2, protocol, allow), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); + if (error) { + ERR("g_dbus_proxy_call_sync failed because %s\n", error->message); + + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) + result = TETHERING_ERROR_PERMISSION_DENIED; + else + result = TETHERING_ERROR_OPERATION_FAILED; + + g_error_free(error); + return result; + } + + g_variant_get(parameters, "(u)", &result); + g_variant_unref(parameters); + + if (allow) + snprintf(cmd, sizeof(cmd), "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_ACCEPT); + else + snprintf(cmd, sizeof(cmd), "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_DROP); + + DBG("cmd:%s", cmd); + + list = strdup(cmd); + if (list == NULL) { ERR("strdup failed\n"); return TETHERING_ERROR_OUT_OF_MEMORY; } + custom_port_filtering = g_slist_append(custom_port_filtering, list); + return TETHERING_ERROR_NONE; } -/** - * @internal - * @brief Sets the visibility of SSID(service set identifier) for Wi-Fi AP. - * @since_tizen 2.3 - * @privlevel platform - * @privilege http://tizen.org/privilege/tethering.admin - * @details If you set the visibility invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device. - * @details by default visibility is set to true. - * @remarks This change is applied next time Wi-Fi tethering is enabled - * @param[in] tethering The handle of tethering - * @param[in] visible The visibility of SSID: (@c true = visible, @c false = invisible) - * @return 0 on success, otherwise negative error value. - * @retval #TETHERING_ERROR_NONE Successful - * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter - * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed - * @see tethering_wifi_ap_get_ssid_visibility() - */ -API int tethering_wifi_ap_set_ssid_visibility(tethering_h tethering, bool visible) +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"); + "parameter(tethering) is NULL\n"); + _retvm_if(port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(port_filtering_list) is NULL\n"); - __tethering_h *th = (__tethering_h *)tethering; - th->visibility = visible; + *port_filtering_list = g_slist_copy(port_filtering); return TETHERING_ERROR_NONE; } -/** - * @internal - * @brief Gets the visibility of SSID(service set identifier) for Wi-Fi AP. - * @since_tizen 2.3 - * @privlevel platform - * @privilege http://tizen.org/privilege/tethering.admin - * @details If the visibility is set invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device. - * @details by default visibility is set to true. - * @param[in] tethering The handle of tethering - * @param[out] visible The visibility of SSID: (@c true = visible, @c false = invisible) - * @return 0 on success, otherwise negative error value. - * @retval #TETHERING_ERROR_NONE Successful - * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter - * @see tethering_wifi_ap_set_ssid_visibility() - */ -API int tethering_wifi_ap_get_ssid_visibility(tethering_h tethering, bool *visible) +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(visible == NULL, TETHERING_ERROR_INVALID_PARAMETER, - "parameter(visible) is NULL\n"); + _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(tethering) is NULL\n"); + _retvm_if(custom_port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(custom_port_filtering_list) is NULL\n"); + + *custom_port_filtering_list = g_slist_copy(custom_port_filtering); + return TETHERING_ERROR_NONE; +} + +API int tethering_wifi_is_port_filtering_enabled(tethering_h tethering, bool* filtering_enabled) +{ + 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(filtering_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER, + "parameter(filtering_enabled) is NULL\n"); __tethering_h *th = (__tethering_h *)tethering; - *visible = th->visibility; + *filtering_enabled = th->port_filtering; + return TETHERING_ERROR_NONE; } -/** - * @internal - * @brief Sets the passphrase for Wi-Fi AP. - * @since_tizen 2.3 - * @privlevel platform - * @privilege http://tizen.org/privilege/tethering.admin - * @details If the passphrase is not set, random string of 8 alphabets will be used. - * @param[in] tethering The handle of tethering - * @param[in] passphrase The passphrase - * @return 0 on success, otherwise negative error value. - * @retval #TETHERING_ERROR_NONE Successful - * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter - * @see tethering_wifi_ap_get_passphrase() - */ -API int tethering_wifi_ap_set_passphrase(tethering_h tethering, const char *passphrase) +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"); - _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER, - "parameter(passphrase) is NULL\n"); + "parameter(tethering) is NULL\n"); + + GVariant *parameters; + GError *error = NULL; + guint result; __tethering_h *th = (__tethering_h *)tethering; - int passphrase_len = 0; - passphrase_len = strlen(passphrase); + GDBusProxy *proxy = th->client_bus_proxy; - if (passphrase_len < TETHERING_WIFI_KEY_MIN_LEN || - passphrase_len > TETHERING_WIFI_KEY_MAX_LEN) { - ERR("parameter(passphrase) is too short or long\n"); - return TETHERING_ERROR_INVALID_PARAMETER; + parameters = g_dbus_proxy_call_sync(proxy, "set_vpn_passthrough_rule", + g_variant_new("(ib)", type, enable), + G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); + if (error) { + ERR("g_dbus_proxy_call_sync failed because %s\n", error->message); + + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) + result = TETHERING_ERROR_PERMISSION_DENIED; + else + result = TETHERING_ERROR_OPERATION_FAILED; + + g_error_free(error); + return result; } - if (!g_strcmp0(passphrase, th->passphrase)) - return TETHERING_ERROR_NONE; + g_variant_get(parameters, "(u)", &result); + + g_variant_unref(parameters); - g_strlcpy(th->passphrase, passphrase, sizeof(th->passphrase)); return TETHERING_ERROR_NONE; } -/** - * @internal - * @brief Gets the passphrase for Wi-Fi AP. - * @since_tizen 2.3 - * @privlevel platform - * @privilege http://tizen.org/privilege/tethering.admin - * @details If the passphrase is not set, random string of 8 alphabets will be used. - * @remarks @a passphrase must be released with free() by you. - * @param[in] tethering The handle of tethering - * @param[out] passphrase The passphrase - * @return 0 on success, otherwise negative error value. - * @retval #TETHERING_ERROR_NONE Successful - * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter - * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory - * @see tethering_wifi_ap_set_passphrase() - */ -API int tethering_wifi_ap_get_passphrase(tethering_h tethering, char **passphrase) +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\n"); - _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER, - "parameter(passphrase) is NULL\n"); - + "parameter(tethering) is NULL"); __tethering_h *th = (__tethering_h *)tethering; + GDBusProxy *proxy = th->client_bus_proxy; + GVariant *parameters = NULL; + int ret = 0; + GError *error = NULL; - *passphrase = g_strdup(th->passphrase); - if (*passphrase == NULL) { - ERR("strdup is failed\n"); - return TETHERING_ERROR_OUT_OF_MEMORY; + parameters = g_dbus_proxy_call_sync(proxy, "push_wps_button", + NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); + + if (error) { + ERR("g_dbus_proxy_call_sync failed because %s\n", error->message); + + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) + ret = TETHERING_ERROR_PERMISSION_DENIED; + else + ret = TETHERING_ERROR_OPERATION_FAILED; + + g_error_free(error); + return ret; + } + + if (parameters != NULL) { + g_variant_get(parameters, "(u)", &ret); + g_variant_unref(parameters); } return TETHERING_ERROR_NONE; } -/** - * @internal - * @brief Reload the settings (SSID / Passphrase / Security type / SSID visibility) for Wi-Fi AP. - * @since_tizen 2.3 - * @privlevel platform - * @privilege http://tizen.org/privilege/tethering.admin - * @remarks Connected devices via MobileAP will be disconnected when the settings are reloaded - * @param[in] tethering The handle of tethering - * @param[in] callback The callback function to invoke - * @param[in] user_data The user data to be passed to the callback function - * @return 0 on success, otherwise negative error value. - * @retval #TETHERING_ERROR_NONE Successful - * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter - * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed - */ -API int tethering_wifi_ap_reload_settings(tethering_h tethering, tethering_wifi_ap_settings_reloaded_cb callback, void *user_data) - +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\n"); - _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER, - "parameter(callback) is NULL\n"); - + "parameter(tethering) is NULL"); __tethering_h *th = (__tethering_h *)tethering; - _softap_settings_t set = {"", "", "", 0, false}; GDBusProxy *proxy = th->client_bus_proxy; + GVariant *parameters = NULL; int ret = 0; + GError *error = NULL; - DBG("+\n"); + parameters = g_dbus_proxy_call_sync(proxy, "set_wps_pin", + g_variant_new("(s)", wps_pin), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error); - if (th->ap_settings_reloaded_cb) { - ERR("Operation in progress\n"); - return TETHERING_ERROR_OPERATION_FAILED; - } + if (error) { + ERR("g_dbus_proxy_call_sync failed because %s\n", error->message); - ret = __prepare_wifi_ap_settings(tethering, &set); - if (ret != TETHERING_ERROR_NONE) { - ERR("softap settings initialization failed\n"); - return TETHERING_ERROR_OPERATION_FAILED; - } + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) + ret = TETHERING_ERROR_PERMISSION_DENIED; + else + ret = TETHERING_ERROR_OPERATION_FAILED; - th->ap_settings_reloaded_cb = callback; - th->ap_settings_reloaded_user_data = user_data; + g_error_free(error); + return ret; + } - g_dbus_proxy_call(proxy, "reload_wifi_ap_settings", - g_variant_new("(ssii)", set.ssid, set.key, set.visibility, set.sec_type), - G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable, - (GAsyncReadyCallback) __ap_settings_reloaded_cb, (gpointer)tethering); + if (parameters != NULL) { + g_variant_get(parameters, "(u)", &ret); + g_variant_unref(parameters); + } return TETHERING_ERROR_NONE; } + +