2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
21 #include <sys/ioctl.h>
22 #include <sys/socket.h>
23 #include <netinet/in.h>
25 #include <arpa/inet.h>
27 #include <dbus/dbus.h>
30 #include <ckmc/ckmc-manager.h>
31 #include <tzplatform_config.h>
32 #include "tethering_private.h"
34 #define ALLOWED_LIST tzplatform_mkpath(TZ_SYS_VAR, "/lib/hostapd/hostapd.accept")
35 #define BLOCKED_LIST tzplatform_mkpath(TZ_SYS_VAR, "/lib/hostapd/hostapd.deny")
36 #define TEMP_LIST tzplatform_mkpath(TZ_SYS_VAR, "/lib/hostapd/.hostapd_tmp")
37 #define MAC_ADDR_LEN 18
38 #define MAX_BUF_SIZE 80
41 #define VCONFKEY_WIFI_TXPOWER "db/dnet/txpower" /**< VCONFKEY for TX Power */
42 #define VCONFKEY_WIFI_CHANNEL "db/dnet/channel" /**< VCONFKEY for Channel */
43 #define VCONFKEY_WIFI_SSID "db/dnet/ssid" /**< VCONFKEY for ssid */
45 #define DBUS_DEFAULT_REPLY_TIMEOUT 15000
46 #endif /* TIZEN_TV_EXT */
48 #define IPTABLES "/usr/sbin/iptables"
49 #define TABLE_NAT "nat"
50 #define TETH_NAT_PRE "teth_nat_pre"
51 #define TABLE_FILTER "filter"
52 #define TETH_FILTER_FW "teth_filter_fw"
53 #define ACTION_DROP "DROP"
54 #define ACTION_ACCEPT "ACCEPT"
55 #define PORT_FORWARD_RULE_STR "-t %s -A %s -i %s -p %s -d %s --dport %d -j DNAT --to %s:%d"
56 #define FILTERING_MULTIPORT_RULE_STR "-t %s -A %s -p %s -m multiport --dport %d,%d -j %s"
57 #define FILTERING_RULE_STR "-t %s -A %s -p %s --dport %d -j %s"
60 DUAL_BAND_NONE = 0, //0
61 DUAL_BAND_2G = 1 << 0, //1
62 DUAL_BAND_5G = 1 << 1, //2
63 DUAL_BAND_MIN_INTERFACE = 1 << 2, //4
64 DUAL_BAND_ALL = 7, //7
67 static GSList *allowed_list = NULL;
68 static GSList *blocked_list = NULL;
69 static GSList *port_forwarding = NULL;
70 static GSList *port_filtering = NULL;
71 static GSList *custom_port_filtering = NULL;
73 static void __handle_wifi_tether_on(GDBusConnection *connection, const gchar *sender_name,
74 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
75 GVariant *parameters, gpointer user_data);
77 static void __handle_wifi_tether_off(GDBusConnection *connection, const gchar *sender_name,
78 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
79 GVariant *parameters, gpointer user_data);
81 static void __handle_p2p_tether_on(GDBusConnection *connection, const gchar *sender_name,
82 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
83 GVariant *parameters, gpointer user_data);
85 static void __handle_p2p_tether_off(GDBusConnection *connection, const gchar *sender_name,
86 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
87 GVariant *parameters, gpointer user_data);
89 static void __handle_usb_tether_on(GDBusConnection *connection, const gchar *sender_name,
90 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
91 GVariant *parameters, gpointer user_data);
93 static void __handle_usb_tether_off(GDBusConnection *connection, const gchar *sender_name,
94 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
95 GVariant *parameters, gpointer user_data);
97 static void __handle_bt_tether_on(GDBusConnection *connection, const gchar *sender_name,
98 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
99 GVariant *parameters, gpointer user_data);
101 static void __handle_bt_tether_off(GDBusConnection *connection, const gchar *sender_name,
102 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
103 GVariant *parameters, gpointer user_data);
105 static void __handle_net_closed(GDBusConnection *connection, const gchar *sender_name,
106 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
107 GVariant *parameters, gpointer user_data);
109 static void __handle_no_data_timeout(GDBusConnection *connection, const gchar *sender_name,
110 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
111 GVariant *parameters, gpointer user_data);
113 static void __handle_low_battery_mode(GDBusConnection *connection, const gchar *sender_name,
114 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
115 GVariant *parameters, gpointer user_data);
117 static void __handle_flight_mode(GDBusConnection *connection, const gchar *sender_name,
118 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
119 GVariant *parameters, gpointer user_data);
121 static void __handle_security_type_changed(GDBusConnection *connection, const gchar *sender_name,
122 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
123 GVariant *parameters, gpointer user_data);
125 static void __handle_ssid_visibility_changed(GDBusConnection *connection, const gchar *sender_name,
126 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
127 GVariant *parameters, gpointer user_data);
129 static void __handle_passphrase_changed(GDBusConnection *connection, const gchar *sender_name,
130 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
131 GVariant *parameters, gpointer user_data);
133 static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name,
134 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
135 GVariant *parameters, gpointer user_data);
137 static __tethering_sig_t sigs[] = {
138 {0, SIGNAL_NAME_NET_CLOSED, __handle_net_closed},
139 {0, SIGNAL_NAME_WIFI_TETHER_ON, __handle_wifi_tether_on},
140 {0, SIGNAL_NAME_WIFI_TETHER_OFF, __handle_wifi_tether_off},
141 {0, SIGNAL_NAME_P2P_TETHER_ON, __handle_p2p_tether_on},
142 {0, SIGNAL_NAME_P2P_TETHER_OFF, __handle_p2p_tether_off},
143 {0, SIGNAL_NAME_USB_TETHER_ON, __handle_usb_tether_on},
144 {0, SIGNAL_NAME_USB_TETHER_OFF, __handle_usb_tether_off},
145 {0, SIGNAL_NAME_BT_TETHER_ON, __handle_bt_tether_on},
146 {0, SIGNAL_NAME_BT_TETHER_OFF, __handle_bt_tether_off},
147 {0, SIGNAL_NAME_NO_DATA_TIMEOUT, __handle_no_data_timeout},
148 {0, SIGNAL_NAME_LOW_BATTERY_MODE, __handle_low_battery_mode},
149 {0, SIGNAL_NAME_FLIGHT_MODE, __handle_flight_mode},
150 {0, SIGNAL_NAME_SECURITY_TYPE_CHANGED, __handle_security_type_changed},
151 {0, SIGNAL_NAME_SSID_VISIBILITY_CHANGED, __handle_ssid_visibility_changed},
152 {0, SIGNAL_NAME_PASSPHRASE_CHANGED, __handle_passphrase_changed},
153 {0, SIGNAL_NAME_DHCP_STATUS, __handle_dhcp} };
155 static int retry = 0;
156 static int is_dualband_support = DUAL_BAND_NONE;
158 static void __reset_dualband_support(void)
160 is_dualband_support = DUAL_BAND_NONE;
163 static void __set_dualband_support(int band)
165 is_dualband_support |= band;
169 static gboolean __is_dualband_support(void)
171 return (is_dualband_support == DUAL_BAND_ALL) ? TRUE : FALSE;
173 static void __send_dbus_signal(GDBusConnection *conn, const char *signal_name, const char *arg)
175 if (conn == NULL || signal_name == NULL)
178 GVariant *message = NULL;
179 GError *error = NULL;
182 message = g_variant_new("(s)", arg);
184 g_dbus_connection_emit_signal(conn, NULL, TETHERING_SERVICE_OBJECT_PATH,
185 TETHERING_SERVICE_INTERFACE, signal_name, message, &error);
187 ERR("g_dbus_connection_emit_signal is failed because %s\n", error->message);
192 static bool __any_tethering_is_enabled(tethering_h tethering)
194 if (tethering_is_enabled(tethering, TETHERING_TYPE_USB) ||
195 tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) ||
196 tethering_is_enabled(tethering, TETHERING_TYPE_BT) ||
197 tethering_is_enabled(tethering, TETHERING_TYPE_P2P))
203 static tethering_error_e __set_security_type(const tethering_wifi_security_type_e security_type)
205 if (security_type != TETHERING_WIFI_SECURITY_TYPE_NONE &&
206 security_type != TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK &&
207 security_type != TETHERING_WIFI_SECURITY_TYPE_WPS &&
208 security_type != TETHERING_WIFI_SECURITY_TYPE_SAE) {
209 ERR("Invalid param\n");
210 return TETHERING_ERROR_INVALID_PARAMETER;
213 if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY, security_type) < 0) {
214 ERR("vconf_set_int is failed\n");
215 return TETHERING_ERROR_OPERATION_FAILED;
218 return TETHERING_ERROR_NONE;
221 static tethering_error_e __get_security_type(tethering_wifi_security_type_e *security_type)
223 if (security_type == NULL) {
224 ERR("Invalid param\n");
225 return TETHERING_ERROR_INVALID_PARAMETER;
228 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY,
229 (int *)security_type) < 0) {
230 ERR("vconf_get_int is failed\n");
231 return TETHERING_ERROR_OPERATION_FAILED;
234 return TETHERING_ERROR_NONE;
237 static bool __get_ssid_from_vconf(const char *path, char *ssid, unsigned int size)
239 if (path == NULL || ssid == NULL || size == 0)
243 char *ptr_tmp = NULL;
245 ptr = vconf_get_str(path);
249 if (!g_strcmp0(ptr, "")) {
254 if (!g_utf8_validate(ptr, -1, (const char **)&ptr_tmp))
257 g_strlcpy(ssid, ptr, size);
263 static tethering_error_e __set_visible(const bool visible)
265 if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, visible ? 0 : 1) < 0) {
266 ERR("vconf_set_int is failed\n");
267 return TETHERING_ERROR_OPERATION_FAILED;
270 return TETHERING_ERROR_NONE;
273 static tethering_error_e __get_visible(bool *visible)
275 if (visible == NULL) {
276 ERR("Invalid param\n");
277 return TETHERING_ERROR_INVALID_PARAMETER;
282 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, &hide) < 0) {
283 ERR("vconf_get_int is failed\n");
284 return TETHERING_ERROR_OPERATION_FAILED;
291 return TETHERING_ERROR_NONE;
294 static unsigned int __generate_initial_passphrase(char *passphrase, unsigned int size)
296 if (passphrase == NULL ||
297 size == 0 || size < TETHERING_WIFI_KEY_MIN_LEN + 1)
300 guint32 rand_int = 0;
303 for (index = 0; index < TETHERING_WIFI_KEY_MIN_LEN; index++) {
304 rand_int = g_random_int_range('a', 'z');
305 passphrase[index] = rand_int;
307 passphrase[index] = '\0';
312 static tethering_error_e __get_error(int agent_error)
314 tethering_error_e err = TETHERING_ERROR_NONE;
316 switch (agent_error) {
317 case MOBILE_AP_ERROR_NONE:
318 err = TETHERING_ERROR_NONE;
321 case MOBILE_AP_ERROR_RESOURCE:
322 err = TETHERING_ERROR_OUT_OF_MEMORY;
325 case MOBILE_AP_ERROR_INTERNAL:
326 err = TETHERING_ERROR_OPERATION_FAILED;
329 case MOBILE_AP_ERROR_INVALID_PARAM:
330 err = TETHERING_ERROR_INVALID_PARAMETER;
333 case MOBILE_AP_ERROR_ALREADY_ENABLED:
334 err = TETHERING_ERROR_OPERATION_FAILED;
337 case MOBILE_AP_ERROR_NOT_ENABLED:
338 err = TETHERING_ERROR_NOT_ENABLED;
341 case MOBILE_AP_ERROR_NET_OPEN:
342 err = TETHERING_ERROR_OPERATION_FAILED;
345 case MOBILE_AP_ERROR_NET_CLOSE:
346 err = TETHERING_ERROR_OPERATION_FAILED;
349 case MOBILE_AP_ERROR_DHCP:
350 err = TETHERING_ERROR_OPERATION_FAILED;
353 case MOBILE_AP_ERROR_IN_PROGRESS:
354 err = TETHERING_ERROR_OPERATION_FAILED;
357 case MOBILE_AP_ERROR_NOT_PERMITTED:
358 err = TETHERING_ERROR_NOT_PERMITTED;
361 case MOBILE_AP_ERROR_PERMISSION_DENIED:
362 err = TETHERING_ERROR_PERMISSION_DENIED;
365 ERR("Not defined error : %d\n", agent_error);
366 err = TETHERING_ERROR_OPERATION_FAILED;
373 static tethering_type_e __convert_to_tethering_type(mobile_ap_type_e type)
376 case MOBILE_AP_TYPE_USB:
377 return TETHERING_TYPE_USB;
378 case MOBILE_AP_TYPE_WIFI:
379 return TETHERING_TYPE_WIFI;
380 case MOBILE_AP_TYPE_BT:
381 return TETHERING_TYPE_BT;
382 case MOBILE_AP_TYPE_P2P:
383 return TETHERING_TYPE_P2P;
385 return TETHERING_TYPE_MAX;
389 static void __invoke_enable_cb(__tethering_h *th, tethering_type_e type, bool is_requested)
391 if (th == NULL || th->enabled_cb[type] == NULL) {
392 ERR("th or enabled_cb is NULL");
396 tethering_enabled_cb ecb = NULL;
399 if (!_tethering_check_handle(th)) {
400 DBG("Tethering handle is not valid now, ignore it.");
404 ecb = th->enabled_cb[type];
405 data = th->enabled_user_data[type];
406 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
409 static int __get_disabled_cause_by_interface_error(tethering_type_e type)
412 case TETHERING_TYPE_USB:
413 return TETHERING_DISABLED_BY_USB_DISCONNECTION;
414 case TETHERING_TYPE_WIFI:
415 return TETHERING_DISABLED_BY_WIFI_ON;
416 case TETHERING_TYPE_BT:
417 return TETHERING_DISABLED_BY_BT_OFF;
419 return TETHERING_DISABLED_BY_OTHERS;
423 static void __invoke_disabled_cb(__tethering_h *th, tethering_type_e type, GVariant *parameters)
425 if (th == NULL || th->disabled_cb[type] == NULL) {
426 ERR("th or disabled_cb is NULL");
430 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
431 tethering_disabled_cb dcb = NULL;
435 if (!_tethering_check_handle(th)) {
436 DBG("Tethering handle is not valid now, ignore it.");
440 dcb = th->disabled_cb[type];
441 data = th->disabled_user_data[type];
443 g_variant_get(parameters, "(s)", &buf);
444 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
445 code = __get_disabled_cause_by_interface_error(type);
446 else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT))
447 code = TETHERING_DISABLED_BY_TIMEOUT;
449 dcb(TETHERING_ERROR_NONE, type, code, data);
453 static void __invoke_disabled_cbs(__tethering_h *th, tethering_disabled_cause_e code)
460 if (!_tethering_check_handle(th)) {
461 DBG("Tethering handle is not valid now, ignore it.");
465 for (tethering_type_e type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
466 tethering_disabled_cb dcb = th->disabled_cb[type];
469 void *data = th->disabled_user_data[type];
470 dcb(TETHERING_ERROR_NONE, type, code, data);
474 static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name,
475 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
476 GVariant *parameters, gpointer user_data)
481 if (user_data == NULL) {
482 ERR("parameter(user_data) is NULL");
487 __tethering_h *th = (__tethering_h *)user_data;
489 tethering_type_e type = 0;
490 mobile_ap_type_e ap_type = 0;
491 tethering_connection_state_changed_cb ccb = NULL;
492 __tethering_client_h client;
500 memset(&client, 0, sizeof(__tethering_client_h));
501 g_variant_get(parameters, "(susssu)", &buf, &ap_type, &ip, &mac, &name, ×tamp);
503 if (!g_strcmp0(buf, "DhcpConnected")) {
505 } else if (!g_strcmp0(buf, "DhcpLeaseDeleted")) {
508 ERR("Unknown event [%s]\n", buf);
512 type = __convert_to_tethering_type(ap_type);
513 if (type == TETHERING_TYPE_MAX) {
514 ERR("Not supported tethering type [%d]\n", ap_type);
518 SINFO("[%s] type %d, ip %s, mac %s, name %s, timestamp %d",
519 buf, ap_type, ip, mac, name, timestamp);
521 ccb = th->changed_cb[type];
524 data = th->changed_user_data[type];
526 client.interface = type;
527 g_strlcpy(client.ip, ip, sizeof(client.ip));
528 g_strlcpy(client.mac, mac, sizeof(client.mac));
530 client.hostname = g_strdup(name);
531 client.tm = (time_t)timestamp;
533 ccb((tethering_client_h)&client, opened, data);
534 g_free(client.hostname);
545 static void __handle_net_closed(GDBusConnection *connection, const gchar *sender_name,
546 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
547 GVariant *parameters, gpointer user_data)
551 SINFO("Tethering Disabled by network close !");
552 __invoke_disabled_cbs((__tethering_h *)user_data, TETHERING_DISABLED_BY_NETWORK_CLOSE);
557 static void __handle_wifi_tether_on(GDBusConnection *connection, const gchar *sender_name,
558 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
559 GVariant *parameters, gpointer user_data)
563 __invoke_enable_cb((__tethering_h *)user_data, TETHERING_TYPE_WIFI, false);
568 static void __handle_wifi_tether_off(GDBusConnection *connection, const gchar *sender_name,
569 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
570 GVariant *parameters, gpointer user_data)
574 __invoke_disabled_cb((__tethering_h *)user_data, TETHERING_TYPE_WIFI, parameters);
579 static void __handle_p2p_tether_on(GDBusConnection *connection, const gchar *sender_name,
580 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
581 GVariant *parameters, gpointer user_data)
585 __invoke_enable_cb((__tethering_h *)user_data, TETHERING_TYPE_P2P, false);
590 static void __handle_p2p_tether_off(GDBusConnection *connection, const gchar *sender_name,
591 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
592 GVariant *parameters, gpointer user_data)
596 __invoke_disabled_cb((__tethering_h *)user_data, TETHERING_TYPE_P2P, parameters);
601 static void __handle_usb_tether_on(GDBusConnection *connection, const gchar *sender_name,
602 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
603 GVariant *parameters, gpointer user_data)
607 __invoke_enable_cb((__tethering_h *)user_data, TETHERING_TYPE_USB, false);
612 static void __handle_usb_tether_off(GDBusConnection *connection, const gchar *sender_name,
613 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
614 GVariant *parameters, gpointer user_data)
618 __invoke_disabled_cb((__tethering_h *)user_data, TETHERING_TYPE_USB, parameters);
623 static void __handle_bt_tether_on(GDBusConnection *connection, const gchar *sender_name,
624 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
625 GVariant *parameters, gpointer user_data)
629 __invoke_enable_cb((__tethering_h *)user_data, TETHERING_TYPE_BT, false);
634 static void __handle_bt_tether_off(GDBusConnection *connection, const gchar *sender_name,
635 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
636 GVariant *parameters, gpointer user_data)
640 __invoke_disabled_cb((__tethering_h *)user_data, TETHERING_TYPE_BT, parameters);
645 static void __handle_no_data_timeout(GDBusConnection *connection, const gchar *sender_name,
646 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
647 GVariant *parameters, gpointer user_data)
651 __invoke_disabled_cbs((__tethering_h *)user_data, TETHERING_DISABLED_BY_TIMEOUT);
656 static void __handle_low_battery_mode(GDBusConnection *connection, const gchar *sender_name,
657 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
658 GVariant *parameters, gpointer user_data)
662 __invoke_disabled_cbs((__tethering_h *)user_data, TETHERING_DISABLED_BY_LOW_BATTERY);
667 static void __handle_flight_mode(GDBusConnection *connection, const gchar *sender_name,
668 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
669 GVariant *parameters, gpointer user_data)
673 __invoke_disabled_cbs((__tethering_h *)user_data, TETHERING_DISABLED_BY_FLIGHT_MODE);
678 static void __handle_security_type_changed(GDBusConnection *connection, const gchar *sender_name,
679 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
680 GVariant *parameters, gpointer user_data)
686 if (user_data == NULL) {
687 ERR("parameter(user_data) is NULL");
692 __tethering_h *th = (__tethering_h *)user_data;
694 tethering_wifi_security_type_changed_cb scb = NULL;
696 tethering_wifi_security_type_e security_type;
699 if (!_tethering_check_handle(th)) {
700 DBG("Tethering handle is not valid now, ignore it.");
705 scb = th->security_type_changed_cb;
711 g_variant_get(parameters, "(s)", &buf);
712 data = th->security_type_user_data;
713 if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_OPEN_STR) == 0)
714 security_type = TETHERING_WIFI_SECURITY_TYPE_NONE;
715 else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR) == 0)
716 security_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK;
717 else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_WPS_STR) == 0)
718 security_type = TETHERING_WIFI_SECURITY_TYPE_WPS;
719 else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_SAE_STR) == 0)
720 security_type = TETHERING_WIFI_SECURITY_TYPE_SAE;
722 SERR("Unknown type : %s\n", buf);
728 scb(security_type, data);
734 static void __handle_ssid_visibility_changed(GDBusConnection *connection, const gchar *sender_name,
735 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
736 GVariant *parameters, gpointer user_data)
741 if (user_data == NULL) {
742 ERR("parameter(user_data) is NULL");
747 __tethering_h *th = (__tethering_h *)user_data;
749 tethering_wifi_ssid_visibility_changed_cb scb = NULL;
751 bool visible = false;
754 if (!_tethering_check_handle(th)) {
755 DBG("Tethering handle is not valid now, ignore it.");
760 scb = th->ssid_visibility_changed_cb;
766 g_variant_get(parameters, "(s)", &buf);
767 data = th->ssid_visibility_user_data;
768 if (g_strcmp0(buf, SIGNAL_MSG_SSID_VISIBLE) == 0)
778 static void __handle_passphrase_changed(GDBusConnection *connection, const gchar *sender_name,
779 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
780 GVariant *parameters, gpointer user_data)
785 if (user_data == NULL) {
786 ERR("parameter(user_data) is NULL");
791 __tethering_h *th = (__tethering_h *)user_data;
793 tethering_wifi_passphrase_changed_cb pcb = NULL;
796 if (!_tethering_check_handle(th)) {
797 DBG("Tethering handle is not valid now, ignore it.");
802 pcb = th->passphrase_changed_cb;
808 data = th->passphrase_user_data;
816 static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
822 if (user_data == NULL) {
823 ERR("parameter(user_data) is NULL");
828 GError *g_error = NULL;
831 tethering_type_e type = TETHERING_TYPE_WIFI;
832 tethering_error_e error;
833 __tethering_h *th = (__tethering_h *)user_data;
835 tethering_enabled_cb ecb = th->enabled_cb[type];
836 void *data = th->enabled_user_data[type];
838 if (!_tethering_check_handle((tethering_h)user_data)) {
839 DBG("Tethering handle is not valid now, ignore it.");
844 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
846 ERR("DBus error [%s]\n", g_error->message);
847 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
848 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
849 g_error_free(g_error);
850 tethering_enable((tethering_h)th, type);
853 } else if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
854 error = TETHERING_ERROR_PERMISSION_DENIED;
856 error = TETHERING_ERROR_OPERATION_FAILED;
857 g_error_free(g_error);
859 g_variant_get(g_var, "(u)", &info);
860 g_variant_unref(g_var);
861 error = __get_error(info);
865 INFO("cfm event : wifi tethering enable info : %d\n", error);
867 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
868 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_ON].name,
869 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
870 sigs[E_SIGNAL_WIFI_TETHER_ON].cb, (gpointer)th, NULL);
872 SINFO("Tethering enabled event ! error(%d)", error);
879 ecb(error, type, true, data);
885 static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
891 if (user_data == NULL) {
892 ERR("parameter(user_data) is NULL");
897 GError *g_error = NULL;
900 tethering_error_e error;
902 __tethering_h *th = (__tethering_h *)user_data;
903 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_BT];
904 void *data = th->enabled_user_data[TETHERING_TYPE_BT];
906 if (!_tethering_check_handle((tethering_h)user_data)) {
907 DBG("Tethering handle is not valid now, ignore it.");
912 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
914 ERR("DBus error [%s]\n", g_error->message);
915 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
916 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
917 g_error_free(g_error);
918 tethering_enable((tethering_h)th, TETHERING_TYPE_BT);
923 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
924 error = TETHERING_ERROR_PERMISSION_DENIED;
926 error = TETHERING_ERROR_OPERATION_FAILED;
927 g_error_free(g_error);
929 g_variant_get(g_var, "(u)", &info);
930 g_variant_unref(g_var);
931 error = __get_error(info);
935 sigs[E_SIGNAL_BT_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
936 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_ON].name,
937 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
938 sigs[E_SIGNAL_BT_TETHER_ON].cb, (gpointer)th, NULL);
946 ecb(error, TETHERING_TYPE_BT, true, data);
952 static void __usb_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
958 if (user_data == NULL) {
959 ERR("parameter(user_data) is NULL");
964 __tethering_h *th = (__tethering_h *)user_data;
965 GError *g_error = NULL;
968 tethering_error_e error;
969 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_USB];
970 void *data = th->enabled_user_data[TETHERING_TYPE_USB];
972 if (!_tethering_check_handle((tethering_h)user_data)) {
973 DBG("Tethering handle is not valid now, ignore it.");
978 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
980 ERR("DBus error [%s]\n", g_error->message);
981 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
982 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
983 g_error_free(g_error);
984 tethering_enable((tethering_h)th, TETHERING_TYPE_USB);
989 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
990 error = TETHERING_ERROR_PERMISSION_DENIED;
992 error = TETHERING_ERROR_OPERATION_FAILED;
993 g_error_free(g_error);
995 g_variant_get(g_var, "(u)", &info);
996 g_variant_unref(g_var);
997 error = __get_error(info);
1001 sigs[E_SIGNAL_USB_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1002 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_ON].name,
1003 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1004 sigs[E_SIGNAL_USB_TETHER_ON].cb, (gpointer)th, NULL);
1012 ecb(error, TETHERING_TYPE_USB, true, data);
1018 static void __p2p_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
1024 if (user_data == NULL) {
1025 ERR("parameter(user_data) is NULL");
1030 __tethering_h *th = (__tethering_h *)user_data;
1031 GError *g_error = NULL;
1034 tethering_error_e error;
1035 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_P2P];
1036 void *data = th->enabled_user_data[TETHERING_TYPE_P2P];
1038 if (!_tethering_check_handle((tethering_h)user_data)) {
1039 DBG("Tethering handle is not valid now, ignore it.");
1044 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1046 ERR("DBus error [%s]\n", g_error->message);
1047 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
1048 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
1049 g_error_free(g_error);
1050 tethering_enable((tethering_h)th, TETHERING_TYPE_P2P);
1055 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1056 error = TETHERING_ERROR_PERMISSION_DENIED;
1058 error = TETHERING_ERROR_OPERATION_FAILED;
1059 g_error_free(g_error);
1061 g_variant_get(g_var, "(u)", &info);
1062 g_variant_unref(g_var);
1063 error = __get_error(info);
1073 ecb(error, TETHERING_TYPE_P2P, true, data);
1079 static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res,
1085 if (user_data == NULL) {
1086 ERR("parameter(user_data) is NULL");
1091 GError *g_error = NULL;
1093 guint info, event_type;
1094 tethering_error_e error;
1095 tethering_type_e type;
1096 tethering_h tethering = (tethering_h)user_data;
1097 __tethering_h *th = (__tethering_h *)tethering;
1098 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_REQUEST;
1099 tethering_disabled_cb dcb = NULL;
1102 if (!_tethering_check_handle((tethering_h)user_data)) {
1103 DBG("Tethering handle is not valid now, ignore it.");
1108 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1110 ERR("DBus error [%s]\n", g_error->message);
1111 g_error_free(g_error);
1115 g_variant_get(g_var, "(uu)", &event_type, &info);
1116 INFO("cfm event : %d info : %d\n", event_type, info);
1117 g_variant_unref(g_var);
1118 error = __get_error(info);
1119 INFO("cfm event : %d info : %d\n", event_type, error);
1120 switch (event_type) {
1121 case MOBILE_AP_DISABLE_WIFI_TETHERING_CFM:
1122 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1123 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_OFF].name,
1124 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1125 sigs[E_SIGNAL_WIFI_TETHER_OFF].cb, (gpointer)th, NULL);
1127 type = TETHERING_TYPE_WIFI;
1128 dcb = th->disabled_cb[type];
1129 data = th->disabled_user_data[type];
1131 dcb(error, type, code, data);
1134 case MOBILE_AP_DISABLE_BT_TETHERING_CFM:
1135 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1136 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_OFF].name,
1137 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1138 sigs[E_SIGNAL_BT_TETHER_OFF].cb, (gpointer)th, NULL);
1140 type = TETHERING_TYPE_BT;
1141 dcb = th->disabled_cb[type];
1142 data = th->disabled_user_data[type];
1144 dcb(error, type, code, data);
1147 case MOBILE_AP_DISABLE_USB_TETHERING_CFM:
1148 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1149 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
1150 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1151 sigs[E_SIGNAL_USB_TETHER_OFF].cb, (gpointer)th, NULL);
1153 type = TETHERING_TYPE_USB;
1154 dcb = th->disabled_cb[type];
1155 data = th->disabled_user_data[type];
1157 dcb(error, type, code, data);
1160 case MOBILE_AP_DISABLE_P2P_TETHERING_CFM:
1161 type = TETHERING_TYPE_P2P;
1162 dcb = th->disabled_cb[type];
1163 data = th->disabled_user_data[type];
1165 dcb(error, type, code, data);
1168 case MOBILE_AP_DISABLE_CFM:
1170 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1171 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_OFF].name,
1172 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1173 sigs[E_SIGNAL_WIFI_TETHER_OFF].cb, (gpointer)th, NULL);
1174 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1175 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_OFF].name,
1176 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1177 sigs[E_SIGNAL_BT_TETHER_OFF].cb, (gpointer)th, NULL);
1178 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1179 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
1180 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1181 sigs[E_SIGNAL_USB_TETHER_OFF].cb, (gpointer)th, NULL);
1183 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
1184 dcb = th->disabled_cb[type];
1187 data = th->disabled_user_data[type];
1189 dcb(error, type, code, data);
1194 ERR("Invalid event\n");
1202 static void __get_data_usage_cb(GObject *source_object, GAsyncResult *res,
1208 if (user_data == NULL) {
1209 ERR("parameter(user_data) is NULL");
1214 GError *g_error = NULL;
1217 guint64 tx_bytes, rx_bytes;
1218 __tethering_h *th = (__tethering_h *)user_data;
1219 tethering_error_e tethering_error = TETHERING_ERROR_NONE;
1222 if (!_tethering_check_handle((tethering_h)user_data)) {
1223 DBG("Tethering handle is not valid now, ignore it.");
1228 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1230 ERR("DBus fail [%s]\n", g_error->message);
1231 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1232 tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1234 tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1238 if (th->data_usage_cb == NULL) {
1239 ERR("There is no data_usage_cb\n");
1244 th->data_usage_cb(tethering_error, 0LL, 0LL, th->data_usage_user_data);
1246 g_variant_get(g_var, "(utt)", &event_type, &tx_bytes, &rx_bytes);
1247 th->data_usage_cb(TETHERING_ERROR_NONE,
1248 rx_bytes, tx_bytes, th->data_usage_user_data);
1249 g_variant_unref(g_var);
1251 th->data_usage_cb = NULL;
1252 th->data_usage_user_data = NULL;
1258 static void __settings_reloaded_cb(GObject *source_object, GAsyncResult *res,
1264 if (user_data == NULL) {
1265 ERR("parameter(user_data) is NULL");
1270 GError *g_error = NULL;
1273 __tethering_h *th = (__tethering_h *)user_data;
1274 tethering_error_e tethering_error = TETHERING_ERROR_NONE;
1276 if (!_tethering_check_handle((tethering_h)user_data)) {
1277 DBG("Tethering handle is not valid now, ignore it.");
1282 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1284 ERR("DBus fail [%s]\n", g_error->message);
1285 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1286 tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1288 tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1289 g_error_free(g_error);
1291 g_variant_get(g_var, "(u)", &info);
1292 if (tethering_error == TETHERING_ERROR_NONE)
1293 tethering_error = __get_error(info);
1294 g_variant_unref(g_var);
1297 if (th->settings_reloaded_cb == NULL) {
1298 DBG("There is no settings_reloaded_cb\n-\n");
1303 th->settings_reloaded_cb(tethering_error,
1304 th->settings_reloaded_user_data);
1306 th->settings_reloaded_cb = NULL;
1307 th->settings_reloaded_user_data = NULL;
1313 static void __connect_signals(tethering_h tethering)
1316 _retm_if(tethering == NULL, "parameter(tethering) is NULL\n");
1318 __tethering_h *th = (__tethering_h *)tethering;
1319 GDBusConnection *connection = th->client_bus;
1322 for (i = E_SIGNAL_NET_CLOSED; i < E_SIGNAL_MAX; i++) {
1323 sigs[i].sig_id = g_dbus_connection_signal_subscribe(connection,
1324 NULL, TETHERING_SERVICE_INTERFACE, sigs[i].name,
1325 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1326 sigs[i].cb, tethering, NULL);
1331 static void __disconnect_signals(tethering_h tethering)
1335 _retm_if(tethering == NULL, "parameter(tethering) is NULL\n");
1337 __tethering_h *th = (__tethering_h *)tethering;
1338 GDBusConnection *connection = th->client_bus;
1342 for (i = E_SIGNAL_NET_CLOSED; i < E_SIGNAL_MAX; i++)
1343 g_dbus_connection_signal_unsubscribe(connection, sigs[i].sig_id);
1349 static bool __get_intf_name(tethering_type_e type, char *buf, unsigned int len)
1351 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1354 case TETHERING_TYPE_USB:
1355 g_strlcpy(buf, TETHERING_USB_IF, len);
1357 case TETHERING_TYPE_WIFI:
1358 g_strlcpy(buf, TETHERING_WIFI_IF, len);
1360 case TETHERING_TYPE_BT:
1361 g_strlcpy(buf, TETHERING_BT_IF, len);
1363 case TETHERING_TYPE_P2P:
1364 g_strlcpy(buf, TETHERING_P2P_IF, len);
1367 ERR("Not supported type : %d\n", type);
1373 static bool __get_gateway_addr(tethering_type_e type, char *buf, unsigned int len)
1375 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1378 case TETHERING_TYPE_USB:
1379 g_strlcpy(buf, TETHERING_USB_GATEWAY, len);
1381 case TETHERING_TYPE_WIFI:
1382 g_strlcpy(buf, TETHERING_WIFI_GATEWAY, len);
1384 case TETHERING_TYPE_BT:
1385 g_strlcpy(buf, TETHERING_BT_GATEWAY, len);
1387 case TETHERING_TYPE_P2P:
1388 g_strlcpy(buf, TETHERING_P2P_GATEWAY, len);
1391 ERR("Not supported type : %d\n", type);
1397 static int __get_common_ssid(char *ssid, unsigned int size)
1400 ERR("ssid is null\n");
1401 return TETHERING_ERROR_INVALID_PARAMETER;
1405 if (__get_ssid_from_vconf(VCONFKEY_WIFI_SSID, ssid, size))
1406 return TETHERING_ERROR_NONE;
1408 ERR("vconf key get failed for ssid or invalid ssid is found");
1409 #endif /* TIZEN_TV_EXT */
1411 if (__get_ssid_from_vconf(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
1412 ssid, size) == false) {
1413 ERR("vconf_get_str is failed and set default ssid");
1414 g_strlcpy(ssid, TETHERING_DEFAULT_SSID, size);
1417 return TETHERING_ERROR_NONE;
1420 static bool __get_wifi_mode_type(tethering_wifi_mode_type_e type, char **buf)
1422 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1425 case TETHERING_WIFI_MODE_TYPE_B:
1426 *buf = g_strdup("b");
1428 case TETHERING_WIFI_MODE_TYPE_G:
1429 *buf = g_strdup("g");
1431 case TETHERING_WIFI_MODE_TYPE_A:
1432 *buf = g_strdup("a");
1434 case TETHERING_WIFI_MODE_TYPE_AD:
1435 *buf = g_strdup("ad");
1438 ERR("Not supported type : %d\n", type);
1444 static int __prepare_wifi_settings(tethering_h tethering, _softap_settings_t *set)
1448 __tethering_h *th = (__tethering_h *)tethering;
1449 tethering_error_e ret = TETHERING_ERROR_NONE;
1452 if (th == NULL || set == NULL) {
1453 ERR("null parameter\n-\n");
1454 return TETHERING_ERROR_INVALID_PARAMETER;
1457 if (th->ssid == NULL)
1458 __get_common_ssid(set->ssid, sizeof(set->ssid));
1460 g_strlcpy(set->ssid, th->ssid, sizeof(set->ssid));
1462 ret = __get_security_type(&set->sec_type);
1463 if (ret != TETHERING_ERROR_NONE)
1464 set->sec_type = th->sec_type;
1466 ret = __get_visible(&set->visibility);
1467 if (ret != TETHERING_ERROR_NONE)
1468 set->visibility = th->visibility;
1470 set->mac_filter = th->mac_filter;
1471 set->max_connected = th->wifi_max_connected;
1472 set->channel = th->channel;
1473 set->txpower = th->txpower;
1475 __get_wifi_mode_type(th->mode_type, &ptr);
1477 g_strlcpy(set->mode, "", sizeof(set->mode));
1479 g_strlcpy(set->mode, ptr, sizeof(set->mode));
1483 if (set->sec_type == TETHERING_WIFI_SECURITY_TYPE_NONE) {
1484 g_strlcpy(set->key, "", sizeof(set->key));
1486 GDBusProxy *proxy = th->client_bus_proxy;
1487 GVariant *parameters;
1488 GError *error = NULL;
1489 char *passphrase = NULL;
1490 unsigned int len = 0;
1492 parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_passphrase",
1493 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1496 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
1498 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
1499 ret = TETHERING_ERROR_PERMISSION_DENIED;
1501 ret = TETHERING_ERROR_OPERATION_FAILED;
1503 g_error_free(error);
1507 if (parameters != NULL) {
1508 g_variant_get(parameters, "(siu)", &passphrase, &len, &ret);
1509 g_strlcpy(set->key, passphrase, sizeof(set->key) - 1);
1511 g_variant_unref(parameters);
1515 if (strlen(th->ip_address))
1516 g_strlcpy(set->ip_address, th->ip_address, sizeof(set->ip_address));
1518 g_strlcpy(set->ip_address, TETHERING_WIFI_GATEWAY, sizeof(set->ip_address));
1520 INFO("ssid: %s security: %d mode: %s "
1521 "channel: %d visibility: %s ip_address: [%s]\n",
1522 set->ssid, set->sec_type, set->mode, set->channel,
1523 (set->visibility) ? "true" : "false",
1526 return TETHERING_ERROR_NONE;
1529 static bool __check_precondition(__tethering_h *th, tethering_type_e type)
1531 int dnet_status = 0;
1532 int cellular_state = 0;
1534 /* data network through cellular */
1535 vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &cellular_state);
1536 if (cellular_state == VCONFKEY_NETWORK_CELLULAR_ON) {
1537 INFO("Data Network can be connected later");
1541 /* data network status */
1542 vconf_get_int(VCONFKEY_NETWORK_STATUS, &dnet_status);
1543 if ((dnet_status == VCONFKEY_NETWORK_WIFI
1544 && type != TETHERING_TYPE_WIFI)
1545 || (th->wifi_sharing && dnet_status == VCONFKEY_NETWORK_WIFI
1546 && type == TETHERING_TYPE_WIFI)
1547 || dnet_status == VCONFKEY_NETWORK_ETHERNET)
1550 ERR("Network is not available!");
1555 static void __set_vconf_values_for_tv(__tethering_h *tethering)
1557 int ret, channel, txpower;
1558 __tethering_h *th = tethering;
1563 ret = vconf_get_int(VCONFKEY_WIFI_CHANNEL, &channel);
1565 ERR("vconf key get failed for channel !!");
1566 channel = TETHERING_WIFI_CHANNEL;
1569 ret = vconf_get_int(VCONFKEY_WIFI_TXPOWER, &txpower);
1571 ERR("vconf key get failed for txpower !!");
1572 txpower = TETHERING_WIFI_MAX_TXPOWER;
1575 th->channel = channel;
1576 th->txpower = txpower;
1578 #endif /* TIZEN_TV_EXT */
1582 * @brief Creates the handle of tethering.
1584 * @privlevel platform
1585 * @privilege http://tizen.org/privilege/tethering.admin
1586 * @remarks The @a tethering must be released tethering_destroy() by you.
1587 * @param[out] tethering A handle of a new mobile ap handle on success
1588 * @return 0 on success, otherwise a negative error value.
1589 * @retval #TETHERING_ERROR_NONE Successful
1590 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1591 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1592 * @retval #TETHERING_ERROR_NOT_SUPPORT_API API is not supported
1593 * @see tethering_destroy()
1595 API int tethering_create(tethering_h *tethering)
1597 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1598 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1599 "parameter(tethering) is NULL\n");
1602 __tethering_h *th = NULL;
1603 GError *error = NULL;
1604 char ssid[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
1606 th = (__tethering_h *)malloc(sizeof(__tethering_h));
1608 _retvm_if(th == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
1609 "malloc is failed\n");
1610 memset(th, 0x00, sizeof(__tethering_h));
1611 th->sec_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK;
1612 th->visibility = true;
1613 th->mac_filter = false;
1614 th->wifi_sharing = false;
1615 th->channel = TETHERING_WIFI_CHANNEL;
1616 th->mode_type = TETHERING_WIFI_MODE_TYPE_G;
1617 th->wifi_max_connected = TETHERING_WIFI_MAX_STA;
1618 th->txpower = TETHERING_WIFI_MAX_TXPOWER;
1620 if (__generate_initial_passphrase(th->passphrase,
1621 sizeof(th->passphrase)) == 0) {
1622 ERR("random passphrase generation failed\n");
1624 return TETHERING_ERROR_OPERATION_FAILED;
1627 if (__get_common_ssid(ssid, sizeof(ssid)) != TETHERING_ERROR_NONE) {
1628 ERR("common ssid get failed\n");
1630 return TETHERING_ERROR_OPERATION_FAILED;
1634 __set_vconf_values_for_tv(th);
1635 #endif /* TIZEN_TV_EXT */
1636 SINFO("ssid: %s, key: %s, channel: %d, mode: %d, txpower: %d, security: %d max_device: %d\n",
1637 ssid, th->passphrase, th->channel, th->mode_type, th->txpower, th->sec_type,
1638 th->wifi_max_connected);
1640 #if !GLIB_CHECK_VERSION(2, 36, 0)
1643 GCancellable *cancellable = g_cancellable_new();
1644 th->client_bus = g_bus_get_sync(DBUS_BUS_SYSTEM, cancellable, &error);
1646 ERR("Couldn't connect to the System bus[%s]", error->message);
1647 g_error_free(error);
1648 g_cancellable_cancel(cancellable);
1649 g_object_unref(cancellable);
1651 return TETHERING_ERROR_OPERATION_FAILED;
1653 th->cancellable = cancellable;
1655 th->client_bus_proxy = g_dbus_proxy_new_sync(th->client_bus, G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION,
1656 NULL, TETHERING_SERVICE_NAME, TETHERING_SERVICE_OBJECT_PATH,
1657 TETHERING_SERVICE_INTERFACE, th->cancellable, &error);
1658 if (!th->client_bus_proxy) {
1660 ERR("Couldn't create the proxy object because of %s\n", error->message);
1661 g_cancellable_cancel(th->cancellable);
1662 g_object_unref(th->cancellable);
1663 g_object_unref(th->client_bus);
1665 return TETHERING_ERROR_OPERATION_FAILED;
1668 __connect_signals((tethering_h)th);
1670 *tethering = (tethering_h)th;
1671 _tethering_add_handle(th);
1672 INFO("Tethering Handle : %p\n", th);
1674 return TETHERING_ERROR_NONE;
1679 * @brief Destroys the handle of tethering.
1681 * @privlevel platform
1682 * @privilege http://tizen.org/privilege/tethering.admin
1683 * @param[in] tethering The handle of tethering
1684 * @return 0 on success, otherwise a negative error value.
1685 * @retval #TETHERING_ERROR_NONE Successful
1686 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1687 * @see tethering_create()
1689 API int tethering_destroy(tethering_h tethering)
1692 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1693 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1694 "parameter(tethering) is NULL\n");
1696 __tethering_h *th = (__tethering_h *)tethering;
1698 INFO("Tethering Handle : %p\n", th);
1700 __disconnect_signals(tethering);
1701 _tethering_remove_handle(th);
1706 g_object_unref(th->cancellable);
1707 g_object_unref(th->client_bus_proxy);
1708 g_object_unref(th->client_bus);
1709 memset(th, 0x00, sizeof(__tethering_h));
1714 return TETHERING_ERROR_NONE;
1717 static GVariant *__get_wifi_settings_dbus_params(const char *wifi_tether_type, _softap_settings_t *set)
1719 GVariantBuilder *builder = NULL;
1720 GVariant *params = NULL;
1722 builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
1723 if (builder == NULL) {
1724 ERR("Failed to create builder");
1728 g_variant_builder_add(builder, "{sv}",
1730 g_variant_new_string(set->ssid));
1732 if (set->sec_type != TETHERING_WIFI_SECURITY_TYPE_NONE)
1733 g_variant_builder_add(builder, "{sv}",
1735 g_variant_new_string(set->key));
1737 if (!g_strcmp0(set->mode, "b")) {
1738 g_variant_builder_add(builder, "{sv}",
1739 "mode", g_variant_new_int32(0));
1740 } else if (!g_strcmp0(set->mode, "g")) {
1741 g_variant_builder_add(builder, "{sv}",
1742 "mode", g_variant_new_int32(1));
1743 } else if (!g_strcmp0(set->mode, "n")) {
1744 g_variant_builder_add(builder, "{sv}",
1745 "mode", g_variant_new_int32(2));
1746 } else if (!g_strcmp0(set->mode, "ac")) {
1747 g_variant_builder_add(builder, "{sv}",
1748 "mode", g_variant_new_int32(3));
1753 g_variant_builder_add(builder, "{sv}",
1755 g_variant_new_boolean(set->visibility));
1757 g_variant_builder_add(builder, "{sv}",
1759 g_variant_new_int32(set->channel));
1761 g_variant_builder_add(builder, "{sv}",
1763 g_variant_new_int32(set->sec_type));
1765 g_variant_builder_add(builder, "{sv}",
1767 g_variant_new_boolean(set->mac_filter));
1769 g_variant_builder_add(builder, "{sv}",
1771 g_variant_new_int32(set->max_connected));
1773 g_variant_builder_add(builder, "{sv}",
1775 g_variant_new_int32(TETHERING_ADDRESS_FAMILY_IPV4));
1777 g_variant_builder_add(builder, "{sv}",
1779 g_variant_new_int32(set->txpower));
1781 if (strlen(set->ip_address))
1782 g_variant_builder_add(builder, "{sv}",
1784 g_variant_new_string(set->ip_address));
1786 if (wifi_tether_type)
1787 g_variant_builder_add(builder, "{sv}",
1789 g_variant_new_string(wifi_tether_type));
1791 params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
1792 g_variant_builder_unref(builder);
1799 * @brief Enables the tethering, asynchronously.
1801 * @privlevel platform
1802 * @privilege http://tizen.org/privilege/tethering.admin
1803 * @param[in] tethering The handle of tethering
1804 * @param[in] type The type of tethering
1805 * @return 0 on success, otherwise negative error value.
1806 * @retval #TETHERING_ERROR_NONE Successful
1807 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1808 * @post tethering_enabled_cb() will be invoked.
1809 * @see tethering_is_enabled()
1810 * @see tethering_disable()
1812 API int tethering_enable(tethering_h tethering, tethering_type_e type)
1814 INFO("+ type : %d\n", type);
1815 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1816 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1817 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1818 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1820 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1821 "parameter(tethering) is NULL\n");
1823 tethering_error_e ret = TETHERING_ERROR_NONE;
1824 __tethering_h *th = (__tethering_h *)tethering;
1825 GDBusProxy *proxy = th->client_bus_proxy;
1826 GDBusConnection *connection = th->client_bus;
1829 g_dbus_proxy_set_default_timeout(proxy, DBUS_DEFAULT_REPLY_TIMEOUT);
1830 #else /* TIZEN_TV_EXT */
1831 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
1832 #endif /* TIZEN_TV_EXT */
1834 if (__check_precondition(th, type) == FALSE) {
1836 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1837 return TETHERING_ERROR_OPERATION_FAILED;
1841 case TETHERING_TYPE_USB:
1842 g_dbus_connection_signal_unsubscribe(connection,
1843 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1845 g_dbus_proxy_call(proxy, "enable_usb_tethering",
1846 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1847 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1848 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1851 case TETHERING_TYPE_WIFI: {
1852 GVariant *params = NULL;
1853 _softap_settings_t set;
1854 memset(&set, 0, sizeof(_softap_settings_t));
1856 ret = __prepare_wifi_settings(tethering, &set);
1857 if (ret != TETHERING_ERROR_NONE) {
1858 ERR("softap settings initialization failed\n");
1860 return TETHERING_ERROR_OPERATION_FAILED;
1862 g_dbus_connection_signal_unsubscribe(connection,
1863 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1865 SINFO("ssid %s, key %s, channel %d, mode %s, "
1866 "txpower %d, security %d, max_device %d, "
1867 "ip_address [%s]\n",
1868 set.ssid, set.key, set.channel, set.mode,
1869 set.txpower, set.sec_type,
1870 set.max_connected, set.ip_address);
1872 if (th->wifi_sharing)
1873 params = __get_wifi_settings_dbus_params("wifi_sharing", &set);
1875 params = __get_wifi_settings_dbus_params("wifi_tether", &set);
1877 g_dbus_proxy_call(proxy, "enable_wifi_tethering", params,
1878 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1879 (GAsyncReadyCallback) __wifi_enabled_cfm_cb,
1880 (gpointer)tethering);
1884 case TETHERING_TYPE_BT:
1885 g_dbus_connection_signal_unsubscribe(connection,
1886 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1888 g_dbus_proxy_call(proxy, "enable_bt_tethering",
1889 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1890 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1891 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1895 case TETHERING_TYPE_P2P: {
1896 _softap_settings_t p2p_set;
1897 memset(&p2p_set, 0, sizeof(_softap_settings_t));
1899 ret = __prepare_wifi_settings(tethering, &p2p_set);
1900 if (ret != TETHERING_ERROR_NONE) {
1901 ERR("p2p settings initialization failed\n");
1902 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1904 return TETHERING_ERROR_OPERATION_FAILED;
1907 g_dbus_proxy_call(proxy, "enable_p2p_tethering",
1908 g_variant_new("(ssi)", p2p_set.ssid, p2p_set.key, p2p_set.channel),
1909 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1910 (GAsyncReadyCallback) __p2p_enabled_cfm_cb, (gpointer)tethering);
1914 case TETHERING_TYPE_ALL: {
1915 GVariant *params = NULL;
1916 _softap_settings_t set;
1917 memset(&set, 0, sizeof(_softap_settings_t));
1919 ret = __prepare_wifi_settings(tethering, &set);
1920 if (ret != TETHERING_ERROR_NONE) {
1921 ERR("softap settings initialization failed\n");
1922 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1923 return TETHERING_ERROR_OPERATION_FAILED;
1926 /* TETHERING_TYPE_USB */
1927 g_dbus_connection_signal_unsubscribe(connection,
1928 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1930 g_dbus_proxy_call(proxy, "enable_usb_tethering",
1931 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1932 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1933 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1935 /* TETHERING_TYPE_WIFI */
1936 g_dbus_connection_signal_unsubscribe(connection,
1937 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1939 if (th->wifi_sharing)
1940 params = __get_wifi_settings_dbus_params("wifi_sharing", &set);
1942 params = __get_wifi_settings_dbus_params("wifi_tether", &set);
1944 g_dbus_proxy_call(proxy, "enable_wifi_tethering", params,
1945 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1946 (GAsyncReadyCallback) __wifi_enabled_cfm_cb,
1947 (gpointer)tethering);
1949 /* TETHERING_TYPE_BT */
1950 g_dbus_connection_signal_unsubscribe(connection,
1951 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1953 g_dbus_proxy_call(proxy, "enable_bt_tethering",
1954 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1955 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1956 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1960 ERR("Unknown type : %d\n", type);
1962 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1965 return TETHERING_ERROR_INVALID_PARAMETER;
1968 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1970 return TETHERING_ERROR_NONE;
1973 API int tethering_ipv6_enable(tethering_h tethering, tethering_type_e type)
1975 DBG("+ type : %d\n", type);
1976 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1977 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1978 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1979 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1981 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1982 "parameter(tethering) is NULL\n");
1984 __tethering_h *th = (__tethering_h *)tethering;
1985 GDBusProxy *proxy = th->client_bus_proxy;
1986 GDBusConnection *connection = th->client_bus;
1989 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
1991 if (__check_precondition(th, type) == FALSE) {
1993 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1994 return TETHERING_ERROR_OPERATION_FAILED;
1998 case TETHERING_TYPE_USB: {
1999 g_dbus_connection_signal_unsubscribe(connection,
2000 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
2002 g_dbus_proxy_call(proxy, "enable_usb_tethering",
2003 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
2004 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2005 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
2009 case TETHERING_TYPE_WIFI: {
2010 GVariant *params = NULL;
2011 _softap_settings_t set;
2012 memset(&set, 0, sizeof(_softap_settings_t));
2014 ret = __prepare_wifi_settings(tethering, &set);
2015 if (ret != TETHERING_ERROR_NONE) {
2016 ERR("softap settings initialization failed\n");
2018 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
2019 return TETHERING_ERROR_OPERATION_FAILED;
2021 g_dbus_connection_signal_unsubscribe(connection,
2022 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
2024 SINFO("ssid %s, key %s, channel %d, mode %s, txpower %d, security %d max_device %d\n",
2025 set.ssid, set.key, set.channel, set.mode, set.txpower, set.sec_type,
2028 char key[TETHERING_WIFI_KEY_MAX_LEN + 1] = "wifi_tether";
2029 if (th->wifi_sharing)
2030 g_strlcpy(key, "wifi_sharing", TETHERING_WIFI_KEY_MAX_LEN + 1);
2032 SINFO("enable_wifi_tethering key: %s", key);
2033 if (th->wifi_sharing)
2034 params = __get_wifi_settings_dbus_params("wifi_sharing", &set);
2036 params = __get_wifi_settings_dbus_params("wifi_tether", &set);
2038 g_dbus_proxy_call(proxy, "enable_wifi_tethering", params,
2039 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2040 (GAsyncReadyCallback) __wifi_enabled_cfm_cb,
2041 (gpointer)tethering);
2045 case TETHERING_TYPE_BT: {
2046 g_dbus_connection_signal_unsubscribe(connection,
2047 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
2049 g_dbus_proxy_call(proxy, "enable_bt_tethering",
2050 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
2051 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2052 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
2058 ERR("Unknown type : %d\n", type);
2060 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
2063 return TETHERING_ERROR_INVALID_PARAMETER;
2067 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
2069 return TETHERING_ERROR_NONE;
2072 API int tethering_ipv6_disable(tethering_h tethering, tethering_type_e type)
2074 DBG("+ type : %d\n", type);
2075 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2076 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2077 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2078 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2080 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2081 "parameter(tethering) is NULL\n");
2083 __tethering_h *th = (__tethering_h *)tethering;
2084 GDBusProxy *proxy = th->client_bus_proxy;
2085 GDBusConnection *connection = th->client_bus;
2088 case TETHERING_TYPE_USB:
2089 g_dbus_connection_signal_unsubscribe(connection,
2090 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
2092 g_dbus_proxy_call(proxy, "disable_usb_tethering",
2093 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
2094 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2095 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
2098 case TETHERING_TYPE_WIFI:
2099 DBG("Disable wifi tethering..");
2100 g_dbus_connection_signal_unsubscribe(connection,
2101 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
2103 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
2104 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
2105 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2106 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
2109 case TETHERING_TYPE_BT:
2110 g_dbus_connection_signal_unsubscribe(connection,
2111 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
2113 g_dbus_proxy_call(proxy, "disable_bt_tethering",
2114 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
2115 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2116 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
2120 ERR("Not supported tethering type [%d]\n", type);
2122 return TETHERING_ERROR_INVALID_PARAMETER;
2125 return TETHERING_ERROR_NONE;
2129 * @brief Disables the tethering, asynchronously.
2131 * @privlevel platform
2132 * @privilege http://tizen.org/privilege/tethering.admin
2133 * @param[in] tethering The handle of tethering
2134 * @param[in] type The type of tethering
2135 * @return 0 on success, otherwise negative error value.
2136 * @retval #TETHERING_ERROR_NONE Successful
2137 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2138 * @post tethering_disabled_cb() will be invoked.
2139 * @see tethering_is_enabled()
2140 * @see tethering_enable()
2142 API int tethering_disable(tethering_h tethering, tethering_type_e type)
2144 INFO("+ type : %d\n", type);
2145 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2146 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2147 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2148 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2150 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2151 "parameter(tethering) is NULL\n");
2153 __tethering_h *th = (__tethering_h *)tethering;
2154 GDBusProxy *proxy = th->client_bus_proxy;
2155 GDBusConnection *connection = th->client_bus;
2158 case TETHERING_TYPE_USB:
2159 g_dbus_connection_signal_unsubscribe(connection,
2160 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
2162 g_dbus_proxy_call(proxy, "disable_usb_tethering",
2163 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
2164 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2165 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
2169 case TETHERING_TYPE_WIFI:
2170 g_dbus_connection_signal_unsubscribe(connection,
2171 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
2173 SINFO("Disable Wi-Fi Tethering !");
2175 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
2176 g_variant_new("(ii)", TETHERING_ADDRESS_FAMILY_IPV4, th->mode_type),
2177 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2178 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
2181 case TETHERING_TYPE_BT:
2183 g_dbus_connection_signal_unsubscribe(connection,
2184 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
2186 g_dbus_proxy_call(proxy, "disable_bt_tethering",
2187 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
2188 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2189 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
2192 case TETHERING_TYPE_P2P:
2193 g_dbus_proxy_call(proxy, "disable_p2p_tethering",
2194 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2195 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
2198 case TETHERING_TYPE_ALL:
2199 g_dbus_connection_signal_unsubscribe(connection,
2200 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
2202 g_dbus_proxy_call(proxy, "disable_usb_tethering",
2203 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
2204 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2205 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
2207 g_dbus_connection_signal_unsubscribe(connection,
2208 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
2210 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
2211 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
2212 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2213 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
2215 g_dbus_connection_signal_unsubscribe(connection,
2216 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
2218 g_dbus_proxy_call(proxy, "disable_bt_tethering",
2219 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
2220 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2221 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
2225 ERR("Not supported tethering type [%d]\n", type);
2227 return TETHERING_ERROR_INVALID_PARAMETER;
2230 return TETHERING_ERROR_NONE;
2235 * @brief Checks whetehr the tethering is enabled or not.
2237 * @privlevel platform
2238 * @privilege http://tizen.org/privilege/tethering.admin
2239 * @param[in] tethering The handle of tethering
2240 * @param[in] type The type of tethering
2241 * @return @c true if tethering is enabled, \n @c false if tethering is disabled.
2243 API bool tethering_is_enabled(tethering_h tethering, tethering_type_e type)
2245 INFO("+ type : %d\n", type);
2247 int vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_NONE;
2249 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2251 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &is_on) != 0)
2255 case TETHERING_TYPE_USB:
2256 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_USB;
2259 case TETHERING_TYPE_WIFI:
2260 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI;
2263 case TETHERING_TYPE_BT:
2264 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_BT;
2267 case TETHERING_TYPE_P2P:
2268 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_P2P;
2272 ERR("Not supported type : %d\n", type);
2275 INFO("- enabled: %s\n", (is_on & vconf_type) ? "true" : "false");
2276 return is_on & vconf_type ? true : false;
2281 * @brief Gets the MAC address of local device as "FC:A1:3E:D6:B1:B1".
2283 * @privlevel platform
2284 * @privilege http://tizen.org/privilege/tethering.admin
2285 * @remarks @a mac_address must be released with free() by you.
2286 * @param[in] tethering The handle of tethering
2287 * @param[in] type The type of tethering
2288 * @param[out] mac_address The MAC address
2289 * @return 0 on success, otherwise a negative error value.
2290 * @retval #TETHERING_ERROR_NONE Successful
2291 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2292 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2293 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2294 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2295 * @pre tethering must be enabled.
2296 * @see tethering_is_enabled()
2297 * @see tethering_enable()
2299 API int tethering_get_mac_address(tethering_h tethering, tethering_type_e type, char **mac_address)
2301 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2302 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2303 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2304 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2306 _retvm_if(tethering_is_enabled(tethering, type) == false,
2307 TETHERING_ERROR_NOT_ENABLED,
2308 "tethering type[%d] is not enabled\n", type);
2309 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2310 "parameter(tethering) is NULL\n");
2311 _retvm_if(mac_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2312 "parameter(mac_address) is NULL\n");
2316 char *macbuf = NULL;
2318 _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
2319 TETHERING_ERROR_OPERATION_FAILED,
2320 "getting interface name is failed\n");
2322 s = socket(AF_INET, SOCK_DGRAM, 0);
2323 _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
2324 "getting socket is failed\n");
2325 if (ioctl(s, SIOCGIFHWADDR, &ifr) < 0) {
2326 ERR("getting mac is failed\n");
2328 return TETHERING_ERROR_OPERATION_FAILED;
2332 macbuf = (char *)malloc(TETHERING_STR_INFO_LEN);
2333 _retvm_if(macbuf == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2334 "Not enough memory\n");
2335 snprintf(macbuf, TETHERING_STR_INFO_LEN, "%02X:%02X:%02X:%02X:%02X:%02X",
2336 (unsigned char)ifr.ifr_hwaddr.sa_data[0],
2337 (unsigned char)ifr.ifr_hwaddr.sa_data[1],
2338 (unsigned char)ifr.ifr_hwaddr.sa_data[2],
2339 (unsigned char)ifr.ifr_hwaddr.sa_data[3],
2340 (unsigned char)ifr.ifr_hwaddr.sa_data[4],
2341 (unsigned char)ifr.ifr_hwaddr.sa_data[5]);
2343 *mac_address = macbuf;
2345 return TETHERING_ERROR_NONE;
2350 * @brief Gets the name of network interface. For example, usb0.
2352 * @privlevel platform
2353 * @privilege http://tizen.org/privilege/tethering.admin
2354 * @remarks @a interface_name must be released with free() by you.
2355 * @param[in] tethering The handle of tethering
2356 * @param[in] type The type of tethering
2357 * @param[out] interface_name The name of network interface
2358 * @return 0 on success, otherwise negative error value.
2359 * @retval #TETHERING_ERROR_NONE Successful
2360 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2361 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2362 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2363 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2364 * @pre tethering must be enabled.
2365 * @see tethering_is_enabled()
2366 * @see tethering_enable()
2368 API int tethering_get_network_interface_name(tethering_h tethering, tethering_type_e type, char **interface_name)
2370 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2371 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2372 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2373 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2375 _retvm_if(tethering_is_enabled(tethering, type) == false,
2376 TETHERING_ERROR_NOT_ENABLED,
2377 "tethering type[%d] is not enabled\n", type);
2378 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2379 "parameter(tethering) is NULL\n");
2380 _retvm_if(interface_name == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2381 "parameter(interface_name) is NULL\n");
2383 char intf[TETHERING_STR_INFO_LEN] = {0, };
2385 _retvm_if(!__get_intf_name(type, intf, sizeof(intf)),
2386 TETHERING_ERROR_OPERATION_FAILED,
2387 "getting interface name is failed\n");
2388 *interface_name = strdup(intf);
2389 _retvm_if(*interface_name == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2390 "Not enough memory\n");
2392 return TETHERING_ERROR_NONE;
2397 * @brief Gets the local IP address.
2399 * @privlevel platform
2400 * @privilege http://tizen.org/privilege/tethering.admin
2401 * @remarks @a ip_address must be released with free() by you.
2402 * @param[in] tethering The handle of tethering
2403 * @param[in] type The type of tethering
2404 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2405 * @param[out] ip_address The local IP address
2406 * @return 0 on success, otherwise negative error value.
2407 * @retval #TETHERING_ERROR_NONE Successful
2408 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2409 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2410 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2411 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2412 * @pre tethering must be enabled.
2413 * @see tethering_is_enabled()
2414 * @see tethering_enable()
2416 API int tethering_get_ip_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **ip_address)
2418 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2419 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2420 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2421 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2423 _retvm_if(tethering_is_enabled(tethering, type) == false,
2424 TETHERING_ERROR_NOT_ENABLED,
2425 "tethering type[%d] is not enabled\n", type);
2426 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2427 "parameter(tethering) is NULL\n");
2428 _retvm_if(ip_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2429 "parameter(ip_address) is NULL\n");
2435 _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
2436 TETHERING_ERROR_OPERATION_FAILED,
2437 "getting interface name is failed\n");
2439 s = socket(AF_INET, SOCK_DGRAM, 0);
2440 _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
2441 "getting socket is failed\n");
2442 if (ioctl(s, SIOCGIFADDR, &ifr) < 0) {
2443 ERR("ioctl is failed\n");
2445 return TETHERING_ERROR_OPERATION_FAILED;
2449 ipbuf = inet_ntoa(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr);
2450 *ip_address = strdup(ipbuf);
2451 _retvm_if(*ip_address == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2452 "Not enough memory\n");
2454 if (type == TETHERING_TYPE_WIFI) {
2455 __tethering_h *th = (__tethering_h *)tethering;
2456 g_strlcpy(th->ip_address, *ip_address, sizeof(th->ip_address));
2459 return TETHERING_ERROR_NONE;
2463 * @brief Sets the local IP address.
2465 * @privlevel platform
2466 * @privilege %http://tizen.org/privilege/tethering.admin
2467 * @remarks API is only available for TETHERING_TYPE_WIFI.
2468 * @param[in] tethering The tethering handle
2469 * @param[in] type The tethering type
2470 * @param[in] address_family The address family of IP address (currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported)
2471 * @param[out] ip_address The local IP address
2472 * @return 0 on success, otherwise negative error value
2473 * @retval #TETHERING_ERROR_NONE Successful
2474 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2475 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2476 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2477 * @see tethering_enable()
2479 int tethering_set_ip_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, const char *ip_address)
2481 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2482 if (type == TETHERING_TYPE_WIFI)
2483 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2485 return TETHERING_ERROR_INVALID_PARAMETER;
2487 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2488 "parameter(tethering) is NULL\n");
2489 _retvm_if(ip_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2490 "parameter(ip_address) is NULL\n");
2492 __tethering_h *th = (__tethering_h *)tethering;
2495 if (address_family == TETHERING_ADDRESS_FAMILY_IPV4) {
2496 ip_len = strlen(ip_address);
2497 if (ip_len < TETHERING_IPV4_ADDRESS_MIN_LEN ||
2498 ip_len > TETHERING_IPV4_ADDRESS_MAX_LEN) {
2499 ERR("parameter(ip_address) is too short or long\n");
2500 return TETHERING_ERROR_INVALID_PARAMETER;
2502 g_strlcpy(th->ip_address, ip_address, sizeof(th->ip_address));
2504 /* IPv6 is not supported yet. */
2505 ERR("IPv6 address is not supported yet\n");
2506 return TETHERING_ERROR_OPERATION_FAILED;
2509 return TETHERING_ERROR_NONE;
2514 * @brief Gets the Gateway address.
2516 * @privlevel platform
2517 * @privilege http://tizen.org/privilege/tethering.admin
2518 * @remarks @a gateway_address must be released with free() by you.
2519 * @param[in] tethering The handle of tethering
2520 * @param[in] type The type of tethering
2521 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2522 * @param[out] gateway_address The local IP address
2523 * @return 0 on success, otherwise negative error value.
2524 * @retval #TETHERING_ERROR_NONE Successful
2525 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2526 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2527 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2528 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2529 * @pre tethering must be enabled.
2530 * @see tethering_is_enabled()
2531 * @see tethering_enable()
2533 API int tethering_get_gateway_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **gateway_address)
2535 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2536 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2537 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2538 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2540 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2541 "parameter(tethering) is NULL\n");
2542 _retvm_if(gateway_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2543 "parameter(gateway_address) is NULL\n");
2544 _retvm_if(tethering_is_enabled(tethering, type) == false,
2545 TETHERING_ERROR_NOT_ENABLED,
2546 "tethering type[%d] is not enabled\n", type);
2548 __tethering_h *th = (__tethering_h *)tethering;
2550 if (type == TETHERING_TYPE_WIFI && strlen(th->ip_address)) {
2551 *gateway_address = strdup(th->ip_address);
2554 char gateway_buf[TETHERING_STR_INFO_LEN] = {0, };
2556 _retvm_if(!__get_gateway_addr(type, gateway_buf,
2557 sizeof(gateway_buf)),
2558 TETHERING_ERROR_OPERATION_FAILED,
2559 "getting gateway address is failed\n");
2561 *gateway_address = strdup(gateway_buf);
2564 return TETHERING_ERROR_NONE;
2569 * @brief Gets the Subnet Mask.
2571 * @privlevel platform
2572 * @privilege http://tizen.org/privilege/tethering.admin
2573 * @remarks @a subnet_mask must be released with free() by you.
2574 * @param[in] tethering The handle of tethering
2575 * @param[in] type The type of tethering
2576 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2577 * @param[out] subnet_mask The local IP address
2578 * @return 0 on success, otherwise negative error value.
2579 * @retval #TETHERING_ERROR_NONE Successful
2580 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2581 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2582 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2583 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2584 * @pre tethering must be enabled.
2585 * @see tethering_is_enabled()
2586 * @see tethering_enable()
2588 API int tethering_get_subnet_mask(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **subnet_mask)
2590 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2591 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2592 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2593 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2595 _retvm_if(tethering_is_enabled(tethering, type) == false,
2596 TETHERING_ERROR_NOT_ENABLED,
2597 "tethering is not enabled\n");
2598 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2599 "parameter(tethering) is NULL\n");
2600 _retvm_if(subnet_mask == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2601 "parameter(subnet_mask) is NULL\n");
2603 *subnet_mask = strdup(TETHERING_SUBNET_MASK);
2604 _retvm_if(*subnet_mask == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2605 "Not enough memory\n");
2607 return TETHERING_ERROR_NONE;
2612 * @brief Gets the data usage.
2614 * @privlevel platform
2615 * @privilege http://tizen.org/privilege/tethering.admin
2616 * @param[in] tethering The handle of tethering
2617 * @param[out] usage The data usage
2618 * @return 0 on success, otherwise negative error value.
2619 * @retval #TETHERING_ERROR_NONE Successful
2620 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2621 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2622 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2623 * @pre tethering must be enabled.
2624 * @see tethering_is_enabled()
2625 * @see tethering_enable()
2627 API int tethering_get_data_usage(tethering_h tethering, tethering_data_usage_cb callback, void *user_data)
2629 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2631 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2632 "parameter(tethering) is NULL\n");
2633 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2634 "parameter(callback) is NULL\n");
2635 _retvm_if(__any_tethering_is_enabled(tethering) == false,
2636 TETHERING_ERROR_NOT_ENABLED,
2637 "tethering is not enabled\n");
2639 __tethering_h *th = (__tethering_h *)tethering;
2640 GDBusProxy *proxy = th->client_bus_proxy;
2642 th->data_usage_cb = callback;
2643 th->data_usage_user_data = user_data;
2645 g_dbus_proxy_call(proxy, "get_data_packet_usage",
2646 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2647 (GAsyncReadyCallback) __get_data_usage_cb, (gpointer)tethering);
2649 return TETHERING_ERROR_NONE;
2654 * @brief Gets the client which is connected by tethering "type".
2656 * @privlevel platform
2657 * @privilege http://tizen.org/privilege/tethering.admin
2658 * @param[in] tethering The handle of tethering
2659 * @param[in] type The type of tethering
2660 * @param[in] callback The callback function to invoke
2661 * @param[in] user_data The user data to be passed to the callback function
2662 * @retval #TETHERING_ERROR_NONE Successful
2663 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2664 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2665 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2666 * @pre tethering must be enabled.
2667 * @see tethering_is_enabled()
2668 * @see tethering_enable()
2671 API int tethering_is_dualband_supported(tethering_h tethering, tethering_type_e type, bool *supported)
2673 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2674 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2676 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2677 "parameter(tethering) is NULL\n");
2679 __tethering_h *th = (__tethering_h *)tethering;
2680 gchar *if_name = NULL;
2681 gboolean Is2GBandSupported = FALSE;
2682 gboolean Is5GBandSupported = FALSE;
2683 GError *error = NULL;
2684 GVariant *result = NULL;
2685 GVariantIter *outer_iter = NULL;
2686 GVariantIter *inner_iter = NULL;
2687 GVariant *station = NULL;
2688 GVariant *value = NULL;
2693 __reset_dualband_support();
2694 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "get_wifi_interfaces",
2695 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
2698 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
2699 g_error_free(error);
2700 return TETHERING_ERROR_OPERATION_FAILED;
2702 g_variant_get(result, "(a(a{sv}))", &outer_iter);
2703 while (g_variant_iter_loop(outer_iter, "(@a{sv})", &station)) {
2704 g_variant_get(station, "a{sv}", &inner_iter);
2705 while (g_variant_iter_loop(inner_iter, "{sv}", &key, &value)) {
2706 if (g_strcmp0(key, "IfName") == 0) {
2707 g_variant_get(value, "s", &if_name);
2708 SDBG("Interface Name is %s\n", if_name);
2709 } else if (g_strcmp0(key, "Is2GBandSupported") == 0) {
2710 Is2GBandSupported = g_variant_get_boolean(value);
2711 SDBG("Is2GBandSupported is %d\n", Is2GBandSupported);
2712 if (Is2GBandSupported)
2713 __set_dualband_support(DUAL_BAND_2G);
2714 } else if (g_strcmp0(key, "Is5GBandSupported") == 0) {
2715 Is5GBandSupported = g_variant_get_boolean(value);
2716 SDBG("Is5GBandSupported is %d\n", Is5GBandSupported);
2717 if (Is5GBandSupported)
2718 __set_dualband_support(DUAL_BAND_5G);
2720 ERR("Key %s not required\n", key);
2725 g_variant_iter_free(inner_iter);
2728 __set_dualband_support(DUAL_BAND_MIN_INTERFACE);
2729 *supported = __is_dualband_support();
2730 DBG("count:%d is dualband suppport: %d", count, *supported);
2731 g_variant_iter_free(outer_iter);
2732 g_variant_unref(result);
2734 return TETHERING_ERROR_NONE;
2736 API int tethering_foreach_connected_clients(tethering_h tethering, tethering_type_e type, tethering_connected_client_cb callback, void *user_data)
2738 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2739 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2740 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2741 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2743 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2744 "parameter(tethering) is NULL\n");
2745 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2746 "parameter(callback) is NULL\n");
2747 _retvm_if(__any_tethering_is_enabled(tethering) == false,
2748 TETHERING_ERROR_NOT_ENABLED,
2749 "tethering is not enabled\n");
2751 mobile_ap_type_e interface;
2752 tethering_band_e band;
2753 __tethering_h *th = (__tethering_h *)tethering;
2754 __tethering_client_h client = {0, };
2757 gchar *hostname = NULL;
2758 guint timestamp = 0;
2759 GError *error = NULL;
2760 GVariant *result = NULL;
2761 GVariantIter *outer_iter = NULL;
2762 GVariantIter *inner_iter = NULL;
2763 GVariant *station = NULL;
2764 GVariant *value = NULL;
2767 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "get_station_info",
2768 NULL, G_DBUS_CALL_FLAGS_NONE,
2769 -1, th->cancellable, &error);
2772 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
2773 g_error_free(error);
2774 return TETHERING_ERROR_OPERATION_FAILED;
2777 g_variant_get(result, "(a(a{sv}))", &outer_iter);
2778 while (g_variant_iter_loop(outer_iter, "(@a{sv})", &station)) {
2779 g_variant_get(station, "a{sv}", &inner_iter);
2780 while (g_variant_iter_loop(inner_iter, "{sv}", &key, &value)) {
2781 if (g_strcmp0(key, "Type") == 0) {
2782 interface = g_variant_get_int32(value);
2783 tethering_type_e converted_type = __convert_to_tethering_type(interface);
2784 if (converted_type == TETHERING_TYPE_MAX) {
2785 ERR("Invalid interface\n");
2787 g_variant_unref(value);
2790 client.interface = converted_type;
2793 DBG("interface is %d\n", client.interface);
2794 if (client.interface != type && (TETHERING_TYPE_ALL != type)) {
2796 g_variant_unref(value);
2799 } else if (g_strcmp0(key, "IP") == 0) {
2800 g_variant_get(value, "s", &ip);
2801 SDBG("ip is %s\n", ip);
2802 g_strlcpy(client.ip, ip, sizeof(client.ip));
2803 } else if (g_strcmp0(key, "MAC") == 0) {
2804 g_variant_get(value, "s", &mac);
2805 SDBG("mac is %s\n", mac);
2806 g_strlcpy(client.mac, mac, sizeof(client.mac));
2807 } else if (g_strcmp0(key, "Name") == 0) {
2808 g_variant_get(value, "s", &hostname);
2809 SDBG("hsotname is %s\n", hostname);
2811 client.hostname = g_strdup(hostname);
2812 } else if (g_strcmp0(key, "Time") == 0) {
2813 timestamp = g_variant_get_int32(value);
2814 DBG("timestamp is %d\n", timestamp);
2815 client.tm = (time_t)timestamp;
2816 } else if (g_strcmp0(key, "Band") == 0) {
2817 band = g_variant_get_int32(value);
2818 client.band = (!band) ? TETHERING_WIFI_BAND_2G : TETHERING_WIFI_BAND_5G;
2819 SDBG("band type %d\n", band);
2821 ERR("Key %s not required\n", key);
2832 g_variant_iter_free(inner_iter);
2833 if ((th->mode_type == 0 || th->mode_type == 1) && client.band != TETHERING_WIFI_BAND_2G) //if band is not for 2g continue
2835 if ((th->mode_type == 2 || th->mode_type == 3) && client.band != TETHERING_WIFI_BAND_5G) //if band is not for 5g continue
2837 SDBG("mode_type: %d and client.band: %d ", th->mode_type, client.band);
2838 if (callback((tethering_client_h)&client, user_data) == false) {
2839 DBG("iteration is stopped\n");
2840 g_free(client.hostname);
2841 client.hostname = NULL;
2842 g_variant_iter_free(outer_iter);
2843 g_variant_unref(result);
2845 return TETHERING_ERROR_OPERATION_FAILED;
2847 g_free(client.hostname);
2848 client.hostname = NULL;
2850 g_variant_iter_free(outer_iter);
2851 g_variant_unref(result);
2853 return TETHERING_ERROR_NONE;
2858 * @brief Registers the callback function called when tethering is enabled.
2860 * @privlevel platform
2861 * @privilege http://tizen.org/privilege/tethering.admin
2862 * @param[in] tethering The handle of tethering
2863 * @param[in] type The type of tethering
2864 * @param[in] callback The callback function to invoke
2865 * @param[in] user_data The user data to be passed to the callback function
2866 * @retval #TETHERING_ERROR_NONE Successful
2867 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2868 * @see tethering_unset_enabled_cb()
2870 API int tethering_set_enabled_cb(tethering_h tethering, tethering_type_e type, tethering_enabled_cb callback, void *user_data)
2872 INFO("+ type: %d\n", type);
2873 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2874 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2875 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2876 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2878 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2879 "parameter(tethering) is NULL\n");
2880 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2881 "parameter(callback) is NULL\n");
2883 __tethering_h *th = (__tethering_h *)tethering;
2884 tethering_type_e ti;
2886 if (type != TETHERING_TYPE_ALL) {
2887 th->enabled_cb[type] = callback;
2888 th->enabled_user_data[type] = user_data;
2890 return TETHERING_ERROR_NONE;
2893 /* TETHERING_TYPE_ALL */
2894 for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
2895 th->enabled_cb[ti] = callback;
2896 th->enabled_user_data[ti] = user_data;
2900 return TETHERING_ERROR_NONE;
2905 * @brief Unregisters the callback function called when tethering is disabled.
2907 * @privlevel platform
2908 * @privilege http://tizen.org/privilege/tethering.admin
2909 * @param[in] tethering The handle of tethering
2910 * @param[in] type The type of tethering
2911 * @retval #TETHERING_ERROR_NONE Successful
2912 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2913 * @see tethering_set_enabled_cb()
2915 API int tethering_unset_enabled_cb(tethering_h tethering, tethering_type_e type)
2917 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2918 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2919 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2920 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2922 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2923 "parameter(tethering) is NULL\n");
2925 __tethering_h *th = (__tethering_h *)tethering;
2926 tethering_type_e ti;
2928 if (type != TETHERING_TYPE_ALL) {
2929 th->enabled_cb[type] = NULL;
2930 th->enabled_user_data[type] = NULL;
2932 return TETHERING_ERROR_NONE;
2935 /* TETHERING_TYPE_ALL */
2936 for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
2937 th->enabled_cb[ti] = NULL;
2938 th->enabled_user_data[ti] = NULL;
2941 return TETHERING_ERROR_NONE;
2946 * @brief Registers the callback function called when tethering is disabled.
2948 * @privlevel platform
2949 * @privilege http://tizen.org/privilege/tethering.admin
2950 * @param[in] tethering The handle of tethering
2951 * @param[in] type The type of tethering
2952 * @param[in] callback The callback function to invoke
2953 * @param[in] user_data The user data to be passed to the callback function
2954 * @retval #TETHERING_ERROR_NONE Successful
2955 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2956 * @see tethering_unset_disabled_cb()
2958 API int tethering_set_disabled_cb(tethering_h tethering, tethering_type_e type, tethering_disabled_cb callback, void *user_data)
2960 INFO("+ type: %d\n", type);
2961 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2962 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2963 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2964 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2966 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2967 "parameter(tethering) is NULL\n");
2968 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2969 "parameter(callback) is NULL\n");
2971 __tethering_h *th = (__tethering_h *)tethering;
2972 tethering_type_e ti;
2974 if (type != TETHERING_TYPE_ALL) {
2975 th->disabled_cb[type] = callback;
2976 th->disabled_user_data[type] = user_data;
2978 return TETHERING_ERROR_NONE;
2981 /* TETHERING_TYPE_ALL */
2982 for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
2983 th->disabled_cb[ti] = callback;
2984 th->disabled_user_data[ti] = user_data;
2987 return TETHERING_ERROR_NONE;
2992 * @brief Unregisters the callback function called when tethering is disabled.
2994 * @privlevel platform
2995 * @privilege http://tizen.org/privilege/tethering.admin
2996 * @param[in] tethering The handle of tethering
2997 * @param[in] type The type of tethering
2998 * @retval #TETHERING_ERROR_NONE Successful
2999 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3000 * @see tethering_set_disabled_cb()
3002 API int tethering_unset_disabled_cb(tethering_h tethering, tethering_type_e type)
3004 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3005 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
3006 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3007 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
3009 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3010 "parameter(tethering) is NULL\n");
3012 __tethering_h *th = (__tethering_h *)tethering;
3013 tethering_type_e ti;
3015 if (type != TETHERING_TYPE_ALL) {
3016 th->disabled_cb[type] = NULL;
3017 th->disabled_user_data[type] = NULL;
3019 return TETHERING_ERROR_NONE;
3022 /* TETHERING_TYPE_ALL */
3023 for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
3024 th->disabled_cb[ti] = NULL;
3025 th->disabled_user_data[ti] = NULL;
3028 return TETHERING_ERROR_NONE;
3033 * @brief Registers the callback function called when the state of connection is changed.
3035 * @privlevel platform
3036 * @privilege http://tizen.org/privilege/tethering.admin
3037 * @param[in] tethering The handle of tethering
3038 * @param[in] type The type of tethering
3039 * @param[in] callback The callback function to invoke
3040 * @param[in] user_data The user data to be passed to the callback function
3041 * @retval #TETHERING_ERROR_NONE Successful
3042 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3043 * @see tethering_unset_connection_state_changed_cb_cb()
3045 API int tethering_set_connection_state_changed_cb(tethering_h tethering, tethering_type_e type, tethering_connection_state_changed_cb callback, void *user_data)
3047 INFO("+ type: %d\n", type);
3048 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3049 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
3050 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3051 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
3053 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3054 "parameter(tethering) is NULL\n");
3055 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3056 "parameter(callback) is NULL\n");
3058 __tethering_h *th = (__tethering_h *)tethering;
3059 tethering_type_e ti;
3061 if (type != TETHERING_TYPE_ALL) {
3062 th->changed_cb[type] = callback;
3063 th->changed_user_data[type] = user_data;
3065 return TETHERING_ERROR_NONE;
3068 /* TETHERING_TYPE_ALL */
3069 for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
3070 th->changed_cb[ti] = callback;
3071 th->changed_user_data[ti] = user_data;
3074 return TETHERING_ERROR_NONE;
3079 * @brief Unregisters the callback function called when the state of connection is changed.
3081 * @privlevel platform
3082 * @privilege http://tizen.org/privilege/tethering.admin
3083 * @param[in] tethering The handle of tethering
3084 * @param[in] type The type of tethering
3085 * @retval #TETHERING_ERROR_NONE Successful
3086 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3087 * @see tethering_set_connection_state_changed_cb()
3089 API int tethering_unset_connection_state_changed_cb(tethering_h tethering, tethering_type_e type)
3091 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3092 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
3093 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3094 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
3096 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3097 "parameter(tethering) is NULL\n");
3099 __tethering_h *th = (__tethering_h *)tethering;
3100 tethering_type_e ti;
3102 if (type != TETHERING_TYPE_ALL) {
3103 th->changed_cb[type] = NULL;
3104 th->changed_user_data[type] = NULL;
3106 return TETHERING_ERROR_NONE;
3109 /* TETHERING_TYPE_ALL */
3110 for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
3111 th->changed_cb[ti] = NULL;
3112 th->changed_user_data[ti] = NULL;
3115 return TETHERING_ERROR_NONE;
3120 * @brief Registers the callback function called when the security type of Wi-Fi tethering is changed.
3122 * @privlevel platform
3123 * @privilege http://tizen.org/privilege/tethering.admin
3124 * @param[in] tethering The handle of tethering
3125 * @param[in] callback The callback function to invoke
3126 * @param[in] user_data The user data to be passed to the callback function
3127 * @retval #TETHERING_ERROR_NONE Successful
3128 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3129 * @see tethering_wifi_unset_security_type_changed_cb()
3131 API int tethering_wifi_set_security_type_changed_cb(tethering_h tethering, tethering_wifi_security_type_changed_cb callback, void *user_data)
3133 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3134 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3136 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3137 "parameter(tethering) is NULL\n");
3138 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3139 "parameter(callback) is NULL\n");
3141 __tethering_h *th = (__tethering_h *)tethering;
3143 th->security_type_changed_cb = callback;
3144 th->security_type_user_data = user_data;
3146 return TETHERING_ERROR_NONE;
3152 * @brief Unregisters the callback function called when the security type of Wi-Fi tethering is changed.
3154 * @privlevel platform
3155 * @privilege http://tizen.org/privilege/tethering.admin
3156 * @param[in] tethering The handle of tethering
3157 * @param[in] type The type of tethering
3158 * @retval #TETHERING_ERROR_NONE Successful
3159 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3160 * @see tethering_wifi_set_security_type_changed_cb()
3162 API int tethering_wifi_unset_security_type_changed_cb(tethering_h tethering)
3164 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3165 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3167 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3168 "parameter(tethering) is NULL\n");
3170 __tethering_h *th = (__tethering_h *)tethering;
3172 th->security_type_changed_cb = NULL;
3173 th->security_type_user_data = NULL;
3175 return TETHERING_ERROR_NONE;
3180 * @brief Registers the callback function called when the visibility of SSID is changed.
3182 * @privlevel platform
3183 * @privilege http://tizen.org/privilege/tethering.admin
3184 * @param[in] tethering The handle of tethering
3185 * @param[in] callback The callback function to invoke
3186 * @param[in] user_data The user data to be passed to the callback function
3187 * @retval #TETHERING_ERROR_NONE Successful
3188 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3189 * @see tethering_wifi_unset_ssid_visibility_changed_cb_cb()
3191 API int tethering_wifi_set_ssid_visibility_changed_cb(tethering_h tethering, tethering_wifi_ssid_visibility_changed_cb callback, void *user_data)
3193 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3194 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3196 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3197 "parameter(tethering) is NULL\n");
3198 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3199 "parameter(callback) is NULL\n");
3201 __tethering_h *th = (__tethering_h *)tethering;
3203 th->ssid_visibility_changed_cb = callback;
3204 th->ssid_visibility_user_data = user_data;
3206 return TETHERING_ERROR_NONE;
3211 * @brief Unregisters the callback function called when the visibility of SSID is changed.
3213 * @privlevel platform
3214 * @privilege http://tizen.org/privilege/tethering.admin
3215 * @param[in] tethering The handle of tethering
3216 * @retval #TETHERING_ERROR_NONE Successful
3217 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3218 * @see tethering_wifi_set_ssid_visibility_changed_cb()
3220 API int tethering_wifi_unset_ssid_visibility_changed_cb(tethering_h tethering)
3222 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3223 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3225 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3226 "parameter(tethering) is NULL\n");
3228 __tethering_h *th = (__tethering_h *)tethering;
3230 th->ssid_visibility_changed_cb = NULL;
3231 th->ssid_visibility_user_data = NULL;
3233 return TETHERING_ERROR_NONE;
3238 * @brief Registers the callback function called when the passphrase of Wi-Fi tethering is changed.
3240 * @privlevel platform
3241 * @privilege http://tizen.org/privilege/tethering.admin
3242 * @param[in] tethering The handle of tethering
3243 * @param[in] callback The callback function to invoke
3244 * @param[in] user_data The user data to be passed to the callback function
3245 * @retval #TETHERING_ERROR_NONE Successful
3246 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3247 * @see tethering_wifi_unset_passphrase_changed_cb()
3249 API int tethering_wifi_set_passphrase_changed_cb(tethering_h tethering, tethering_wifi_passphrase_changed_cb callback, void *user_data)
3251 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3252 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3254 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3255 "parameter(tethering) is NULL\n");
3256 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3257 "parameter(callback) is NULL\n");
3259 __tethering_h *th = (__tethering_h *)tethering;
3261 th->passphrase_changed_cb = callback;
3262 th->passphrase_user_data = user_data;
3264 return TETHERING_ERROR_NONE;
3269 * @brief Unregisters the callback function called when the passphrase of Wi-Fi tethering is changed.
3271 * @privlevel platform
3272 * @privilege http://tizen.org/privilege/tethering.admin
3273 * @param[in] tethering The handle of tethering
3274 * @retval #TETHERING_ERROR_NONE Successful
3275 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3276 * @see tethering_wifi_set_passphrase_changed_cb()
3278 API int tethering_wifi_unset_passphrase_changed_cb(tethering_h tethering)
3280 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3281 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3283 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3284 "parameter(tethering) is NULL\n");
3286 __tethering_h *th = (__tethering_h *)tethering;
3288 th->passphrase_changed_cb = NULL;
3289 th->passphrase_user_data = NULL;
3291 return TETHERING_ERROR_NONE;
3296 * @brief Sets the security type of Wi-Fi tethering.
3298 * @privlevel platform
3299 * @privilege http://tizen.org/privilege/tethering.admin
3300 * @remarks This change is applied next time Wi-Fi tethering is enabled
3301 * @param[in] tethering The handle of tethering
3302 * @param[in] type The security type
3303 * @return 0 on success, otherwise negative error value.
3304 * @retval #TETHERING_ERROR_NONE Successful
3305 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3306 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3307 * @see tethering_wifi_get_security_type()
3309 API int tethering_wifi_set_security_type(tethering_h tethering, tethering_wifi_security_type_e type)
3311 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3312 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3314 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3315 "parameter(tethering) is NULL\n");
3317 __tethering_h *th = (__tethering_h *)tethering;
3318 tethering_error_e ret = TETHERING_ERROR_NONE;
3319 char *sec_str = NULL;
3321 ret = __set_security_type(type);
3322 if (ret == TETHERING_ERROR_NONE) {
3324 case TETHERING_WIFI_SECURITY_TYPE_NONE:
3325 sec_str = TETHERING_WIFI_SECURITY_TYPE_OPEN_STR;
3327 case TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK:
3328 sec_str = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR;
3330 case TETHERING_WIFI_SECURITY_TYPE_WPS:
3331 sec_str = TETHERING_WIFI_SECURITY_TYPE_WPS_STR;
3333 case TETHERING_WIFI_SECURITY_TYPE_SAE:
3334 sec_str = TETHERING_WIFI_SECURITY_TYPE_SAE_STR;
3338 __send_dbus_signal(th->client_bus,
3339 SIGNAL_NAME_SECURITY_TYPE_CHANGED, sec_str);
3346 * @brief Gets the security type of Wi-Fi tethering.
3348 * @privlevel platform
3349 * @privilege http://tizen.org/privilege/tethering.admin
3350 * @param[in] tethering The handle of tethering
3351 * @param[out] type The security type
3352 * @return 0 on success, otherwise negative error value.
3353 * @retval #TETHERING_ERROR_NONE Successful
3354 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3355 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3356 * @see tethering_wifi_set_security_type()
3358 API int tethering_wifi_get_security_type(tethering_h tethering, tethering_wifi_security_type_e *type)
3360 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3361 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3363 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3364 "parameter(tethering) is NULL\n");
3365 _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3366 "parameter(type) is NULL\n");
3368 return __get_security_type(type);
3373 * @brief Sets the SSID (service set identifier).
3375 * @privlevel platform
3376 * @privilege http://tizen.org/privilege/tethering.admin
3377 * @details If SSID is not set, Device name is used as SSID
3378 * @remarks This change is applied next time Wi-Fi tethering is enabled with same @a tethering handle
3379 * @param[in] tethering The handle of tethering
3380 * @param[out] ssid The SSID
3381 * @return 0 on success, otherwise negative error value.
3382 * @retval #TETHERING_ERROR_NONE Successful
3383 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3384 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
3386 API int tethering_wifi_set_ssid(tethering_h tethering, const char *ssid)
3388 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3389 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3391 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3392 "parameter(tethering) is NULL\n");
3393 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3394 "parameter(ssid) is NULL\n");
3396 __tethering_h *th = (__tethering_h *)tethering;
3397 char *p_ssid = NULL;
3400 ssid_len = strlen(ssid);
3401 if (ssid_len > TETHERING_WIFI_SSID_MAX_LEN) {
3402 ERR("parameter(ssid) is too long");
3403 return TETHERING_ERROR_INVALID_PARAMETER;
3406 p_ssid = strdup(ssid);
3407 _retvm_if(p_ssid == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
3408 "strdup is failed\n");
3411 GDBusProxy *proxy = th->client_bus_proxy;
3412 GVariant *parameters;
3413 GError *error = NULL;
3414 tethering_error_e ret = TETHERING_ERROR_NONE;
3416 parameters = g_dbus_proxy_call_sync(proxy, "set_wifi_tethering_ssid",
3417 g_variant_new("(s)", ssid), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3420 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3422 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3423 ret = TETHERING_ERROR_PERMISSION_DENIED;
3425 ret = TETHERING_ERROR_OPERATION_FAILED;
3427 g_error_free(error);
3432 if (parameters != NULL) {
3433 g_variant_get(parameters, "(u)", &ret);
3434 g_variant_unref(parameters);
3437 SINFO("set tethering ssid : %s", ssid);
3438 #endif /* TIZEN_TV_EXT */
3444 return TETHERING_ERROR_NONE;
3449 * @brief Gets the SSID (service set identifier).
3451 * @privlevel platform
3452 * @privilege http://tizen.org/privilege/tethering.admin
3453 * @remarks @a ssid must be released with free() by you.
3454 * @param[in] tethering The handle of tethering
3455 * @param[out] ssid The SSID
3456 * @return 0 on success, otherwise negative error value.
3457 * @retval #TETHERING_ERROR_NONE Successful
3458 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3459 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
3460 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3462 API int tethering_wifi_get_ssid(tethering_h tethering, char **ssid)
3464 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3465 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3467 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3468 "parameter(tethering) is NULL\n");
3469 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3470 "parameter(ssid) is NULL\n");
3473 __tethering_h *th = (__tethering_h *)tethering;
3474 char val[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
3477 if (__get_ssid_from_vconf(VCONFKEY_WIFI_SSID,
3478 val, sizeof(val)) == true) {
3479 *ssid = strdup(val);
3480 SINFO("get tethering ssid : %s", *ssid);
3481 return TETHERING_ERROR_NONE;
3483 #endif /* TIZEN_TV_EXT */
3485 if (!tethering_is_enabled(NULL, TETHERING_TYPE_WIFI)) {
3486 if (th->ssid != NULL) {
3487 DBG("Private SSID is set\n");
3488 *ssid = strdup(th->ssid);
3490 if (__get_ssid_from_vconf(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
3491 val, sizeof(val)) == false) {
3492 return TETHERING_ERROR_OPERATION_FAILED;
3494 *ssid = strdup(val);
3497 if (__get_ssid_from_vconf(VCONFKEY_MOBILE_HOTSPOT_SSID,
3498 val, sizeof(val)) == false) {
3499 return TETHERING_ERROR_OPERATION_FAILED;
3501 *ssid = strdup(val);
3504 if (*ssid == NULL) {
3505 ERR("strdup is failed\n");
3506 return TETHERING_ERROR_OUT_OF_MEMORY;
3509 return TETHERING_ERROR_NONE;
3514 * @brief Sets the visibility of SSID(service set identifier).
3516 * @privlevel platform
3517 * @privilege http://tizen.org/privilege/tethering.admin
3518 * @details If you set the visibility invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
3519 * @remarks This change is applied next time Wi-Fi tethering is enabled
3520 * @param[in] tethering The handle of tethering
3521 * @param[in] visible The visibility of SSID: (@c true = visible, @c false = invisible)
3522 * @return 0 on success, otherwise negative error value.
3523 * @retval #TETHERING_ERROR_NONE Successful
3524 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3525 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3526 * @see tethering_wifi_get_ssid_visibility()
3528 API int tethering_wifi_set_ssid_visibility(tethering_h tethering, bool visible)
3530 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3531 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3533 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3534 "parameter(tethering) is NULL\n");
3536 __tethering_h *th = (__tethering_h *)tethering;
3537 tethering_error_e ret = TETHERING_ERROR_NONE;
3539 ret = __set_visible(visible);
3540 if (ret == TETHERING_ERROR_NONE) {
3541 __send_dbus_signal(th->client_bus,
3542 SIGNAL_NAME_SSID_VISIBILITY_CHANGED,
3543 visible ? SIGNAL_MSG_SSID_VISIBLE :
3544 SIGNAL_MSG_SSID_HIDE);
3551 * @brief Gets the visibility of SSID(service set identifier).
3553 * @privlevel platform
3554 * @privilege http://tizen.org/privilege/tethering.admin
3555 * @details If the visibility is set invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
3556 * @param[in] tethering The handle of tethering
3557 * @param[out] visible The visibility of SSID: (@c true = visible, @c false = invisible)
3558 * @return 0 on success, otherwise negative error value.
3559 * @retval #TETHERING_ERROR_NONE Successful
3560 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3561 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3562 * @see tethering_wifi_set_ssid_visibility()
3564 API int tethering_wifi_get_ssid_visibility(tethering_h tethering, bool *visible)
3566 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3567 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3569 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3570 "parameter(tethering) is NULL\n");
3571 _retvm_if(visible == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3572 "parameter(visible) is NULL\n");
3574 return __get_visible(visible);
3579 * @brief Sets the passphrase.
3581 * @privlevel platform
3582 * @privilege http://tizen.org/privilege/tethering.admin
3583 * @remarks This change is applied next time Wi-Fi tethering is enabled
3584 * @param[in] tethering The handle of tethering
3585 * @param[in] passphrase The passphrase
3586 * @return 0 on success, otherwise negative error value.
3587 * @retval #TETHERING_ERROR_NONE Successful
3588 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3589 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3590 * @see tethering_wifi_get_passphrase()
3592 API int tethering_wifi_set_passphrase(tethering_h tethering, const char *passphrase)
3594 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3595 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3597 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3598 "parameter(tethering) is NULL\n");
3599 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3600 "parameter(passphrase) is NULL\n");
3602 __tethering_h *th = (__tethering_h *)tethering;
3603 GDBusProxy *proxy = th->client_bus_proxy;
3604 GVariant *parameters;
3605 GError *error = NULL;
3606 int passphrase_len = 0;
3610 passphrase_len = strlen(passphrase);
3611 if (passphrase_len < TETHERING_WIFI_KEY_MIN_LEN ||
3612 passphrase_len > TETHERING_WIFI_KEY_MAX_LEN) {
3613 ERR("parameter(passphrase) is too short or long\n");
3614 return TETHERING_ERROR_INVALID_PARAMETER;
3617 parameters = g_dbus_proxy_call_sync(proxy, "set_wifi_tethering_passphrase",
3618 g_variant_new("(s)", passphrase), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3621 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3623 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3624 ret = TETHERING_ERROR_PERMISSION_DENIED;
3626 ret = TETHERING_ERROR_OPERATION_FAILED;
3628 g_error_free(error);
3632 g_variant_get(parameters, "(u)", &ret);
3633 g_variant_unref(parameters);
3635 if (ret == TETHERING_ERROR_NONE) {
3636 __send_dbus_signal(th->client_bus,
3637 SIGNAL_NAME_PASSPHRASE_CHANGED, NULL);
3646 * @brief Gets the passphrase.
3648 * @privlevel platform
3649 * @privilege http://tizen.org/privilege/tethering.admin
3650 * @remarks @a passphrase must be released with free() by you.
3651 * @param[in] tethering The handle of tethering
3652 * @param[out] passphrase The passphrase
3653 * @return 0 on success, otherwise negative error value.
3654 * @retval #TETHERING_ERROR_NONE Successful
3655 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3656 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
3657 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3658 * @see tethering_wifi_set_passphrase()
3660 API int tethering_wifi_get_passphrase(tethering_h tethering, char **passphrase)
3662 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3663 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3665 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3666 "parameter(tethering) is NULL\n");
3667 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3668 "parameter(passphrase) is NULL\n");
3670 __tethering_h *th = (__tethering_h *)tethering;
3671 GDBusProxy *proxy = th->client_bus_proxy;
3672 GVariant *parameters;
3673 GError *error = NULL;
3674 unsigned int len = 0;
3675 tethering_error_e ret = TETHERING_ERROR_NONE;
3677 parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_passphrase",
3678 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3681 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3683 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3684 ret = TETHERING_ERROR_PERMISSION_DENIED;
3686 ret = TETHERING_ERROR_OPERATION_FAILED;
3688 g_error_free(error);
3692 if (parameters != NULL) {
3693 g_variant_get(parameters, "(siu)", passphrase, &len, &ret);
3694 g_variant_unref(parameters);
3697 return TETHERING_ERROR_NONE;
3700 API int tethering_wifi_set_channel(tethering_h tethering, int channel)
3702 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3703 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3705 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3706 "parameter(tethering) is NULL\n");
3708 __tethering_h *th = (__tethering_h *)tethering;
3711 GDBusProxy *proxy = th->client_bus_proxy;
3712 GVariant *parameters;
3713 GError *error = NULL;
3714 tethering_error_e ret = TETHERING_ERROR_NONE;
3716 parameters = g_dbus_proxy_call_sync(proxy, "set_wifi_tethering_channel",
3717 g_variant_new("(i)", channel), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3720 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3722 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3723 ret = TETHERING_ERROR_PERMISSION_DENIED;
3725 ret = TETHERING_ERROR_OPERATION_FAILED;
3727 g_error_free(error);
3731 if (parameters != NULL) {
3732 g_variant_get(parameters, "(u)", &ret);
3733 g_variant_unref(parameters);
3736 SINFO("set channel : %d", channel);
3737 #endif /* TIZEN_TV_EXT */
3739 th->channel = channel;
3741 return TETHERING_ERROR_NONE;
3744 API int tethering_wifi_get_channel(tethering_h tethering, int *channel)
3746 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3747 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3749 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3750 "parameter(tethering) is NULL\n");
3752 _retvm_if(channel == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3753 "parameter(channel) is NULL\n");
3755 __tethering_h *th = (__tethering_h *)tethering;
3757 GDBusProxy *proxy = th->client_bus_proxy;
3758 GVariant *parameters = NULL;
3759 GError *error = NULL;
3761 int vconf_channel = -1;
3762 tethering_error_e ret = TETHERING_ERROR_NONE;
3764 parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_channel",
3765 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3768 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3770 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3771 ret = TETHERING_ERROR_PERMISSION_DENIED;
3773 ret = TETHERING_ERROR_OPERATION_FAILED;
3775 g_error_free(error);
3779 if (parameters != NULL) {
3780 g_variant_get(parameters, "(iu)", &ch, &ret);
3781 g_variant_unref(parameters);
3785 ERR("failed to get Hostapd channel, set th->channel");
3786 *channel = th->channel;
3790 if (vconf_get_int(VCONFKEY_WIFI_CHANNEL, &vconf_channel) < 0)
3791 ERR("Failed to get vconf key for channel");
3793 *channel = vconf_channel;
3795 SINFO("get tethering channel : %d", *channel);
3796 #else /* TIZEN_TV_EXT */
3797 *channel = th->channel;
3798 #endif /* TIZEN_TV_EXT */
3800 return TETHERING_ERROR_NONE;
3803 API int tethering_wifi_set_mode(tethering_h tethering, tethering_wifi_mode_type_e type)
3805 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3806 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3808 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3809 "parameter(tethering) is NULL\n");
3811 __tethering_h *th = (__tethering_h *)tethering;
3813 th->mode_type = type;
3815 return TETHERING_ERROR_NONE;
3818 API int tethering_wifi_get_mode(tethering_h tethering, tethering_wifi_mode_type_e *type)
3820 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3821 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3823 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3824 "parameter(tethering) is NULL\n");
3825 _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3826 "parameter(type) is NULL\n");
3828 __tethering_h *th = (__tethering_h *)tethering;
3829 *type = th->mode_type;
3831 return TETHERING_ERROR_NONE;
3837 * @brief Reload the settings (SSID / Passphrase / Security type / SSID visibility).
3839 * @privlevel platform
3840 * @privilege http://tizen.org/privilege/tethering.admin
3841 * @remarks Connected devices via Wi-Fi tethering or MobileAP will be disconnected when the settings are reloaded
3842 * @param[in] tethering The handle of tethering
3843 * @param[in] callback The callback function to invoke
3844 * @param[in] user_data The user data to be passed to the callback function
3845 * @return 0 on success, otherwise negative error value.
3846 * @retval #TETHERING_ERROR_NONE Successful
3847 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3848 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3850 API int tethering_wifi_reload_settings(tethering_h tethering, tethering_wifi_settings_reloaded_cb callback, void *user_data)
3853 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3854 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3856 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3857 "parameter(tethering) is NULL\n");
3858 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3859 "parameter(callback) is NULL\n");
3861 __tethering_h *th = (__tethering_h *)tethering;
3862 _softap_settings_t set;
3863 GDBusProxy *proxy = th->client_bus_proxy;
3866 memset(&set, 0, sizeof(_softap_settings_t));
3870 if (th->settings_reloaded_cb) {
3871 ERR("Operation in progress\n");
3872 return TETHERING_ERROR_OPERATION_FAILED;
3875 ret = __prepare_wifi_settings(tethering, &set);
3876 if (ret != TETHERING_ERROR_NONE) {
3877 ERR("softap settings initialization failed\n");
3878 return TETHERING_ERROR_OPERATION_FAILED;
3881 th->settings_reloaded_cb = callback;
3882 th->settings_reloaded_user_data = user_data;
3884 SINFO("ssid %s, key %s, channel %d, mode %s, txpower %d, security %d max_device %d\n",
3885 set.ssid, set.key, set.channel, set.mode, set.txpower, set.sec_type,
3888 g_dbus_proxy_call(proxy, "reload_wifi_settings",
3889 g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, set.txpower),
3890 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
3891 (GAsyncReadyCallback) __settings_reloaded_cb, (gpointer)tethering);
3893 return TETHERING_ERROR_NONE;
3896 API int tethering_wifi_set_mac_filter(tethering_h tethering, bool mac_filter)
3898 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3899 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3901 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3902 "parameter(tethering) is NULL\n");
3904 __tethering_h *th = (__tethering_h *)tethering;
3905 th->mac_filter = mac_filter;
3907 return TETHERING_ERROR_NONE;
3910 API int tethering_wifi_get_mac_filter(tethering_h tethering, bool *mac_filter)
3912 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3913 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3915 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3916 "parameter(mac_filter) is NULL\n");
3917 _retvm_if(mac_filter == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3918 "parameter(mac_filter) is NULL\n");
3920 __tethering_h *th = (__tethering_h *)tethering;
3921 *mac_filter = th->mac_filter;
3923 return TETHERING_ERROR_NONE;
3926 static int __add_mac_to_file(const char *filepath, const char *mac)
3929 char line[MAX_BUF_SIZE] = "\0";
3930 bool mac_exist = false;
3933 fp = fopen(filepath, "a+");
3935 ERR("fopen is failed\n");
3936 return TETHERING_ERROR_OPERATION_FAILED;
3939 while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
3940 if (strncmp(mac, line, 17) == 0) {
3941 DBG("MAC %s already exist in the list\n", mac);
3948 p_mac = strdup(mac);
3949 if (p_mac == NULL) {
3950 ERR("strdup failed\n");
3952 return TETHERING_ERROR_OUT_OF_MEMORY;
3955 fprintf(fp, "%s\n", mac);
3957 if ((strcmp(filepath, ALLOWED_LIST) == 0))
3958 allowed_list = g_slist_append(allowed_list, p_mac);
3959 else if ((strcmp(filepath, BLOCKED_LIST) == 0))
3960 blocked_list = g_slist_append(blocked_list, p_mac);
3967 return TETHERING_ERROR_NONE;
3970 static int __remove_mac_from_file(const char *filepath, const char *mac)
3974 char line[MAX_BUF_SIZE] = "\0";
3976 fp = fopen(filepath, "r");
3978 ERR("fopen is failed\n");
3979 return TETHERING_ERROR_OPERATION_FAILED;
3982 fp1 = fopen(TEMP_LIST, "w+");
3985 ERR("fopen is failed\n");
3986 return TETHERING_ERROR_OPERATION_FAILED;
3989 while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
3990 if (strncmp(mac, line, 17) == 0) {
3991 DBG("MAC %s found in the list\n", mac);
3993 if ((strcmp(filepath, ALLOWED_LIST) == 0)) {
3994 GSList *list = NULL;
3995 for (list = allowed_list; list != NULL; list = list->next) {
3996 char *p_mac = (char *)list->data;
3997 if (strncmp(mac, p_mac, strlen(mac)) == 0)
3998 allowed_list = g_slist_remove(allowed_list, p_mac);
4000 } else if ((strcmp(filepath, BLOCKED_LIST) == 0)) {
4001 GSList *list = NULL;
4002 for (list = blocked_list; list != NULL; list = list->next) {
4003 char *p_mac = (char *)list->data;
4004 if (strncmp(mac, p_mac, strlen(mac)) == 0)
4005 blocked_list = g_slist_remove(blocked_list, p_mac);
4009 fprintf(fp1, "%s", line);
4016 if ((strcmp(filepath, ALLOWED_LIST) == 0)) {
4017 if (rename(TEMP_LIST, ALLOWED_LIST) != 0) {
4018 ERR("rename is failed (%s -> %s)", TEMP_LIST, ALLOWED_LIST);
4019 return TETHERING_ERROR_OPERATION_FAILED;
4021 } else if ((strcmp(filepath, BLOCKED_LIST) == 0)) {
4022 if (rename(TEMP_LIST, BLOCKED_LIST) != 0) {
4023 ERR("rename is failed (%s -> %s)", TEMP_LIST, BLOCKED_LIST);
4024 return TETHERING_ERROR_OPERATION_FAILED;
4028 return TETHERING_ERROR_NONE;
4031 API int tethering_wifi_add_allowed_mac_list(tethering_h tethering, const char *mac)
4033 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4034 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4036 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4037 "parameter(tethering) is NULL\n");
4038 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4039 "parameter(mac) is NULL\n");
4041 return __add_mac_to_file(ALLOWED_LIST, mac);
4044 API int tethering_wifi_remove_allowed_mac_list(tethering_h tethering, const char *mac)
4046 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4047 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4049 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4050 "parameter(tethering) is NULL\n");
4051 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4052 "parameter(mac) is NULL\n");
4054 return __remove_mac_from_file(ALLOWED_LIST, mac);
4057 API int tethering_wifi_get_allowed_mac_list(tethering_h tethering, void **allowed_mac_list)
4059 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4060 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4062 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4063 "parameter(tethering) is NULL\n");
4064 _retvm_if(allowed_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4065 "parameter(allowed_mac_list) is NULL\n");
4067 *allowed_mac_list = g_slist_copy(allowed_list);
4068 return TETHERING_ERROR_NONE;
4071 API int tethering_wifi_add_blocked_mac_list(tethering_h tethering, const char *mac)
4073 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4074 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4076 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4077 "parameter(tethering) is NULL\n");
4078 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4079 "parameter(mac) is NULL\n");
4081 return __add_mac_to_file(BLOCKED_LIST, mac);
4084 API int tethering_wifi_remove_blocked_mac_list(tethering_h tethering, const char *mac)
4086 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4087 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4089 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4090 "parameter(tethering) is NULL\n");
4091 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4092 "parameter(mac) is NULL\n");
4094 return __remove_mac_from_file(BLOCKED_LIST, mac);
4097 API int tethering_wifi_get_blocked_mac_list(tethering_h tethering, void **blocked_mac_list)
4099 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4100 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4102 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4103 "parameter(tethering) is NULL\n");
4104 _retvm_if(blocked_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4105 "parameter(blocked_mac_list) is NULL\n");
4107 *blocked_mac_list = g_slist_copy(blocked_list);
4108 return TETHERING_ERROR_NONE;
4111 API int tethering_wifi_enable_dhcp(tethering_h tethering, bool enable)
4113 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4114 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4116 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4117 "parameter(tethering) is NULL\n");
4119 GVariant *parameters;
4120 GError *error = NULL;
4123 __tethering_h *th = (__tethering_h *)tethering;
4125 GDBusProxy *proxy = th->client_bus_proxy;
4127 parameters = g_dbus_proxy_call_sync(proxy, "enable_dhcp",
4128 g_variant_new("(b)", enable),
4129 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4132 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4133 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4134 result = TETHERING_ERROR_PERMISSION_DENIED;
4136 result = TETHERING_ERROR_OPERATION_FAILED;
4138 g_error_free(error);
4139 th->dhcp_enabled = false;
4144 g_variant_get(parameters, "(u)", &result);
4145 g_variant_unref(parameters);
4148 th->dhcp_enabled = true;
4150 th->dhcp_enabled = false;
4152 return TETHERING_ERROR_NONE;
4155 API int tethering_wifi_set_dhcp_range(tethering_h tethering, char *rangestart, char *rangestop)
4157 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4158 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4160 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4161 "parameter(tethering) is NULL\n");
4162 _retvm_if(rangestart == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4163 "parameter(rangestart) is NULL\n");
4164 _retvm_if(rangestop == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4165 "parameter(rangestop) is NULL\n");
4167 GVariant *parameters;
4168 GError *error = NULL;
4171 __tethering_h *th = (__tethering_h *)tethering;
4173 GDBusProxy *proxy = th->client_bus_proxy;
4175 parameters = g_dbus_proxy_call_sync(proxy, "dhcp_range",
4176 g_variant_new("(ss)", rangestart, rangestop),
4177 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4179 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4181 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4182 result = TETHERING_ERROR_PERMISSION_DENIED;
4184 result = TETHERING_ERROR_OPERATION_FAILED;
4186 g_error_free(error);
4187 th->dhcp_enabled = false;
4192 g_variant_get(parameters, "(u)", &result);
4193 g_variant_unref(parameters);
4195 th->dhcp_enabled = true;
4197 return TETHERING_ERROR_NONE;
4200 API int tethering_wifi_is_dhcp_enabled(tethering_h tethering, bool *dhcp_enabled)
4202 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4203 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4205 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4206 "parameter(tethering) is NULL\n");
4207 _retvm_if(dhcp_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4208 "parameter(dhcp_enabled) is NULL\n");
4210 __tethering_h *th = (__tethering_h *)tethering;
4211 *dhcp_enabled = th->dhcp_enabled;
4213 return TETHERING_ERROR_NONE;
4216 API int tethering_wifi_set_txpower(tethering_h tethering, unsigned int txpower)
4218 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4219 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4221 GError *error = NULL;
4223 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4224 "parameter(tethering) is NULL\n");
4225 _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false,
4226 TETHERING_ERROR_NOT_ENABLED,
4227 "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
4228 __tethering_h *th = (__tethering_h *)tethering;
4229 th->txpower = txpower;
4231 g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_set_txpower",
4232 g_variant_new("(u)", txpower),
4233 G_DBUS_CALL_FLAGS_NONE,
4234 -1, th->cancellable, &error);
4236 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
4237 g_clear_error(&error);
4238 return TETHERING_ERROR_OPERATION_FAILED;
4240 return TETHERING_ERROR_NONE;
4243 API int tethering_wifi_get_txpower(tethering_h tethering, unsigned int *txpower)
4245 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4246 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4248 GError *error = NULL;
4249 GVariant *result = NULL;
4251 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4252 "parameter(tethering) is NULL\n");
4253 _retvm_if(txpower == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4254 "parameter(txpower) is NULL\n");
4255 _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false,
4256 TETHERING_ERROR_NOT_ENABLED,
4257 "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
4259 __tethering_h *th = (__tethering_h *)tethering;
4261 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_get_txpower",
4263 G_DBUS_CALL_FLAGS_NONE,
4264 -1, th->cancellable, &error);
4266 if (result != NULL) {
4267 g_variant_get(result, "(u)", txpower);
4268 g_variant_unref(result);
4271 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
4272 g_clear_error(&error);
4273 return TETHERING_ERROR_OPERATION_FAILED;
4275 g_clear_error(&error);
4276 return TETHERING_ERROR_NONE;
4279 API int tethering_wifi_set_mtu(tethering_h tethering, unsigned int mtu)
4281 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4282 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4284 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4285 "parameter(tethering) is NULL\n");
4287 GVariant *parameters;
4288 GError *error = NULL;
4291 __tethering_h *th = (__tethering_h *)tethering;
4293 GDBusProxy *proxy = th->client_bus_proxy;
4295 parameters = g_dbus_proxy_call_sync(proxy, "set_mtu",
4296 g_variant_new("(u)", mtu),
4297 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4299 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4301 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4302 result = TETHERING_ERROR_PERMISSION_DENIED;
4304 result = TETHERING_ERROR_OPERATION_FAILED;
4306 g_error_free(error);
4310 g_variant_get(parameters, "(u)", &result);
4312 g_variant_unref(parameters);
4314 return TETHERING_ERROR_NONE;
4317 API int tethering_wifi_change_mac(tethering_h tethering, char *mac)
4319 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4320 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4322 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4323 "parameter(tethering) is NULL\n");
4324 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4325 "parameter(mac) is NULL\n");
4327 GVariant *parameters;
4328 GError *error = NULL;
4331 __tethering_h *th = (__tethering_h *)tethering;
4333 GDBusProxy *proxy = th->client_bus_proxy;
4335 parameters = g_dbus_proxy_call_sync(proxy, "change_mac",
4336 g_variant_new("(s)", mac),
4337 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4339 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4341 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4342 result = TETHERING_ERROR_PERMISSION_DENIED;
4344 result = TETHERING_ERROR_OPERATION_FAILED;
4346 g_error_free(error);
4350 g_variant_get(parameters, "(u)", &result);
4351 g_variant_unref(parameters);
4353 if (result == MOBILE_AP_ERROR_NOT_PERMITTED)
4354 return TETHERING_ERROR_NOT_SUPPORT_API;
4356 return TETHERING_ERROR_NONE;
4359 API int tethering_wifi_set_max_connected_device(tethering_h tethering, int max_device)
4361 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4362 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4364 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4365 "parameter(tethering) is NULL\n");
4367 __tethering_h *th = (__tethering_h *)tethering;
4369 th->wifi_max_connected = max_device;
4371 return TETHERING_ERROR_NONE;
4374 API int tethering_wifi_get_max_connected_device(tethering_h tethering, int *max_device)
4376 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4377 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4379 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4380 "parameter(tethering) is NULL\n");
4381 _retvm_if(max_device == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4382 "parameter(max_device) is NULL\n");
4384 __tethering_h *th = (__tethering_h *)tethering;
4386 *max_device = th->wifi_max_connected;
4387 return TETHERING_ERROR_NONE;
4390 API int tethering_wifi_enable_port_forwarding(tethering_h tethering, bool enable)
4392 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4393 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4395 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4396 "parameter(tethering) is NULL\n");
4398 GVariant *parameters;
4399 GError *error = NULL;
4402 __tethering_h *th = (__tethering_h *)tethering;
4404 GDBusProxy *proxy = th->client_bus_proxy;
4406 parameters = g_dbus_proxy_call_sync(proxy, "enable_port_forwarding",
4407 g_variant_new("(b)", enable),
4408 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4410 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4412 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4413 result = TETHERING_ERROR_PERMISSION_DENIED;
4415 result = TETHERING_ERROR_OPERATION_FAILED;
4417 g_error_free(error);
4421 g_variant_get(parameters, "(u)", &result);
4422 g_variant_unref(parameters);
4424 th->port_forwarding = true;
4426 return TETHERING_ERROR_NONE;
4429 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)
4431 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4432 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4434 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4435 "parameter(tethering) is NULL\n");
4436 _retvm_if(ifname == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4437 "parameter(ifname) is NULL\n");
4438 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4439 "parameter(protocol) is NULL\n");
4440 _retvm_if(org_ip == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4441 "parameter(org_ip) is NULL\n");
4442 _retvm_if(final_ip == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4443 "parameter(final_ip) is NULL\n");
4445 GVariant *parameters;
4446 GError *error = NULL;
4448 char cmd[MAX_BUF_SIZE] = { 0, };
4451 __tethering_h *th = (__tethering_h *)tethering;
4453 GDBusProxy *proxy = th->client_bus_proxy;
4455 parameters = g_dbus_proxy_call_sync(proxy, "add_port_forwarding_rule",
4456 g_variant_new("(sssisi)", ifname, protocol, org_ip, org_port, final_ip, final_port),
4457 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4459 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4461 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4462 result = TETHERING_ERROR_PERMISSION_DENIED;
4464 result = TETHERING_ERROR_OPERATION_FAILED;
4466 g_error_free(error);
4470 g_variant_get(parameters, "(u)", &result);
4471 g_variant_unref(parameters);
4473 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);
4477 ERR("strdup failed\n");
4478 return TETHERING_ERROR_OUT_OF_MEMORY;
4481 port_forwarding = g_slist_append(port_forwarding, list);
4483 return TETHERING_ERROR_NONE;
4486 API int tethering_wifi_reset_port_forwarding_rule(tethering_h tethering)
4488 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4489 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4491 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4492 "parameter(tethering) is NULL\n");
4494 GVariant *parameters;
4495 GError *error = NULL;
4498 __tethering_h *th = (__tethering_h *)tethering;
4500 GDBusProxy *proxy = th->client_bus_proxy;
4502 parameters = g_dbus_proxy_call_sync(proxy, "reset_port_forwarding_rule",
4503 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4505 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4507 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4508 result = TETHERING_ERROR_PERMISSION_DENIED;
4510 result = TETHERING_ERROR_OPERATION_FAILED;
4512 g_error_free(error);
4516 g_variant_get(parameters, "(u)", &result);
4518 g_variant_unref(parameters);
4520 return TETHERING_ERROR_NONE;
4523 API int tethering_wifi_is_port_forwarding_enabled(tethering_h tethering, bool *forwarding_enabled)
4525 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4526 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4528 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4529 "parameter(tethering) is NULL\n");
4530 _retvm_if(forwarding_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4531 "parameter(forwarding_enabled) is NULL\n");
4533 __tethering_h *th = (__tethering_h *)tethering;
4535 *forwarding_enabled = th->port_forwarding;
4537 return TETHERING_ERROR_NONE;
4540 API int tethering_wifi_get_port_forwarding_rule(tethering_h tethering, void **port_forwarding_list)
4542 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4543 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4545 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4546 "parameter(tethering) is NULL\n");
4547 _retvm_if(port_forwarding_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4548 "parameter(port_forwarding_list) is NULL\n");
4550 *port_forwarding_list = g_slist_copy(port_forwarding);
4551 return TETHERING_ERROR_NONE;
4554 API int tethering_wifi_enable_port_filtering(tethering_h tethering, bool enable)
4556 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4557 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4559 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4560 "parameter(tethering) is NULL\n");
4562 GVariant *parameters;
4563 GError *error = NULL;
4566 __tethering_h *th = (__tethering_h *)tethering;
4568 GDBusProxy *proxy = th->client_bus_proxy;
4570 parameters = g_dbus_proxy_call_sync(proxy, "enable_port_filtering",
4571 g_variant_new("(b)", enable),
4572 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4574 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4576 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4577 result = TETHERING_ERROR_PERMISSION_DENIED;
4579 result = TETHERING_ERROR_OPERATION_FAILED;
4581 g_error_free(error);
4585 g_variant_get(parameters, "(u)", &result);
4586 g_variant_unref(parameters);
4588 th->port_filtering = true;
4590 return TETHERING_ERROR_NONE;
4593 API int tethering_wifi_add_port_filtering_rule(tethering_h tethering, int port, char *protocol, bool allow)
4595 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4596 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4598 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4599 "parameter(tethering) is NULL\n");
4600 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4601 "parameter(protocol) is NULL\n");
4603 GVariant *parameters;
4604 GError *error = NULL;
4609 __tethering_h *th = (__tethering_h *)tethering;
4611 GDBusProxy *proxy = th->client_bus_proxy;
4613 parameters = g_dbus_proxy_call_sync(proxy, "add_port_filtering_rule",
4614 g_variant_new("(isb)", port, protocol, allow),
4615 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4617 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4619 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4620 result = TETHERING_ERROR_PERMISSION_DENIED;
4622 result = TETHERING_ERROR_OPERATION_FAILED;
4624 g_error_free(error);
4628 g_variant_get(parameters, "(u)", &result);
4629 g_variant_unref(parameters);
4632 ret = asprintf(&list, "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_ACCEPT);
4634 ret = asprintf(&list, "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_DROP);
4636 if (ret == -1 || list == NULL) {
4637 ERR("asprintf failed\n");
4638 return TETHERING_ERROR_OUT_OF_MEMORY;
4641 DBG("cmd:%s", list);
4643 port_filtering = g_slist_append(port_filtering, list);
4645 return TETHERING_ERROR_NONE;
4648 API int tethering_wifi_add_custom_port_filtering_rule(tethering_h tethering, int port1, int port2, char *protocol, bool allow)
4650 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4651 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4653 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4654 "parameter(tethering) is NULL\n");
4655 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4656 "parameter(protocol) is NULL\n");
4658 GVariant *parameters;
4659 GError *error = NULL;
4664 __tethering_h *th = (__tethering_h *)tethering;
4666 GDBusProxy *proxy = th->client_bus_proxy;
4668 parameters = g_dbus_proxy_call_sync(proxy, "add_custom_port_filtering_rule",
4669 g_variant_new("(iisb)", port1, port2, protocol, allow),
4670 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4672 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4674 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4675 result = TETHERING_ERROR_PERMISSION_DENIED;
4677 result = TETHERING_ERROR_OPERATION_FAILED;
4679 g_error_free(error);
4683 g_variant_get(parameters, "(u)", &result);
4684 g_variant_unref(parameters);
4687 ret = asprintf(&list, "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_ACCEPT);
4689 ret = asprintf(&list, "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_DROP);
4691 if (ret == -1 || list == NULL) {
4692 ERR("asprintf failed\n");
4693 return TETHERING_ERROR_OUT_OF_MEMORY;
4696 DBG("cmd:%s", list);
4698 custom_port_filtering = g_slist_append(custom_port_filtering, list);
4700 return TETHERING_ERROR_NONE;
4703 API int tethering_wifi_get_port_filtering_rule(tethering_h tethering, void **port_filtering_list)
4705 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4706 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4708 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4709 "parameter(tethering) is NULL\n");
4710 _retvm_if(port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4711 "parameter(port_filtering_list) is NULL\n");
4713 *port_filtering_list = g_slist_copy(port_filtering);
4714 return TETHERING_ERROR_NONE;
4717 API int tethering_wifi_get_custom_port_filtering_rule(tethering_h tethering, void **custom_port_filtering_list)
4719 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4720 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4722 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4723 "parameter(tethering) is NULL\n");
4724 _retvm_if(custom_port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4725 "parameter(custom_port_filtering_list) is NULL\n");
4727 *custom_port_filtering_list = g_slist_copy(custom_port_filtering);
4728 return TETHERING_ERROR_NONE;
4731 API int tethering_wifi_is_port_filtering_enabled(tethering_h tethering, bool *filtering_enabled)
4733 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4734 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4736 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4737 "parameter(tethering) is NULL\n");
4738 _retvm_if(filtering_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4739 "parameter(filtering_enabled) is NULL\n");
4741 __tethering_h *th = (__tethering_h *)tethering;
4743 *filtering_enabled = th->port_filtering;
4745 return TETHERING_ERROR_NONE;
4748 API int tethering_wifi_set_vpn_passthrough_rule(tethering_h tethering, tethering_vpn_passthrough_type_e type, bool enable)
4750 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4751 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4753 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4754 "parameter(tethering) is NULL\n");
4756 GVariant *parameters;
4757 GError *error = NULL;
4760 __tethering_h *th = (__tethering_h *)tethering;
4762 GDBusProxy *proxy = th->client_bus_proxy;
4764 parameters = g_dbus_proxy_call_sync(proxy, "set_vpn_passthrough_rule",
4765 g_variant_new("(ib)", type, enable),
4766 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4768 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4770 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4771 result = TETHERING_ERROR_PERMISSION_DENIED;
4773 result = TETHERING_ERROR_OPERATION_FAILED;
4775 g_error_free(error);
4779 g_variant_get(parameters, "(u)", &result);
4781 g_variant_unref(parameters);
4783 return TETHERING_ERROR_NONE;
4786 API int tethering_wifi_push_wps_button(tethering_h tethering)
4788 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4789 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4791 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4792 "parameter(tethering) is NULL");
4793 __tethering_h *th = (__tethering_h *)tethering;
4794 GDBusProxy *proxy = th->client_bus_proxy;
4795 GVariant *parameters = NULL;
4797 GError *error = NULL;
4799 parameters = g_dbus_proxy_call_sync(proxy, "push_wps_button",
4800 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4803 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4805 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4806 ret = TETHERING_ERROR_PERMISSION_DENIED;
4808 ret = TETHERING_ERROR_OPERATION_FAILED;
4810 g_error_free(error);
4814 if (parameters != NULL) {
4815 g_variant_get(parameters, "(u)", &ret);
4816 g_variant_unref(parameters);
4819 return TETHERING_ERROR_NONE;
4822 API int tethering_wifi_set_wps_pin(tethering_h tethering, const char *wps_pin)
4824 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4825 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4827 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4828 "parameter(tethering) is NULL");
4829 _retvm_if(wps_pin == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4830 "parameter(wps_pin) is NULL");
4832 __tethering_h *th = (__tethering_h *)tethering;
4833 GDBusProxy *proxy = th->client_bus_proxy;
4834 GVariant *parameters = NULL;
4836 GError *error = NULL;
4838 parameters = g_dbus_proxy_call_sync(proxy, "set_wps_pin",
4839 g_variant_new("(s)", wps_pin), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4842 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4844 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4845 ret = TETHERING_ERROR_PERMISSION_DENIED;
4847 ret = TETHERING_ERROR_OPERATION_FAILED;
4849 g_error_free(error);
4853 if (parameters != NULL) {
4854 g_variant_get(parameters, "(u)", &ret);
4855 g_variant_unref(parameters);
4858 return TETHERING_ERROR_NONE;
4861 API int tethering_wifi_is_sharing_supported(tethering_h tethering, bool *supported)
4863 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4864 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4866 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4867 "parameter(tethering) is NULL\n");
4868 _retvm_if(supported == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4869 "parameter(supported) is NULL\n");
4871 /** Check if wifi-sharing is supported */
4872 __tethering_h *th = (__tethering_h *)tethering;
4873 GDBusProxy *proxy = th->client_bus_proxy;
4875 int ret = TETHERING_ERROR_NONE;
4878 GVariant *value = NULL;
4879 GVariantIter *iter = NULL;
4880 GVariantIter *sub_iter = NULL;
4881 GVariant *parameters = NULL;
4882 GError *error = NULL;
4884 parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_interfaces",
4885 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4888 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4890 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4891 ret = TETHERING_ERROR_PERMISSION_DENIED;
4893 ret = TETHERING_ERROR_OPERATION_FAILED;
4895 g_error_free(error);
4899 g_variant_get(parameters, "(a(a{sv}))", &iter);
4901 g_variant_unref(parameters);
4902 ret = TETHERING_ERROR_OPERATION_FAILED;
4906 while (g_variant_iter_loop(iter, "(a{sv})", &sub_iter)) {
4907 while (g_variant_iter_loop(sub_iter, "{sv}", &key, &value)) {
4908 if (g_strcmp0(key, "IfName") == 0) {
4909 const gchar *interface = g_variant_get_string(value, NULL);
4910 ERR("interface: %s\n", interface);
4911 if (strncmp(interface, "wlan", 4) == 0)
4916 g_variant_unref(parameters);
4927 API int tethering_wifi_set_sharing(tethering_h tethering, bool sharing)
4929 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4930 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4932 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4933 "parameter(tethering) is NULL\n");
4935 __tethering_h *th = (__tethering_h *)tethering;
4936 th->wifi_sharing = sharing;
4938 return TETHERING_ERROR_NONE;
4941 API int tethering_wifi_get_sharing(tethering_h tethering, bool *sharing)
4943 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4944 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4946 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4947 "parameter(tethering) is NULL\n");
4948 _retvm_if(sharing == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4949 "parameter(sharing) is NULL\n");
4951 __tethering_h *th = (__tethering_h *)tethering;
4952 *sharing = th->wifi_sharing;
4954 return TETHERING_ERROR_NONE;