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.
20 #include <sys/ioctl.h>
21 #include <sys/socket.h>
22 #include <netinet/in.h>
24 #include <arpa/inet.h>
26 #include <dbus/dbus.h>
29 #include <openssl/evp.h>
30 #include <openssl/sha.h>
31 #include <ckmc/ckmc-manager.h>
32 #include <tzplatform_config.h>
33 #include "tethering_private.h"
35 #define ALLOWED_LIST tzplatform_mkpath(TZ_SYS_VAR, "/lib/hostapd/hostapd.accept")
36 #define BLOCKED_LIST tzplatform_mkpath(TZ_SYS_VAR, "/lib/hostapd/hostapd.deny")
37 #define TEMP_LIST tzplatform_mkpath(TZ_SYS_VAR, "/lib/hostapd/.hostapd_tmp")
38 #define MAC_ADDR_LEN 18
39 #define MAX_BUF_SIZE 80
41 #define IPTABLES "/usr/sbin/iptables"
42 #define TABLE_NAT "nat"
43 #define TETH_NAT_PRE "teth_nat_pre"
44 #define TABLE_FILTER "filter"
45 #define TETH_FILTER_FW "teth_filter_fw"
46 #define ACTION_DROP "DROP"
47 #define ACTION_ACCEPT "ACCEPT"
48 #define PORT_FORWARD_RULE_STR "-t %s -A %s -i %s -p %s -d %s --dport %d -j DNAT --to %s:%d"
49 #define FILTERING_MULTIPORT_RULE_STR "-t %s -A %s -p %s -m multiport --dport %d,%d -j %s"
50 #define FILTERING_RULE_STR "-t %s -A %s -p %s --dport %d -j %s"
52 static GSList *allowed_list = NULL;
53 static GSList *blocked_list = NULL;
54 static GSList *port_forwarding = NULL;
55 static GSList *port_filtering = NULL;
56 static GSList *custom_port_filtering = NULL;
58 static void __handle_wifi_tether_on(GDBusConnection *connection, const gchar *sender_name,
59 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
60 GVariant *parameters, gpointer user_data);
62 static void __handle_wifi_tether_off(GDBusConnection *connection, const gchar *sender_name,
63 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
64 GVariant *parameters, gpointer user_data);
66 static void __handle_usb_tether_on(GDBusConnection *connection, const gchar *sender_name,
67 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
68 GVariant *parameters, gpointer user_data);
70 static void __handle_usb_tether_off(GDBusConnection *connection, const gchar *sender_name,
71 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
72 GVariant *parameters, gpointer user_data);
74 static void __handle_bt_tether_on(GDBusConnection *connection, const gchar *sender_name,
75 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
76 GVariant *parameters, gpointer user_data);
78 static void __handle_bt_tether_off(GDBusConnection *connection, const gchar *sender_name,
79 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
80 GVariant *parameters, gpointer user_data);
82 static void __handle_net_closed(GDBusConnection *connection, const gchar *sender_name,
83 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
84 GVariant *parameters, gpointer user_data);
86 static void __handle_no_data_timeout(GDBusConnection *connection, const gchar *sender_name,
87 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
88 GVariant *parameters, gpointer user_data);
90 static void __handle_low_battery_mode(GDBusConnection *connection, const gchar *sender_name,
91 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
92 GVariant *parameters, gpointer user_data);
94 static void __handle_flight_mode(GDBusConnection *connection, const gchar *sender_name,
95 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
96 GVariant *parameters, gpointer user_data);
98 static void __handle_security_type_changed(GDBusConnection *connection, const gchar *sender_name,
99 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
100 GVariant *parameters, gpointer user_data);
102 static void __handle_ssid_visibility_changed(GDBusConnection *connection, const gchar *sender_name,
103 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
104 GVariant *parameters, gpointer user_data);
106 static void __handle_passphrase_changed(GDBusConnection *connection, const gchar *sender_name,
107 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
108 GVariant *parameters, gpointer user_data);
110 static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name,
111 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
112 GVariant *parameters, gpointer user_data);
114 static __tethering_sig_t sigs[] = {
115 {0, SIGNAL_NAME_NET_CLOSED, __handle_net_closed},
116 {0, SIGNAL_NAME_WIFI_TETHER_ON, __handle_wifi_tether_on},
117 {0, SIGNAL_NAME_WIFI_TETHER_OFF, __handle_wifi_tether_off},
118 {0, SIGNAL_NAME_USB_TETHER_ON, __handle_usb_tether_on},
119 {0, SIGNAL_NAME_USB_TETHER_OFF, __handle_usb_tether_off},
120 {0, SIGNAL_NAME_BT_TETHER_ON, __handle_bt_tether_on},
121 {0, SIGNAL_NAME_BT_TETHER_OFF, __handle_bt_tether_off},
122 {0, SIGNAL_NAME_NO_DATA_TIMEOUT, __handle_no_data_timeout},
123 {0, SIGNAL_NAME_LOW_BATTERY_MODE, __handle_low_battery_mode},
124 {0, SIGNAL_NAME_FLIGHT_MODE, __handle_flight_mode},
125 {0, SIGNAL_NAME_SECURITY_TYPE_CHANGED, __handle_security_type_changed},
126 {0, SIGNAL_NAME_SSID_VISIBILITY_CHANGED, __handle_ssid_visibility_changed},
127 {0, SIGNAL_NAME_PASSPHRASE_CHANGED, __handle_passphrase_changed},
128 {0, SIGNAL_NAME_DHCP_STATUS, __handle_dhcp} };
130 static int retry = 0;
132 static void __send_dbus_signal(GDBusConnection *conn, const char *signal_name, const char *arg)
134 if (conn == NULL || signal_name == NULL)
135 return; //LCOV_EXCL_LINE
137 GVariant *message = NULL;
138 GError *error = NULL;
141 message = g_variant_new("(s)", arg);
143 g_dbus_connection_emit_signal(conn, NULL, TETHERING_SERVICE_OBJECT_PATH,
144 TETHERING_SERVICE_INTERFACE, signal_name, message, &error);
146 ERR("g_dbus_connection_emit_signal is failed because %s\n", error->message); //LCOV_EXCL_LINE
147 g_error_free(error); //LCOV_EXCL_LINE
149 g_variant_unref(message);
152 static bool __any_tethering_is_enabled(tethering_h tethering)
154 if (tethering_is_enabled(tethering, TETHERING_TYPE_USB) ||
155 tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) ||
156 tethering_is_enabled(tethering, TETHERING_TYPE_BT))
162 static tethering_error_e __set_security_type(const tethering_wifi_security_type_e security_type)
164 if (security_type != TETHERING_WIFI_SECURITY_TYPE_NONE &&
165 security_type != TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK &&
166 security_type != TETHERING_WIFI_SECURITY_TYPE_WPS) {
167 ERR("Invalid param\n");
168 return TETHERING_ERROR_INVALID_PARAMETER;
171 if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY, security_type) < 0) {
172 ERR("vconf_set_int is failed\n");
173 return TETHERING_ERROR_OPERATION_FAILED;
176 return TETHERING_ERROR_NONE;
179 static tethering_error_e __get_security_type(tethering_wifi_security_type_e *security_type)
181 if (security_type == NULL) {
182 ERR("Invalid param\n");
183 return TETHERING_ERROR_INVALID_PARAMETER;
186 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY,
187 (int *)security_type) < 0) {
188 ERR("vconf_get_int is failed\n");
189 return TETHERING_ERROR_OPERATION_FAILED;
192 return TETHERING_ERROR_NONE;
195 static bool __get_ssid_from_vconf(const char *path, char *ssid, unsigned int size)
197 if (path == NULL || ssid == NULL || size == 0)
201 char *ptr_tmp = NULL;
203 ptr = vconf_get_str(path);
207 if (!g_utf8_validate(ptr, -1, (const char **)&ptr_tmp))
210 g_strlcpy(ssid, ptr, size);
216 static tethering_error_e __set_visible(const bool visible)
218 if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, visible ? 0 : 1) < 0) {
219 ERR("vconf_set_int is failed\n");
220 return TETHERING_ERROR_OPERATION_FAILED;
223 return TETHERING_ERROR_NONE;
226 static tethering_error_e __get_visible(bool *visible)
228 if (visible == NULL) {
229 ERR("Invalid param\n");
230 return TETHERING_ERROR_INVALID_PARAMETER;
235 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, &hide) < 0) {
236 ERR("vconf_get_int is failed\n");
237 return TETHERING_ERROR_OPERATION_FAILED;
244 return TETHERING_ERROR_NONE;
247 static unsigned int __generate_initial_passphrase(char *passphrase, unsigned int size)
249 if (passphrase == NULL ||
250 size == 0 || size < TETHERING_WIFI_KEY_MIN_LEN + 1)
253 guint32 rand_int = 0;
256 for (index = 0; index < TETHERING_WIFI_KEY_MIN_LEN; index++) {
257 rand_int = g_random_int_range('a', 'z');
258 passphrase[index] = rand_int;
260 passphrase[index] = '\0';
265 static tethering_error_e __get_error(int agent_error)
267 tethering_error_e err = TETHERING_ERROR_NONE;
269 switch (agent_error) {
270 case MOBILE_AP_ERROR_NONE:
271 err = TETHERING_ERROR_NONE;
275 case MOBILE_AP_ERROR_RESOURCE:
276 err = TETHERING_ERROR_OUT_OF_MEMORY;
280 case MOBILE_AP_ERROR_INTERNAL:
281 err = TETHERING_ERROR_OPERATION_FAILED;
284 case MOBILE_AP_ERROR_INVALID_PARAM:
285 err = TETHERING_ERROR_INVALID_PARAMETER;
288 case MOBILE_AP_ERROR_ALREADY_ENABLED:
289 err = TETHERING_ERROR_OPERATION_FAILED;
292 case MOBILE_AP_ERROR_NOT_ENABLED:
293 err = TETHERING_ERROR_NOT_ENABLED;
296 case MOBILE_AP_ERROR_NET_OPEN:
297 err = TETHERING_ERROR_OPERATION_FAILED;
300 case MOBILE_AP_ERROR_NET_CLOSE:
301 err = TETHERING_ERROR_OPERATION_FAILED;
304 case MOBILE_AP_ERROR_DHCP:
305 err = TETHERING_ERROR_OPERATION_FAILED;
308 case MOBILE_AP_ERROR_IN_PROGRESS:
309 err = TETHERING_ERROR_OPERATION_FAILED;
313 case MOBILE_AP_ERROR_NOT_PERMITTED:
314 err = TETHERING_ERROR_NOT_PERMITTED;
317 case MOBILE_AP_ERROR_PERMISSION_DENIED:
318 err = TETHERING_ERROR_PERMISSION_DENIED;
322 ERR("Not defined error : %d\n", agent_error);
323 err = TETHERING_ERROR_OPERATION_FAILED;
331 static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name,
332 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
333 GVariant *parameters, gpointer user_data)
337 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
339 __tethering_h *th = (__tethering_h *)user_data;
341 tethering_type_e type = 0;
342 mobile_ap_type_e ap_type = 0;
343 tethering_connection_state_changed_cb ccb = NULL;
344 __tethering_client_h client;
352 memset(&client, 0, sizeof(__tethering_client_h));
353 g_variant_get(parameters, "(susssu)", &buf, &ap_type, &ip, &mac, &name, ×tamp);
355 if (!g_strcmp0(buf, "DhcpConnected")) {
357 } else if (!g_strcmp0(buf, "DhcpLeaseDeleted")) {
360 ERR("Unknown event [%s]\n", buf);
364 if (ap_type == MOBILE_AP_TYPE_USB)
365 type = TETHERING_TYPE_USB;
366 else if (ap_type == MOBILE_AP_TYPE_WIFI)
367 type = TETHERING_TYPE_WIFI;
368 else if (ap_type == MOBILE_AP_TYPE_BT)
369 type = TETHERING_TYPE_BT;
371 ERR("Not supported tethering type [%d]\n", ap_type);
375 ccb = th->changed_cb[type];
378 data = th->changed_user_data[type];
380 client.interface = type;
381 g_strlcpy(client.ip, ip, sizeof(client.ip));
382 g_strlcpy(client.mac, mac, sizeof(client.mac));
384 client.hostname = g_strdup(name);
385 client.tm = (time_t)timestamp;
387 ccb((tethering_client_h)&client, opened, data);
388 g_free(client.hostname);
399 static void __handle_net_closed(GDBusConnection *connection, const gchar *sender_name,
400 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
401 GVariant *parameters, gpointer user_data)
405 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
407 __tethering_h *th = (__tethering_h *)user_data;
408 tethering_type_e type = 0;
409 tethering_disabled_cb dcb = NULL;
411 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_NETWORK_CLOSE;
413 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
414 dcb = th->disabled_cb[type];
417 data = th->disabled_user_data[type];
419 dcb(TETHERING_ERROR_NONE, type, code, data);
426 static void __handle_wifi_tether_on(GDBusConnection *connection, const gchar *sender_name,
427 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
428 GVariant *parameters, gpointer user_data)
432 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
434 __tethering_h *th = (__tethering_h *)user_data;
435 tethering_type_e type = TETHERING_TYPE_WIFI;
436 bool is_requested = false;
437 tethering_enabled_cb ecb = NULL;
440 ecb = th->enabled_cb[type];
443 data = th->enabled_user_data[type];
445 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
449 static void __handle_wifi_tether_off(GDBusConnection *connection, const gchar *sender_name,
450 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
451 GVariant *parameters, gpointer user_data)
455 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
457 __tethering_h *th = (__tethering_h *)user_data;
458 tethering_type_e type = TETHERING_TYPE_WIFI;
459 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
460 tethering_disabled_cb dcb = NULL;
464 dcb = th->disabled_cb[type];
467 data = th->disabled_user_data[type];
468 g_variant_get(parameters, "(s)", &buf);
469 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
470 code = TETHERING_DISABLED_BY_WIFI_ON;
471 else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT))
472 code = TETHERING_DISABLED_BY_TIMEOUT;
475 dcb(TETHERING_ERROR_NONE, type, code, data);
481 static void __handle_usb_tether_on(GDBusConnection *connection, const gchar *sender_name,
482 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
483 GVariant *parameters, gpointer user_data)
487 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
489 __tethering_h *th = (__tethering_h *)user_data;
490 tethering_type_e type = TETHERING_TYPE_USB;
491 bool is_requested = false;
492 tethering_enabled_cb ecb = NULL;
495 ecb = th->enabled_cb[type];
498 data = th->enabled_user_data[type];
500 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
504 static void __handle_usb_tether_off(GDBusConnection *connection, const gchar *sender_name,
505 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
506 GVariant *parameters, gpointer user_data)
510 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
512 __tethering_h *th = (__tethering_h *)user_data;
513 tethering_type_e type = TETHERING_TYPE_USB;
514 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
515 tethering_disabled_cb dcb = NULL;
519 dcb = th->disabled_cb[type];
522 data = th->disabled_user_data[type];
524 g_variant_get(parameters, "(s)", &buf);
525 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
526 code = TETHERING_DISABLED_BY_USB_DISCONNECTION;
528 dcb(TETHERING_ERROR_NONE, type, code, data);
534 static void __handle_bt_tether_on(GDBusConnection *connection, const gchar *sender_name,
535 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
536 GVariant *parameters, gpointer user_data)
540 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
542 __tethering_h *th = (__tethering_h *)user_data;
543 tethering_type_e type = TETHERING_TYPE_BT;
544 bool is_requested = false;
545 tethering_enabled_cb ecb = NULL;
548 ecb = th->enabled_cb[type];
551 data = th->enabled_user_data[type];
553 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
557 static void __handle_bt_tether_off(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 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
565 __tethering_h *th = (__tethering_h *)user_data;
566 tethering_type_e type = TETHERING_TYPE_BT;
567 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
568 tethering_disabled_cb dcb = NULL;
572 dcb = th->disabled_cb[type];
575 data = th->disabled_user_data[type];
576 g_variant_get(parameters, "(s)", &buf);
577 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
578 code = TETHERING_DISABLED_BY_BT_OFF;
579 else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT))
580 code = TETHERING_DISABLED_BY_TIMEOUT;
582 dcb(TETHERING_ERROR_NONE, type, code, data);
589 static void __handle_no_data_timeout(GDBusConnection *connection, const gchar *sender_name,
590 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
591 GVariant *parameters, gpointer user_data)
595 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
597 __tethering_h *th = (__tethering_h *)user_data;
598 tethering_type_e type = 0;
599 tethering_disabled_cb dcb = NULL;
601 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_TIMEOUT;
603 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
604 dcb = th->disabled_cb[type];
607 data = th->disabled_user_data[type];
609 dcb(TETHERING_ERROR_NONE, type, code, data);
614 static void __handle_low_battery_mode(GDBusConnection *connection, const gchar *sender_name,
615 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
616 GVariant *parameters, gpointer user_data)
620 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
622 __tethering_h *th = (__tethering_h *)user_data;
623 tethering_type_e type = 0;
624 tethering_disabled_cb dcb = NULL;
626 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_LOW_BATTERY;
628 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
629 dcb = th->disabled_cb[type];
632 data = th->disabled_user_data[type];
634 dcb(TETHERING_ERROR_NONE, type, code, data);
639 static void __handle_flight_mode(GDBusConnection *connection, const gchar *sender_name,
640 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
641 GVariant *parameters, gpointer user_data)
645 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
647 __tethering_h *th = (__tethering_h *)user_data;
648 tethering_type_e type = 0;
649 tethering_disabled_cb dcb = NULL;
651 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_FLIGHT_MODE;
653 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
654 dcb = th->disabled_cb[type];
657 data = th->disabled_user_data[type];
659 dcb(TETHERING_ERROR_NONE, type, code, data);
665 static void __handle_security_type_changed(GDBusConnection *connection, const gchar *sender_name,
666 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
667 GVariant *parameters, gpointer user_data)
672 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
673 __tethering_h *th = (__tethering_h *)user_data;
675 tethering_wifi_security_type_changed_cb scb = NULL;
677 tethering_wifi_security_type_e security_type;
680 scb = th->security_type_changed_cb;
684 g_variant_get(parameters, "(s)", &buf);
685 data = th->security_type_user_data;
686 if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_OPEN_STR) == 0)
687 security_type = TETHERING_WIFI_SECURITY_TYPE_NONE;
688 else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR) == 0)
689 security_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK;
690 else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_WPS_STR) == 0)
691 security_type = TETHERING_WIFI_SECURITY_TYPE_WPS;
693 SERR("Unknown type : %s\n", buf);
698 scb(security_type, data);
703 static void __handle_ssid_visibility_changed(GDBusConnection *connection, const gchar *sender_name,
704 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
705 GVariant *parameters, gpointer user_data)
709 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
710 __tethering_h *th = (__tethering_h *)user_data;
712 tethering_wifi_ssid_visibility_changed_cb scb = NULL;
714 bool visible = false;
717 scb = th->ssid_visibility_changed_cb;
722 g_variant_get(parameters, "(s)", &buf);
723 data = th->ssid_visibility_user_data;
724 if (g_strcmp0(buf, SIGNAL_MSG_SSID_VISIBLE) == 0)
732 static void __handle_passphrase_changed(GDBusConnection *connection, const gchar *sender_name,
733 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
734 GVariant *parameters, gpointer user_data)
738 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
739 __tethering_h *th = (__tethering_h *)user_data;
741 tethering_wifi_passphrase_changed_cb pcb = NULL;
744 pcb = th->passphrase_changed_cb;
748 data = th->passphrase_user_data;
754 static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
759 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
760 GError *g_error = NULL;
763 tethering_error_e error;
764 __tethering_h *th = (__tethering_h *)user_data;
765 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_WIFI];
766 void *data = th->enabled_user_data[TETHERING_TYPE_WIFI];
768 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
771 ERR("DBus error [%s]\n", g_error->message);
772 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
773 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
774 g_error_free(g_error);
775 tethering_enable((tethering_h)th, TETHERING_TYPE_WIFI);
777 } else if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
778 error = TETHERING_ERROR_PERMISSION_DENIED;
780 error = TETHERING_ERROR_OPERATION_FAILED;
781 g_error_free(g_error);
784 g_variant_get(g_var, "(u)", &info);
785 error = __get_error(info);
789 INFO("cfm event : wifi tethering enable info : %d\n", error);
791 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
792 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_ON].name,
793 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
794 sigs[E_SIGNAL_WIFI_TETHER_ON].cb, (gpointer)th, NULL);
800 ecb(error, TETHERING_TYPE_WIFI, true, data);
801 g_variant_unref(g_var);
805 static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
809 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
810 GError *g_error = NULL;
813 tethering_error_e error;
815 __tethering_h *th = (__tethering_h *)user_data;
816 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_BT];
817 void *data = th->enabled_user_data[TETHERING_TYPE_BT];
819 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
822 ERR("DBus error [%s]\n", g_error->message);
823 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
824 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
825 g_error_free(g_error);
826 tethering_enable((tethering_h)th, TETHERING_TYPE_BT);
830 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
831 error = TETHERING_ERROR_PERMISSION_DENIED;
833 error = TETHERING_ERROR_OPERATION_FAILED;
834 g_error_free(g_error);
837 g_variant_get(g_var, "(u)", &info);
838 g_variant_unref(g_var);
839 error = __get_error(info);
843 sigs[E_SIGNAL_BT_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
844 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_ON].name,
845 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
846 sigs[E_SIGNAL_BT_TETHER_ON].cb, (gpointer)th, NULL);
853 ecb(error, TETHERING_TYPE_BT, true, data);
858 static void __usb_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
863 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
864 __tethering_h *th = (__tethering_h *)user_data;
865 GError *g_error = NULL;
868 tethering_error_e error;
869 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_USB];
870 void *data = th->enabled_user_data[TETHERING_TYPE_USB];
872 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
874 ERR("DBus error [%s]\n", g_error->message);
875 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
876 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
877 g_error_free(g_error);
878 tethering_enable((tethering_h)th, TETHERING_TYPE_USB);
882 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
883 error = TETHERING_ERROR_PERMISSION_DENIED;
885 error = TETHERING_ERROR_OPERATION_FAILED;
886 g_error_free(g_error);
888 g_variant_get(g_var, "(u)", &info);
889 g_variant_unref(g_var);
890 error = __get_error(info);
894 sigs[E_SIGNAL_USB_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
895 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_ON].name,
896 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
897 sigs[E_SIGNAL_USB_TETHER_ON].cb, (gpointer)th, NULL);
904 ecb(error, TETHERING_TYPE_USB, true, data);
909 static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res,
914 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
915 GError *g_error = NULL;
917 guint info, event_type;
918 tethering_error_e error;
919 tethering_type_e type;
920 tethering_h tethering = (tethering_h)user_data;
921 __tethering_h *th = (__tethering_h *)tethering;
922 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_REQUEST;
923 tethering_disabled_cb dcb = NULL;
926 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
929 ERR("DBus error [%s]\n", g_error->message);
930 g_error_free(g_error);
934 g_variant_get(g_var, "(uu)", &event_type, &info);
935 INFO("cfm event : %d info : %d\n", event_type, info);
936 g_variant_unref(g_var);
937 error = __get_error(info);
938 INFO("cfm event : %d info : %d\n", event_type, error);
939 switch (event_type) {
940 case MOBILE_AP_DISABLE_WIFI_TETHERING_CFM:
941 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
942 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_OFF].name,
943 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
944 sigs[E_SIGNAL_WIFI_TETHER_OFF].cb, (gpointer)th, NULL);
946 type = TETHERING_TYPE_WIFI;
947 dcb = th->disabled_cb[type];
948 data = th->disabled_user_data[type];
950 dcb(error, type, code, data);
953 case MOBILE_AP_DISABLE_BT_TETHERING_CFM:
954 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
955 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_OFF].name,
956 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
957 sigs[E_SIGNAL_BT_TETHER_OFF].cb, (gpointer)th, NULL);
959 type = TETHERING_TYPE_BT;
960 dcb = th->disabled_cb[type];
961 data = th->disabled_user_data[type];
963 dcb(error, type, code, data);
967 case MOBILE_AP_DISABLE_USB_TETHERING_CFM:
968 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
969 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
970 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
971 sigs[E_SIGNAL_USB_TETHER_OFF].cb, (gpointer)th, NULL);
973 type = TETHERING_TYPE_USB;
974 dcb = th->disabled_cb[type];
975 data = th->disabled_user_data[type];
977 dcb(error, type, code, data);
981 case MOBILE_AP_DISABLE_CFM:
983 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
984 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_OFF].name,
985 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
986 sigs[E_SIGNAL_WIFI_TETHER_OFF].cb, (gpointer)th, NULL);
987 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
988 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_OFF].name,
989 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
990 sigs[E_SIGNAL_BT_TETHER_OFF].cb, (gpointer)th, NULL);
991 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
992 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
993 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
994 sigs[E_SIGNAL_USB_TETHER_OFF].cb, (gpointer)th, NULL);
996 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
997 dcb = th->disabled_cb[type];
1000 data = th->disabled_user_data[type];
1002 dcb(error, type, code, data);
1007 ERR("Invalid event\n");
1013 static void __get_data_usage_cb(GObject *source_object, GAsyncResult *res,
1018 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1020 GError *g_error = NULL;
1023 guint64 tx_bytes, rx_bytes;
1024 __tethering_h *th = (__tethering_h *)user_data;
1025 tethering_error_e tethering_error = TETHERING_ERROR_NONE;
1028 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1031 ERR("DBus fail [%s]\n", g_error->message);
1032 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1033 tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1035 tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1040 if (th->data_usage_cb == NULL) {
1041 ERR("There is no data_usage_cb\n");
1045 th->data_usage_cb(tethering_error, 0LL, 0LL, th->data_usage_user_data);
1047 g_variant_get(g_var, "(utt)", &event_type, &tx_bytes, &rx_bytes);
1048 th->data_usage_cb(TETHERING_ERROR_NONE,
1049 rx_bytes, tx_bytes, th->data_usage_user_data);
1050 g_variant_unref(g_var);
1052 th->data_usage_cb = NULL;
1053 th->data_usage_user_data = NULL;
1058 static void __settings_reloaded_cb(GObject *source_object, GAsyncResult *res,
1063 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1064 GError *g_error = NULL;
1067 __tethering_h *th = (__tethering_h *)user_data;
1068 tethering_error_e tethering_error;
1070 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1072 ERR("DBus fail [%s]\n", g_error->message);
1073 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1074 tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1076 tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1077 g_error_free(g_error);
1079 if (th->settings_reloaded_cb == NULL) {
1080 DBG("There is no settings_reloaded_cb\n-\n");
1083 g_variant_get(g_var, "(u)", &info);
1084 tethering_error = __get_error(info);
1085 g_variant_unref(g_var);
1087 th->settings_reloaded_cb(tethering_error,
1088 th->settings_reloaded_user_data);
1090 th->settings_reloaded_cb = NULL;
1091 th->settings_reloaded_user_data = NULL;
1095 static void __connect_signals(tethering_h tethering)
1098 _retm_if(tethering == NULL, "parameter(tethering) is NULL\n");
1100 __tethering_h *th = (__tethering_h *)tethering;
1101 GDBusConnection *connection = th->client_bus;
1104 for (i = E_SIGNAL_NET_CLOSED; i < E_SIGNAL_MAX; i++) {
1105 sigs[i].sig_id = g_dbus_connection_signal_subscribe(connection,
1106 NULL, TETHERING_SERVICE_INTERFACE, sigs[i].name,
1107 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1108 sigs[i].cb, tethering, NULL);
1113 static void __disconnect_signals(tethering_h tethering)
1117 _retm_if(tethering == NULL, "parameter(tethering) is NULL\n");
1119 __tethering_h *th = (__tethering_h *)tethering;
1120 GDBusConnection *connection = th->client_bus;
1124 for (i = E_SIGNAL_NET_CLOSED; i < E_SIGNAL_MAX; i++)
1125 g_dbus_connection_signal_unsubscribe(connection, sigs[i].sig_id);
1131 static bool __get_intf_name(tethering_type_e type, char *buf, unsigned int len)
1133 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1137 case TETHERING_TYPE_USB:
1138 g_strlcpy(buf, TETHERING_USB_IF, len);
1141 case TETHERING_TYPE_WIFI:
1142 g_strlcpy(buf, TETHERING_WIFI_IF, len);
1145 case TETHERING_TYPE_BT:
1146 g_strlcpy(buf, TETHERING_BT_IF, len);
1150 ERR("Not supported type : %d\n", type);
1156 static bool __get_gateway_addr(tethering_type_e type, char *buf, unsigned int len)
1158 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1161 case TETHERING_TYPE_USB:
1162 g_strlcpy(buf, TETHERING_USB_GATEWAY, len);
1165 case TETHERING_TYPE_WIFI:
1166 g_strlcpy(buf, TETHERING_WIFI_GATEWAY, len);
1169 case TETHERING_TYPE_BT:
1170 g_strlcpy(buf, TETHERING_BT_GATEWAY, len);
1174 ERR("Not supported type : %d\n", type);
1180 static int __get_common_ssid(char *ssid, unsigned int size)
1183 ERR("ssid is null\n"); //LCOV_EXCL_LINE
1184 return TETHERING_ERROR_INVALID_PARAMETER;
1188 char *ptr_tmp = NULL;
1190 ptr = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
1192 ERR("vconf_get_str is failed and set default ssid");
1193 g_strlcpy(ssid, TETHERING_DEFAULT_SSID, size);
1195 g_strlcpy(ssid, ptr, size);
1199 if (!g_utf8_validate(ssid, -1, (const char **)&ptr_tmp))
1202 return TETHERING_ERROR_NONE;
1205 static bool __get_wifi_mode_type(tethering_wifi_mode_type_e type, char **buf)
1207 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1210 case TETHERING_WIFI_MODE_TYPE_B:
1211 *buf = g_strdup("b");
1213 case TETHERING_WIFI_MODE_TYPE_G:
1214 *buf = g_strdup("g");
1216 case TETHERING_WIFI_MODE_TYPE_A:
1217 *buf = g_strdup("a");
1219 case TETHERING_WIFI_MODE_TYPE_AD:
1220 *buf = g_strdup("ad");
1223 ERR("Not supported type : %d\n", type);
1229 static int __prepare_wifi_settings(tethering_h tethering, _softap_settings_t *set)
1233 __tethering_h *th = (__tethering_h *)tethering;
1234 tethering_error_e ret = TETHERING_ERROR_NONE;
1237 if (th == NULL || set == NULL) {
1238 ERR("null parameter\n-\n");
1239 return TETHERING_ERROR_INVALID_PARAMETER;
1242 if (th->ssid == NULL)
1243 __get_common_ssid(set->ssid, sizeof(set->ssid));
1245 g_strlcpy(set->ssid, th->ssid, sizeof(set->ssid));
1247 ret = __get_security_type(&set->sec_type);
1248 if (ret != TETHERING_ERROR_NONE)
1249 set->sec_type = th->sec_type;
1251 ret = __get_visible(&set->visibility);
1252 if (ret != TETHERING_ERROR_NONE)
1253 set->visibility = th->visibility;
1255 set->mac_filter = th->mac_filter;
1256 set->max_connected = th->wifi_max_connected;
1257 set->channel = th->channel;
1259 __get_wifi_mode_type(th->mode_type, &ptr);
1261 g_strlcpy(set->mode, "", sizeof(set->mode));
1263 g_strlcpy(set->mode, ptr, sizeof(set->mode));
1267 if (set->sec_type == TETHERING_WIFI_SECURITY_TYPE_NONE) {
1268 g_strlcpy(set->key, "", sizeof(set->key));
1270 GDBusProxy *proxy = th->client_bus_proxy;
1271 GVariant *parameters;
1272 GError *error = NULL;
1273 char *passphrase = NULL;
1274 unsigned int len = 0;
1276 parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_passphrase",
1277 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1281 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
1283 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
1284 ret = TETHERING_ERROR_PERMISSION_DENIED;
1286 ret = TETHERING_ERROR_OPERATION_FAILED;
1288 g_error_free(error);
1293 if (parameters != NULL) {
1294 g_variant_get(parameters, "(siu)", &passphrase, &len, &ret);
1295 g_variant_unref(parameters);
1298 g_strlcpy(set->key, passphrase, sizeof(set->key));
1301 INFO("ssid: %s security: %d mode: %s channel: %d visibility: %s\n",
1302 set->ssid, set->sec_type, set->mode, set->channel,
1303 (set->visibility) ? "true" : "false");
1305 return TETHERING_ERROR_NONE;
1308 static bool __check_precondition(tethering_type_e type)
1311 int cellular_state = 0;
1314 /* data network through cellular */
1315 vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &cellular_state);
1316 if (cellular_state == VCONFKEY_NETWORK_CELLULAR_ON) {
1317 INFO("Data Network can be connected later");
1322 /* data network through ethernet */
1323 vconf_get_int(VCONFKEY_NETWORK_STATUS, &dnet_state);
1324 if (dnet_state == VCONFKEY_NETWORK_ETHERNET) {
1325 INFO("Data Network is connected");
1329 vconf_get_int(VCONFKEY_DNET_STATE, &dnet_state);
1330 if (dnet_state > VCONFKEY_DNET_OFF) {
1331 INFO("Data Network is connected");
1334 #endif/*TIZEN_TV_EXT*/
1336 /* data network through wifi */
1337 if (type != TETHERING_TYPE_WIFI) {
1338 vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state);
1339 if (wifi_state > VCONFKEY_WIFI_UNCONNECTED) {
1340 INFO("Wi-Fi is connected!");
1345 ERR("Network is not available!");
1351 * @brief Creates the handle of tethering.
1353 * @privlevel platform
1354 * @privilege http://tizen.org/privilege/tethering.admin
1355 * @remarks The @a tethering must be released tethering_destroy() by you.
1356 * @param[out] tethering A handle of a new mobile ap handle on success
1357 * @return 0 on success, otherwise a negative error value.
1358 * @retval #TETHERING_ERROR_NONE Successful
1359 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1360 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1361 * @retval #TETHERING_ERROR_NOT_SUPPORT_API API is not supported
1362 * @see tethering_destroy()
1364 API int tethering_create(tethering_h *tethering)
1366 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1367 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1368 "parameter(tethering) is NULL\n");
1371 __tethering_h *th = NULL;
1372 GError *error = NULL;
1373 char ssid[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
1375 th = (__tethering_h *)malloc(sizeof(__tethering_h));
1377 _retvm_if(th == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
1378 "malloc is failed\n");
1379 memset(th, 0x00, sizeof(__tethering_h));
1380 th->sec_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK;
1381 th->visibility = true;
1382 th->mac_filter = false;
1384 th->mode_type = TETHERING_WIFI_MODE_TYPE_G;
1385 th->wifi_max_connected = TETHERING_WIFI_MAX_STA;
1387 if (__generate_initial_passphrase(th->passphrase,
1388 sizeof(th->passphrase)) == 0) {
1389 ERR("random passphrase generation failed\n"); //LCOV_EXCL_LINE
1391 return TETHERING_ERROR_OPERATION_FAILED;
1394 if (__get_common_ssid(ssid, sizeof(ssid)) != TETHERING_ERROR_NONE) {
1395 ERR("common ssid get failed\n"); //LCOV_EXCL_LINE
1397 return TETHERING_ERROR_OPERATION_FAILED;
1400 #if !GLIB_CHECK_VERSION(2, 36, 0)
1403 GCancellable *cancellable = g_cancellable_new();
1404 th->client_bus = g_bus_get_sync(DBUS_BUS_SYSTEM, cancellable, &error);
1407 ERR("Couldn't connect to the System bus[%s]", error->message);
1408 g_error_free(error);
1409 g_cancellable_cancel(cancellable);
1410 g_object_unref(cancellable);
1412 return TETHERING_ERROR_OPERATION_FAILED;
1415 th->cancellable = cancellable;
1417 th->client_bus_proxy = g_dbus_proxy_new_sync(th->client_bus, G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION,
1418 NULL, TETHERING_SERVICE_NAME, TETHERING_SERVICE_OBJECT_PATH,
1419 TETHERING_SERVICE_INTERFACE, th->cancellable, &error);
1420 if (!th->client_bus_proxy) {
1423 ERR("Couldn't create the proxy object because of %s\n", error->message);
1424 g_cancellable_cancel(th->cancellable);
1425 g_object_unref(th->cancellable);
1426 g_object_unref(th->client_bus);
1428 return TETHERING_ERROR_OPERATION_FAILED;
1432 __connect_signals((tethering_h)th);
1434 *tethering = (tethering_h)th;
1435 INFO("Tethering Handle : 0x%X\n", th);
1437 return TETHERING_ERROR_NONE;
1442 * @brief Destroys the handle of tethering.
1444 * @privlevel platform
1445 * @privilege http://tizen.org/privilege/tethering.admin
1446 * @param[in] tethering The handle of tethering
1447 * @return 0 on success, otherwise a negative error value.
1448 * @retval #TETHERING_ERROR_NONE Successful
1449 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1450 * @see tethering_create()
1452 API int tethering_destroy(tethering_h tethering)
1455 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1456 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1457 "parameter(tethering) is NULL\n");
1459 __tethering_h *th = (__tethering_h *)tethering;
1461 INFO("Tethering Handle : 0x%X\n", th);
1463 __disconnect_signals(tethering);
1468 g_object_unref(th->cancellable);
1469 g_object_unref(th->client_bus_proxy);
1470 g_object_unref(th->client_bus);
1471 memset(th, 0x00, sizeof(__tethering_h));
1475 return TETHERING_ERROR_NONE;
1480 * @brief Enables the tethering, asynchronously.
1482 * @privlevel platform
1483 * @privilege http://tizen.org/privilege/tethering.admin
1484 * @param[in] tethering The handle of tethering
1485 * @param[in] type The type of tethering
1486 * @return 0 on success, otherwise negative error value.
1487 * @retval #TETHERING_ERROR_NONE Successful
1488 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1489 * @post tethering_enabled_cb() will be invoked.
1490 * @see tethering_is_enabled()
1491 * @see tethering_disable()
1493 API int tethering_enable(tethering_h tethering, tethering_type_e type)
1495 INFO("+ type : %d\n", type);
1496 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1497 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1498 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1499 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1501 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1502 "parameter(tethering) is NULL\n");
1504 tethering_error_e ret = TETHERING_ERROR_NONE;
1505 __tethering_h *th = (__tethering_h *)tethering;
1506 GDBusProxy *proxy = th->client_bus_proxy;
1507 GDBusConnection *connection = th->client_bus;
1509 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
1511 if (__check_precondition(type) == FALSE) {
1514 return TETHERING_ERROR_OPERATION_FAILED;
1520 case TETHERING_TYPE_USB:
1521 g_dbus_connection_signal_unsubscribe(connection,
1522 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1524 g_dbus_proxy_call(proxy, "enable_usb_tethering", NULL,
1525 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1526 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1530 case TETHERING_TYPE_WIFI: {
1531 _softap_settings_t set = {"", "", "", 0, false};
1533 ret = __prepare_wifi_settings(tethering, &set);
1534 if (ret != TETHERING_ERROR_NONE) {
1535 ERR("softap settings initialization failed\n");
1537 return TETHERING_ERROR_OPERATION_FAILED;
1539 g_dbus_connection_signal_unsubscribe(connection,
1540 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1542 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1543 g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, TETHERING_ADDRESS_FAMILY_IPV4),
1544 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1545 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1549 case TETHERING_TYPE_BT:
1550 g_dbus_connection_signal_unsubscribe(connection,
1551 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1553 g_dbus_proxy_call(proxy, "enable_bt_tethering",
1554 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1555 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1556 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1561 case TETHERING_TYPE_ALL: {
1562 _softap_settings_t set = {"", "", "", 0, false};
1564 ret = __prepare_wifi_settings(tethering, &set);
1565 if (ret != TETHERING_ERROR_NONE) {
1566 ERR("softap settings initialization failed\n");
1567 return TETHERING_ERROR_OPERATION_FAILED;
1570 /* TETHERING_TYPE_USB */
1571 g_dbus_connection_signal_unsubscribe(connection,
1572 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1574 g_dbus_proxy_call(proxy, "enable_usb_tethering", NULL,
1575 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1576 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1578 /* TETHERING_TYPE_WIFI */
1579 g_dbus_connection_signal_unsubscribe(connection,
1580 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1582 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1583 g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode,
1584 set.channel, set.visibility, set.mac_filter, set.max_connected,
1585 set.sec_type, TETHERING_ADDRESS_FAMILY_IPV4),
1586 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1587 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1589 /* TETHERING_TYPE_BT */
1590 g_dbus_connection_signal_unsubscribe(connection,
1591 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1593 g_dbus_proxy_call(proxy, "enable_bt_tethering",
1594 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1595 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1596 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1601 ERR("Unknown type : %d\n", type);
1603 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1606 return TETHERING_ERROR_INVALID_PARAMETER;
1609 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1611 return TETHERING_ERROR_NONE;
1614 API int tethering_ipv6_enable(tethering_h tethering, tethering_type_e type)
1616 DBG("+ type : %d\n", type);
1617 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1618 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1619 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1620 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1622 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1623 "parameter(tethering) is NULL\n");
1625 __tethering_h *th = (__tethering_h *)tethering;
1626 GDBusProxy *proxy = th->client_bus_proxy;
1627 GDBusConnection *connection = th->client_bus;
1630 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
1632 if (__check_precondition(type) == FALSE) {
1635 return TETHERING_ERROR_OPERATION_FAILED;
1641 case TETHERING_TYPE_WIFI: {
1642 _softap_settings_t set = {"", "", "", 0, false, false, 0, 0};
1644 ret = __prepare_wifi_settings(tethering, &set);
1645 if (ret != TETHERING_ERROR_NONE) {
1646 ERR("softap settings initialization failed\n");
1648 return TETHERING_ERROR_OPERATION_FAILED;
1650 g_dbus_connection_signal_unsubscribe(connection,
1651 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1652 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1653 g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, TETHERING_ADDRESS_FAMILY_IPV6),
1654 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1655 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1658 case TETHERING_TYPE_BT: {
1659 g_dbus_connection_signal_unsubscribe(connection,
1660 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1663 g_dbus_proxy_call(proxy, "enable_bt_tethering", g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1664 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1665 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1671 ERR("Unknown type : %d\n", type);
1673 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1676 return TETHERING_ERROR_INVALID_PARAMETER;
1680 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1682 return TETHERING_ERROR_NONE;
1685 API int tethering_ipv6_disable(tethering_h tethering, tethering_type_e type)
1687 DBG("+ type : %d\n", type);
1688 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1689 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1690 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1691 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1693 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1694 "parameter(tethering) is NULL\n");
1696 __tethering_h *th = (__tethering_h *)tethering;
1697 GDBusProxy *proxy = th->client_bus_proxy;
1698 GDBusConnection *connection = th->client_bus;
1701 case TETHERING_TYPE_WIFI:
1702 DBG("Disable wifi tethering..");
1703 g_dbus_connection_signal_unsubscribe(connection,
1704 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1706 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1707 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1708 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1709 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1711 case TETHERING_TYPE_BT:
1712 g_dbus_connection_signal_unsubscribe(connection,
1713 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1715 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1716 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1717 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1718 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1722 ERR("Not supported tethering type [%d]\n", type);
1724 return TETHERING_ERROR_INVALID_PARAMETER;
1727 return TETHERING_ERROR_NONE;
1731 * @brief Disables the tethering, asynchronously.
1733 * @privlevel platform
1734 * @privilege http://tizen.org/privilege/tethering.admin
1735 * @param[in] tethering The handle of tethering
1736 * @param[in] type The type of tethering
1737 * @return 0 on success, otherwise negative error value.
1738 * @retval #TETHERING_ERROR_NONE Successful
1739 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1740 * @post tethering_disabled_cb() will be invoked.
1741 * @see tethering_is_enabled()
1742 * @see tethering_enable()
1744 API int tethering_disable(tethering_h tethering, tethering_type_e type)
1746 INFO("+ type : %d\n", type);
1747 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1748 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1749 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1750 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1752 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1753 "parameter(tethering) is NULL\n");
1755 __tethering_h *th = (__tethering_h *)tethering;
1756 GDBusProxy *proxy = th->client_bus_proxy;
1757 GDBusConnection *connection = th->client_bus;
1760 case TETHERING_TYPE_USB:
1761 g_dbus_connection_signal_unsubscribe(connection,
1762 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1764 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1765 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1766 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1770 case TETHERING_TYPE_WIFI:
1772 g_dbus_connection_signal_unsubscribe(connection,
1773 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1775 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1776 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1777 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1778 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1781 case TETHERING_TYPE_BT:
1783 g_dbus_connection_signal_unsubscribe(connection,
1784 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1786 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1787 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1788 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1789 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1792 case TETHERING_TYPE_ALL:
1793 g_dbus_connection_signal_unsubscribe(connection,
1794 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1796 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1797 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1798 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1800 g_dbus_connection_signal_unsubscribe(connection,
1801 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1803 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1804 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1805 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1806 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1808 g_dbus_connection_signal_unsubscribe(connection,
1809 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1811 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1812 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1813 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1814 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1818 ERR("Not supported tethering type [%d]\n", type);
1820 return TETHERING_ERROR_INVALID_PARAMETER;
1823 return TETHERING_ERROR_NONE;
1828 * @brief Checks whetehr the tethering is enabled or not.
1830 * @privlevel platform
1831 * @privilege http://tizen.org/privilege/tethering.admin
1832 * @param[in] tethering The handle of tethering
1833 * @param[in] type The type of tethering
1834 * @return @c true if tethering is enabled, \n @c false if tethering is disabled.
1836 API bool tethering_is_enabled(tethering_h tethering, tethering_type_e type)
1838 INFO("+ type : %d\n", type);
1840 int vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_NONE;
1842 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1844 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &is_on) != 0)
1848 case TETHERING_TYPE_USB:
1849 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_USB;
1852 case TETHERING_TYPE_WIFI:
1853 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI;
1856 case TETHERING_TYPE_BT:
1857 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_BT;
1861 ERR("Not supported type : %d\n", type);
1864 INFO("- enabled: %s\n", (is_on & vconf_type) ? "true" : "false");
1865 return is_on & vconf_type ? true : false;
1870 * @brief Gets the MAC address of local device as "FC:A1:3E:D6:B1:B1".
1872 * @privlevel platform
1873 * @privilege http://tizen.org/privilege/tethering.admin
1874 * @remarks @a mac_address must be released with free() by you.
1875 * @param[in] tethering The handle of tethering
1876 * @param[in] type The type of tethering
1877 * @param[out] mac_address The MAC address
1878 * @return 0 on success, otherwise a negative error value.
1879 * @retval #TETHERING_ERROR_NONE Successful
1880 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1881 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1882 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
1883 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
1884 * @pre tethering must be enabled.
1885 * @see tethering_is_enabled()
1886 * @see tethering_enable()
1888 API int tethering_get_mac_address(tethering_h tethering, tethering_type_e type, char **mac_address)
1890 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1891 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1892 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1893 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1895 _retvm_if(tethering_is_enabled(tethering, type) == false,
1896 TETHERING_ERROR_NOT_ENABLED,
1897 "tethering type[%d] is not enabled\n", type);
1898 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1899 "parameter(tethering) is NULL\n");
1900 _retvm_if(mac_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1901 "parameter(mac_address) is NULL\n");
1905 char *macbuf = NULL;
1907 _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
1908 TETHERING_ERROR_OPERATION_FAILED,
1909 "getting interface name is failed\n");
1911 s = socket(AF_INET, SOCK_DGRAM, 0);
1912 _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
1913 "getting socket is failed\n");
1914 if (ioctl(s, SIOCGIFHWADDR, &ifr) < 0) {
1915 ERR("getting mac is failed\n");
1917 return TETHERING_ERROR_OPERATION_FAILED;
1921 macbuf = (char *)malloc(TETHERING_STR_INFO_LEN);
1922 _retvm_if(macbuf == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
1923 "Not enough memory\n");
1924 snprintf(macbuf, TETHERING_STR_INFO_LEN, "%02X:%02X:%02X:%02X:%02X:%02X",
1925 (unsigned char)ifr.ifr_hwaddr.sa_data[0],
1926 (unsigned char)ifr.ifr_hwaddr.sa_data[1],
1927 (unsigned char)ifr.ifr_hwaddr.sa_data[2],
1928 (unsigned char)ifr.ifr_hwaddr.sa_data[3],
1929 (unsigned char)ifr.ifr_hwaddr.sa_data[4],
1930 (unsigned char)ifr.ifr_hwaddr.sa_data[5]);
1932 *mac_address = macbuf;
1934 return TETHERING_ERROR_NONE;
1939 * @brief Gets the name of network interface. For example, usb0.
1941 * @privlevel platform
1942 * @privilege http://tizen.org/privilege/tethering.admin
1943 * @remarks @a interface_name must be released with free() by you.
1944 * @param[in] tethering The handle of tethering
1945 * @param[in] type The type of tethering
1946 * @param[out] interface_name The name of network interface
1947 * @return 0 on success, otherwise negative error value.
1948 * @retval #TETHERING_ERROR_NONE Successful
1949 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1950 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1951 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
1952 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
1953 * @pre tethering must be enabled.
1954 * @see tethering_is_enabled()
1955 * @see tethering_enable()
1957 API int tethering_get_network_interface_name(tethering_h tethering, tethering_type_e type, char **interface_name)
1959 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1960 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1961 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1962 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1964 _retvm_if(tethering_is_enabled(tethering, type) == false,
1965 TETHERING_ERROR_NOT_ENABLED,
1966 "tethering type[%d] is not enabled\n", type);
1967 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1968 "parameter(tethering) is NULL\n");
1969 _retvm_if(interface_name == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1970 "parameter(interface_name) is NULL\n");
1972 char intf[TETHERING_STR_INFO_LEN] = {0, };
1974 _retvm_if(!__get_intf_name(type, intf, sizeof(intf)),
1975 TETHERING_ERROR_OPERATION_FAILED,
1976 "getting interface name is failed\n");
1977 *interface_name = strdup(intf);
1978 _retvm_if(*interface_name == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
1979 "Not enough memory\n");
1981 return TETHERING_ERROR_NONE;
1986 * @brief Gets the local IP address.
1988 * @privlevel platform
1989 * @privilege http://tizen.org/privilege/tethering.admin
1990 * @remarks @a ip_address must be released with free() by you.
1991 * @param[in] tethering The handle of tethering
1992 * @param[in] type The type of tethering
1993 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
1994 * @param[out] ip_address The local IP address
1995 * @return 0 on success, otherwise negative error value.
1996 * @retval #TETHERING_ERROR_NONE Successful
1997 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1998 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1999 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2000 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2001 * @pre tethering must be enabled.
2002 * @see tethering_is_enabled()
2003 * @see tethering_enable()
2005 API int tethering_get_ip_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **ip_address)
2007 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2008 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2009 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2010 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2012 _retvm_if(tethering_is_enabled(tethering, type) == false,
2013 TETHERING_ERROR_NOT_ENABLED,
2014 "tethering type[%d] is not enabled\n", type);
2015 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2016 "parameter(tethering) is NULL\n");
2017 _retvm_if(ip_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2018 "parameter(ip_address) is NULL\n");
2024 _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
2025 TETHERING_ERROR_OPERATION_FAILED,
2026 "getting interface name is failed\n");
2028 s = socket(AF_INET, SOCK_DGRAM, 0);
2029 _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
2030 "getting socket is failed\n");
2031 if (ioctl(s, SIOCGIFADDR, &ifr) < 0) {
2032 ERR("ioctl is failed\n");
2034 return TETHERING_ERROR_OPERATION_FAILED;
2038 ipbuf = inet_ntoa(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr);
2039 *ip_address = strdup(ipbuf);
2040 _retvm_if(*ip_address == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2041 "Not enough memory\n");
2043 return TETHERING_ERROR_NONE;
2048 * @brief Gets the Gateway address.
2050 * @privlevel platform
2051 * @privilege http://tizen.org/privilege/tethering.admin
2052 * @remarks @a gateway_address must be released with free() by you.
2053 * @param[in] tethering The handle of tethering
2054 * @param[in] type The type of tethering
2055 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2056 * @param[out] gateway_address The local IP address
2057 * @return 0 on success, otherwise negative error value.
2058 * @retval #TETHERING_ERROR_NONE Successful
2059 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2060 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2061 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2062 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2063 * @pre tethering must be enabled.
2064 * @see tethering_is_enabled()
2065 * @see tethering_enable()
2067 API int tethering_get_gateway_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **gateway_address)
2069 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2070 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2071 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2072 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2074 _retvm_if(tethering_is_enabled(tethering, type) == false,
2075 TETHERING_ERROR_NOT_ENABLED,
2076 "tethering type[%d] is not enabled\n", type);
2077 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2078 "parameter(tethering) is NULL\n");
2079 _retvm_if(gateway_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2080 "parameter(gateway_address) is NULL\n");
2082 char gateway_buf[TETHERING_STR_INFO_LEN] = {0, };
2084 _retvm_if(!__get_gateway_addr(type, gateway_buf, sizeof(gateway_buf)),
2085 TETHERING_ERROR_OPERATION_FAILED,
2086 "getting gateway address is failed\n");
2088 *gateway_address = strdup(gateway_buf);
2090 return TETHERING_ERROR_NONE;
2095 * @brief Gets the Subnet Mask.
2097 * @privlevel platform
2098 * @privilege http://tizen.org/privilege/tethering.admin
2099 * @remarks @a subnet_mask must be released with free() by you.
2100 * @param[in] tethering The handle of tethering
2101 * @param[in] type The type of tethering
2102 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2103 * @param[out] subnet_mask The local IP address
2104 * @return 0 on success, otherwise negative error value.
2105 * @retval #TETHERING_ERROR_NONE Successful
2106 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2107 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2108 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2109 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2110 * @pre tethering must be enabled.
2111 * @see tethering_is_enabled()
2112 * @see tethering_enable()
2114 API int tethering_get_subnet_mask(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **subnet_mask)
2116 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2117 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2118 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2119 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2121 _retvm_if(tethering_is_enabled(tethering, type) == false,
2122 TETHERING_ERROR_NOT_ENABLED,
2123 "tethering is not enabled\n");
2124 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2125 "parameter(tethering) is NULL\n");
2126 _retvm_if(subnet_mask == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2127 "parameter(subnet_mask) is NULL\n");
2129 *subnet_mask = strdup(TETHERING_SUBNET_MASK);
2130 _retvm_if(*subnet_mask == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2131 "Not enough memory\n");
2133 return TETHERING_ERROR_NONE;
2138 * @brief Gets the data usage.
2140 * @privlevel platform
2141 * @privilege http://tizen.org/privilege/tethering.admin
2142 * @param[in] tethering The handle of tethering
2143 * @param[out] usage The data usage
2144 * @return 0 on success, otherwise negative error value.
2145 * @retval #TETHERING_ERROR_NONE Successful
2146 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2147 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2148 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2149 * @pre tethering must be enabled.
2150 * @see tethering_is_enabled()
2151 * @see tethering_enable()
2153 API int tethering_get_data_usage(tethering_h tethering, tethering_data_usage_cb callback, void *user_data)
2155 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2157 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2158 "parameter(tethering) is NULL\n");
2159 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2160 "parameter(callback) is NULL\n");
2161 _retvm_if(__any_tethering_is_enabled(tethering) == false,
2162 TETHERING_ERROR_NOT_ENABLED,
2163 "tethering is not enabled\n");
2165 __tethering_h *th = (__tethering_h *)tethering;
2166 GDBusProxy *proxy = th->client_bus_proxy;
2168 th->data_usage_cb = callback;
2169 th->data_usage_user_data = user_data;
2171 g_dbus_proxy_call(proxy, "get_data_packet_usage",
2172 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2173 (GAsyncReadyCallback) __get_data_usage_cb, (gpointer)tethering);
2175 return TETHERING_ERROR_NONE;
2180 * @brief Gets the client which is connected by tethering "type".
2182 * @privlevel platform
2183 * @privilege http://tizen.org/privilege/tethering.admin
2184 * @param[in] tethering The handle of tethering
2185 * @param[in] type The type of tethering
2186 * @param[in] callback The callback function to invoke
2187 * @param[in] user_data The user data to be passed to the callback function
2188 * @retval #TETHERING_ERROR_NONE Successful
2189 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2190 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2191 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2192 * @pre tethering must be enabled.
2193 * @see tethering_is_enabled()
2194 * @see tethering_enable()
2196 API int tethering_foreach_connected_clients(tethering_h tethering, tethering_type_e type, tethering_connected_client_cb callback, void *user_data)
2198 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2199 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2200 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2201 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2203 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2204 "parameter(tethering) is NULL\n");
2205 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2206 "parameter(callback) is NULL\n");
2207 _retvm_if(__any_tethering_is_enabled(tethering) == false,
2208 TETHERING_ERROR_NOT_ENABLED,
2209 "tethering is not enabled\n");
2211 mobile_ap_type_e interface;
2212 __tethering_h *th = (__tethering_h *)tethering;
2213 __tethering_client_h client = {0, };
2216 gchar *hostname = NULL;
2217 guint timestamp = 0;
2218 GError *error = NULL;
2219 GVariant *result = NULL;
2220 GVariantIter *outer_iter = NULL;
2221 GVariantIter *inner_iter = NULL;
2222 GVariant *station = NULL;
2223 GVariant *value = NULL;
2226 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "get_station_info",
2227 NULL, G_DBUS_CALL_FLAGS_NONE,
2228 -1, th->cancellable, &error);
2230 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
2231 g_variant_get(result, "(a(a{sv}))", &outer_iter);
2232 while (g_variant_iter_loop(outer_iter, "(@a{sv})", &station)) {
2233 g_variant_get(station, "a{sv}", &inner_iter);
2234 while (g_variant_iter_loop(inner_iter, "{sv}", &key, &value)) {
2235 if (g_strcmp0(key, "Type") == 0) {
2236 interface = g_variant_get_int32(value);
2237 if (interface == MOBILE_AP_TYPE_USB)
2238 client.interface = TETHERING_TYPE_USB;
2239 else if (interface == MOBILE_AP_TYPE_WIFI)
2240 client.interface = TETHERING_TYPE_WIFI;
2241 else if (interface == MOBILE_AP_TYPE_BT)
2242 client.interface = TETHERING_TYPE_BT;
2244 ERR("Invalid interface\n");
2246 g_variant_unref(value);
2249 DBG("interface is %d\n", client.interface);
2250 if (client.interface != type && (TETHERING_TYPE_ALL != type)) {
2252 g_variant_unref(value);
2255 } else if (g_strcmp0(key, "IP") == 0) {
2256 g_variant_get(value, "s", &ip);
2257 SDBG("ip is %s\n", ip);
2258 g_strlcpy(client.ip, ip, sizeof(client.ip));
2259 } else if (g_strcmp0(key, "MAC") == 0) {
2260 g_variant_get(value, "s", &mac);
2261 SDBG("mac is %s\n", mac);
2262 g_strlcpy(client.mac, mac, sizeof(client.mac));
2263 } else if (g_strcmp0(key, "Name") == 0) {
2264 g_variant_get(value, "s", &hostname);
2265 SDBG("hsotname is %s\n", hostname);
2267 client.hostname = g_strdup(hostname);
2268 } else if (g_strcmp0(key, "Time") == 0) {
2269 timestamp = g_variant_get_int32(value);
2270 DBG("timestamp is %d\n", timestamp);
2271 client.tm = (time_t)timestamp;
2273 ERR("Key %s not required\n", key);
2279 g_variant_iter_free(inner_iter);
2280 if (callback((tethering_client_h)&client, user_data) == false) {
2281 DBG("iteration is stopped\n");
2282 g_free(client.hostname);
2283 g_variant_iter_free(outer_iter);
2284 g_variant_unref(station);
2285 g_variant_unref(result);
2287 return TETHERING_ERROR_OPERATION_FAILED;
2289 g_free(client.hostname);
2291 g_variant_iter_free(outer_iter);
2292 g_variant_unref(station);
2293 g_variant_unref(result);
2295 return TETHERING_ERROR_NONE;
2300 * @brief Registers the callback function called when tethering is enabled.
2302 * @privlevel platform
2303 * @privilege http://tizen.org/privilege/tethering.admin
2304 * @param[in] tethering The handle of tethering
2305 * @param[in] type The type of tethering
2306 * @param[in] callback The callback function to invoke
2307 * @param[in] user_data The user data to be passed to the callback function
2308 * @retval #TETHERING_ERROR_NONE Successful
2309 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2310 * @see tethering_unset_enabled_cb()
2312 API int tethering_set_enabled_cb(tethering_h tethering, tethering_type_e type, tethering_enabled_cb callback, void *user_data)
2314 INFO("+ type: %d\n", type);
2315 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2316 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2317 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2318 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2320 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2321 "parameter(tethering) is NULL\n");
2322 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2323 "parameter(callback) is NULL\n");
2325 __tethering_h *th = (__tethering_h *)tethering;
2326 tethering_type_e ti;
2328 if (type != TETHERING_TYPE_ALL) {
2329 th->enabled_cb[type] = callback;
2330 th->enabled_user_data[type] = user_data;
2332 return TETHERING_ERROR_NONE;
2335 /* TETHERING_TYPE_ALL */
2336 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2337 th->enabled_cb[ti] = callback;
2338 th->enabled_user_data[ti] = user_data;
2342 return TETHERING_ERROR_NONE;
2347 * @brief Unregisters the callback function called when tethering is disabled.
2349 * @privlevel platform
2350 * @privilege http://tizen.org/privilege/tethering.admin
2351 * @param[in] tethering The handle of tethering
2352 * @param[in] type The type of tethering
2353 * @retval #TETHERING_ERROR_NONE Successful
2354 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2355 * @see tethering_set_enabled_cb()
2357 API int tethering_unset_enabled_cb(tethering_h tethering, tethering_type_e type)
2359 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2360 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2361 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2362 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2364 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2365 "parameter(tethering) is NULL\n");
2367 __tethering_h *th = (__tethering_h *)tethering;
2368 tethering_type_e ti;
2370 if (type != TETHERING_TYPE_ALL) {
2371 th->enabled_cb[type] = NULL;
2372 th->enabled_user_data[type] = NULL;
2374 return TETHERING_ERROR_NONE;
2377 /* TETHERING_TYPE_ALL */
2378 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2379 th->enabled_cb[ti] = NULL;
2380 th->enabled_user_data[ti] = NULL;
2383 return TETHERING_ERROR_NONE;
2388 * @brief Registers the callback function called when tethering is disabled.
2390 * @privlevel platform
2391 * @privilege http://tizen.org/privilege/tethering.admin
2392 * @param[in] tethering The handle of tethering
2393 * @param[in] type The type of tethering
2394 * @param[in] callback The callback function to invoke
2395 * @param[in] user_data The user data to be passed to the callback function
2396 * @retval #TETHERING_ERROR_NONE Successful
2397 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2398 * @see tethering_unset_disabled_cb()
2400 API int tethering_set_disabled_cb(tethering_h tethering, tethering_type_e type, tethering_disabled_cb callback, void *user_data)
2402 INFO("+ type: %d\n", type);
2403 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2404 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2405 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2406 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2408 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2409 "parameter(tethering) is NULL\n");
2410 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2411 "parameter(callback) is NULL\n");
2413 __tethering_h *th = (__tethering_h *)tethering;
2414 tethering_type_e ti;
2416 if (type != TETHERING_TYPE_ALL) {
2417 th->disabled_cb[type] = callback;
2418 th->disabled_user_data[type] = user_data;
2420 return TETHERING_ERROR_NONE;
2423 /* TETHERING_TYPE_ALL */
2424 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2425 th->disabled_cb[ti] = callback;
2426 th->disabled_user_data[ti] = user_data;
2429 return TETHERING_ERROR_NONE;
2434 * @brief Unregisters the callback function called when tethering is disabled.
2436 * @privlevel platform
2437 * @privilege http://tizen.org/privilege/tethering.admin
2438 * @param[in] tethering The handle of tethering
2439 * @param[in] type The type of tethering
2440 * @retval #TETHERING_ERROR_NONE Successful
2441 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2442 * @see tethering_set_disabled_cb()
2444 API int tethering_unset_disabled_cb(tethering_h tethering, tethering_type_e type)
2446 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2447 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2448 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2449 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2451 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2452 "parameter(tethering) is NULL\n");
2454 __tethering_h *th = (__tethering_h *)tethering;
2455 tethering_type_e ti;
2457 if (type != TETHERING_TYPE_ALL) {
2458 th->disabled_cb[type] = NULL;
2459 th->disabled_user_data[type] = NULL;
2461 return TETHERING_ERROR_NONE;
2464 /* TETHERING_TYPE_ALL */
2465 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2466 th->disabled_cb[ti] = NULL;
2467 th->disabled_user_data[ti] = NULL;
2470 return TETHERING_ERROR_NONE;
2475 * @brief Registers the callback function called when the state of connection is changed.
2477 * @privlevel platform
2478 * @privilege http://tizen.org/privilege/tethering.admin
2479 * @param[in] tethering The handle of tethering
2480 * @param[in] type The type of tethering
2481 * @param[in] callback The callback function to invoke
2482 * @param[in] user_data The user data to be passed to the callback function
2483 * @retval #TETHERING_ERROR_NONE Successful
2484 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2485 * @see tethering_unset_connection_state_changed_cb_cb()
2487 API int tethering_set_connection_state_changed_cb(tethering_h tethering, tethering_type_e type, tethering_connection_state_changed_cb callback, void *user_data)
2489 INFO("+ type: %d\n", type);
2490 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2491 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2492 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2493 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2495 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2496 "parameter(tethering) is NULL\n");
2497 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2498 "parameter(callback) is NULL\n");
2500 __tethering_h *th = (__tethering_h *)tethering;
2501 tethering_type_e ti;
2503 if (type != TETHERING_TYPE_ALL) {
2504 th->changed_cb[type] = callback;
2505 th->changed_user_data[type] = user_data;
2507 return TETHERING_ERROR_NONE;
2510 /* TETHERING_TYPE_ALL */
2511 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2512 th->changed_cb[ti] = callback;
2513 th->changed_user_data[ti] = user_data;
2516 return TETHERING_ERROR_NONE;
2521 * @brief Unregisters the callback function called when the state of connection is changed.
2523 * @privlevel platform
2524 * @privilege http://tizen.org/privilege/tethering.admin
2525 * @param[in] tethering The handle of tethering
2526 * @param[in] type The type of tethering
2527 * @retval #TETHERING_ERROR_NONE Successful
2528 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2529 * @see tethering_set_connection_state_changed_cb()
2531 API int tethering_unset_connection_state_changed_cb(tethering_h tethering, tethering_type_e type)
2533 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2534 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2535 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2536 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2538 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2539 "parameter(tethering) is NULL\n");
2541 __tethering_h *th = (__tethering_h *)tethering;
2542 tethering_type_e ti;
2544 if (type != TETHERING_TYPE_ALL) {
2545 th->changed_cb[type] = NULL;
2546 th->changed_user_data[type] = NULL;
2548 return TETHERING_ERROR_NONE;
2551 /* TETHERING_TYPE_ALL */
2552 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2553 th->changed_cb[ti] = NULL;
2554 th->changed_user_data[ti] = NULL;
2557 return TETHERING_ERROR_NONE;
2562 * @brief Registers the callback function called when the security type of Wi-Fi tethering is changed.
2564 * @privlevel platform
2565 * @privilege http://tizen.org/privilege/tethering.admin
2566 * @param[in] tethering The handle of tethering
2567 * @param[in] callback The callback function to invoke
2568 * @param[in] user_data The user data to be passed to the callback function
2569 * @retval #TETHERING_ERROR_NONE Successful
2570 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2571 * @see tethering_wifi_unset_security_type_changed_cb()
2573 API int tethering_wifi_set_security_type_changed_cb(tethering_h tethering, tethering_wifi_security_type_changed_cb callback, void *user_data)
2575 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2576 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2578 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2579 "parameter(tethering) is NULL\n");
2580 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2581 "parameter(callback) is NULL\n");
2583 __tethering_h *th = (__tethering_h *)tethering;
2585 th->security_type_changed_cb = callback;
2586 th->security_type_user_data = user_data;
2588 return TETHERING_ERROR_NONE;
2594 * @brief Unregisters the callback function called when the security type of Wi-Fi tethering is changed.
2596 * @privlevel platform
2597 * @privilege http://tizen.org/privilege/tethering.admin
2598 * @param[in] tethering The handle of tethering
2599 * @param[in] type The type of tethering
2600 * @retval #TETHERING_ERROR_NONE Successful
2601 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2602 * @see tethering_wifi_set_security_type_changed_cb()
2604 API int tethering_wifi_unset_security_type_changed_cb(tethering_h tethering)
2606 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2607 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2609 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2610 "parameter(tethering) is NULL\n");
2612 __tethering_h *th = (__tethering_h *)tethering;
2614 th->security_type_changed_cb = NULL;
2615 th->security_type_user_data = NULL;
2617 return TETHERING_ERROR_NONE;
2622 * @brief Registers the callback function called when the visibility of SSID is changed.
2624 * @privlevel platform
2625 * @privilege http://tizen.org/privilege/tethering.admin
2626 * @param[in] tethering The handle of tethering
2627 * @param[in] callback The callback function to invoke
2628 * @param[in] user_data The user data to be passed to the callback function
2629 * @retval #TETHERING_ERROR_NONE Successful
2630 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2631 * @see tethering_wifi_unset_ssid_visibility_changed_cb_cb()
2633 API int tethering_wifi_set_ssid_visibility_changed_cb(tethering_h tethering, tethering_wifi_ssid_visibility_changed_cb callback, void *user_data)
2635 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2636 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2638 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2639 "parameter(tethering) is NULL\n");
2640 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2641 "parameter(callback) is NULL\n");
2643 __tethering_h *th = (__tethering_h *)tethering;
2645 th->ssid_visibility_changed_cb = callback;
2646 th->ssid_visibility_user_data = user_data;
2648 return TETHERING_ERROR_NONE;
2653 * @brief Unregisters the callback function called when the visibility of SSID is changed.
2655 * @privlevel platform
2656 * @privilege http://tizen.org/privilege/tethering.admin
2657 * @param[in] tethering The handle of tethering
2658 * @retval #TETHERING_ERROR_NONE Successful
2659 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2660 * @see tethering_wifi_set_ssid_visibility_changed_cb()
2662 API int tethering_wifi_unset_ssid_visibility_changed_cb(tethering_h tethering)
2664 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2665 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2667 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2668 "parameter(tethering) is NULL\n");
2670 __tethering_h *th = (__tethering_h *)tethering;
2672 th->ssid_visibility_changed_cb = NULL;
2673 th->ssid_visibility_user_data = NULL;
2675 return TETHERING_ERROR_NONE;
2680 * @brief Registers the callback function called when the passphrase of Wi-Fi tethering is changed.
2682 * @privlevel platform
2683 * @privilege http://tizen.org/privilege/tethering.admin
2684 * @param[in] tethering The handle of tethering
2685 * @param[in] callback The callback function to invoke
2686 * @param[in] user_data The user data to be passed to the callback function
2687 * @retval #TETHERING_ERROR_NONE Successful
2688 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2689 * @see tethering_wifi_unset_passphrase_changed_cb()
2691 API int tethering_wifi_set_passphrase_changed_cb(tethering_h tethering, tethering_wifi_passphrase_changed_cb callback, void *user_data)
2693 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2694 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2696 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2697 "parameter(tethering) is NULL\n");
2698 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2699 "parameter(callback) is NULL\n");
2701 __tethering_h *th = (__tethering_h *)tethering;
2703 th->passphrase_changed_cb = callback;
2704 th->passphrase_user_data = user_data;
2706 return TETHERING_ERROR_NONE;
2711 * @brief Unregisters the callback function called when the passphrase of Wi-Fi tethering is changed.
2713 * @privlevel platform
2714 * @privilege http://tizen.org/privilege/tethering.admin
2715 * @param[in] tethering The handle of tethering
2716 * @retval #TETHERING_ERROR_NONE Successful
2717 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2718 * @see tethering_wifi_set_passphrase_changed_cb()
2720 API int tethering_wifi_unset_passphrase_changed_cb(tethering_h tethering)
2722 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2723 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2725 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2726 "parameter(tethering) is NULL\n");
2728 __tethering_h *th = (__tethering_h *)tethering;
2730 th->passphrase_changed_cb = NULL;
2731 th->passphrase_user_data = NULL;
2733 return TETHERING_ERROR_NONE;
2738 * @brief Sets the security type of Wi-Fi tethering.
2740 * @privlevel platform
2741 * @privilege http://tizen.org/privilege/tethering.admin
2742 * @remarks This change is applied next time Wi-Fi tethering is enabled
2743 * @param[in] tethering The handle of tethering
2744 * @param[in] type The security type
2745 * @return 0 on success, otherwise negative error value.
2746 * @retval #TETHERING_ERROR_NONE Successful
2747 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2748 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2749 * @see tethering_wifi_get_security_type()
2751 API int tethering_wifi_set_security_type(tethering_h tethering, tethering_wifi_security_type_e type)
2753 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2754 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2756 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2757 "parameter(tethering) is NULL\n");
2759 __tethering_h *th = (__tethering_h *)tethering;
2760 tethering_error_e ret = TETHERING_ERROR_NONE;
2761 char *sec_str = NULL;
2763 ret = __set_security_type(type);
2764 if (ret == TETHERING_ERROR_NONE) {
2767 case TETHERING_WIFI_SECURITY_TYPE_NONE:
2768 sec_str = TETHERING_WIFI_SECURITY_TYPE_OPEN_STR;
2770 case TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK:
2771 sec_str = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR;
2773 case TETHERING_WIFI_SECURITY_TYPE_WPS:
2774 sec_str = TETHERING_WIFI_SECURITY_TYPE_WPS_STR;
2778 __send_dbus_signal(th->client_bus,
2779 SIGNAL_NAME_SECURITY_TYPE_CHANGED, sec_str);
2786 * @brief Gets the security type of Wi-Fi tethering.
2788 * @privlevel platform
2789 * @privilege http://tizen.org/privilege/tethering.admin
2790 * @param[in] tethering The handle of tethering
2791 * @param[out] type The security type
2792 * @return 0 on success, otherwise negative error value.
2793 * @retval #TETHERING_ERROR_NONE Successful
2794 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2795 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2796 * @see tethering_wifi_set_security_type()
2798 API int tethering_wifi_get_security_type(tethering_h tethering, tethering_wifi_security_type_e *type)
2800 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2801 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2803 _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2804 "parameter(type) is NULL\n");
2806 return __get_security_type(type);
2811 * @brief Sets the SSID (service set identifier).
2813 * @privlevel platform
2814 * @privilege http://tizen.org/privilege/tethering.admin
2815 * @details If SSID is not set, Device name is used as SSID
2816 * @remarks This change is applied next time Wi-Fi tethering is enabled with same @a tethering handle
2817 * @param[in] tethering The handle of tethering
2818 * @param[out] ssid The SSID
2819 * @return 0 on success, otherwise negative error value.
2820 * @retval #TETHERING_ERROR_NONE Successful
2821 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2822 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2824 API int tethering_wifi_set_ssid(tethering_h tethering, const char *ssid)
2826 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2827 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2829 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2830 "parameter(tethering) is NULL\n");
2831 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2832 "parameter(ssid) is NULL\n");
2834 __tethering_h *th = (__tethering_h *)tethering;
2835 char *p_ssid = NULL;
2838 ssid_len = strlen(ssid);
2839 if (ssid_len > TETHERING_WIFI_SSID_MAX_LEN) {
2840 ERR("parameter(ssid) is too long");
2841 return TETHERING_ERROR_INVALID_PARAMETER;
2844 p_ssid = strdup(ssid);
2845 _retvm_if(p_ssid == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2846 "strdup is failed\n");
2852 return TETHERING_ERROR_NONE;
2857 * @brief Gets the SSID (service set identifier).
2859 * @privlevel platform
2860 * @privilege http://tizen.org/privilege/tethering.admin
2861 * @remarks @a ssid must be released with free() by you.
2862 * @param[in] tethering The handle of tethering
2863 * @param[out] ssid The SSID
2864 * @return 0 on success, otherwise negative error value.
2865 * @retval #TETHERING_ERROR_NONE Successful
2866 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2867 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2868 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2870 API int tethering_wifi_get_ssid(tethering_h tethering, char **ssid)
2872 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2873 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2875 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2876 "parameter(tethering) is NULL\n");
2877 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2878 "parameter(ssid) is NULL\n");
2881 __tethering_h *th = (__tethering_h *)tethering;
2882 char val[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
2884 if (!tethering_is_enabled(NULL, TETHERING_TYPE_WIFI)) {
2885 if (th->ssid != NULL) {
2886 DBG("Private SSID is set\n");
2887 *ssid = strdup(th->ssid);
2889 if (__get_ssid_from_vconf(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
2890 val, sizeof(val)) == false) {
2891 return TETHERING_ERROR_OPERATION_FAILED;
2893 *ssid = strdup(val);
2896 if (__get_ssid_from_vconf(VCONFKEY_MOBILE_HOTSPOT_SSID,
2897 val, sizeof(val)) == false) {
2898 return TETHERING_ERROR_OPERATION_FAILED;
2900 *ssid = strdup(val);
2903 if (*ssid == NULL) {
2904 ERR("strdup is failed\n");
2905 return TETHERING_ERROR_OUT_OF_MEMORY;
2908 return TETHERING_ERROR_NONE;
2913 * @brief Sets the visibility of SSID(service set identifier).
2915 * @privlevel platform
2916 * @privilege http://tizen.org/privilege/tethering.admin
2917 * @details If you set the visibility invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
2918 * @remarks This change is applied next time Wi-Fi tethering is enabled
2919 * @param[in] tethering The handle of tethering
2920 * @param[in] visible The visibility of SSID: (@c true = visible, @c false = invisible)
2921 * @return 0 on success, otherwise negative error value.
2922 * @retval #TETHERING_ERROR_NONE Successful
2923 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2924 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2925 * @see tethering_wifi_get_ssid_visibility()
2927 API int tethering_wifi_set_ssid_visibility(tethering_h tethering, bool visible)
2929 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2930 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2932 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2933 "parameter(tethering) is NULL\n");
2935 __tethering_h *th = (__tethering_h *)tethering;
2936 tethering_error_e ret = TETHERING_ERROR_NONE;
2938 ret = __set_visible(visible);
2939 if (ret == TETHERING_ERROR_NONE) {
2941 __send_dbus_signal(th->client_bus,
2942 SIGNAL_NAME_SSID_VISIBILITY_CHANGED,
2943 visible ? SIGNAL_MSG_SSID_VISIBLE :
2944 SIGNAL_MSG_SSID_HIDE);
2951 * @brief Gets the visibility of SSID(service set identifier).
2953 * @privlevel platform
2954 * @privilege http://tizen.org/privilege/tethering.admin
2955 * @details If the visibility is set invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
2956 * @param[in] tethering The handle of tethering
2957 * @param[out] visible The visibility of SSID: (@c true = visible, @c false = invisible)
2958 * @return 0 on success, otherwise negative error value.
2959 * @retval #TETHERING_ERROR_NONE Successful
2960 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2961 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2962 * @see tethering_wifi_set_ssid_visibility()
2964 API int tethering_wifi_get_ssid_visibility(tethering_h tethering, bool *visible)
2966 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2967 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2969 _retvm_if(visible == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2970 "parameter(visible) is NULL\n");
2972 return __get_visible(visible);
2977 * @brief Sets the passphrase.
2979 * @privlevel platform
2980 * @privilege http://tizen.org/privilege/tethering.admin
2981 * @remarks This change is applied next time Wi-Fi tethering is enabled
2982 * @param[in] tethering The handle of tethering
2983 * @param[in] passphrase The passphrase
2984 * @return 0 on success, otherwise negative error value.
2985 * @retval #TETHERING_ERROR_NONE Successful
2986 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2987 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2988 * @see tethering_wifi_get_passphrase()
2990 API int tethering_wifi_set_passphrase(tethering_h tethering, const char *passphrase)
2992 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2993 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2995 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2996 "parameter(tethering) is NULL\n");
2997 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2998 "parameter(passphrase) is NULL\n");
3000 __tethering_h *th = (__tethering_h *)tethering;
3001 GDBusProxy *proxy = th->client_bus_proxy;
3002 GVariant *parameters;
3003 GError *error = NULL;
3004 int passphrase_len = 0;
3008 passphrase_len = strlen(passphrase);
3009 if (passphrase_len < TETHERING_WIFI_KEY_MIN_LEN ||
3010 passphrase_len > TETHERING_WIFI_KEY_MAX_LEN) {
3011 ERR("parameter(passphrase) is too short or long\n");
3012 return TETHERING_ERROR_INVALID_PARAMETER;
3015 parameters = g_dbus_proxy_call_sync(proxy, "set_wifi_tethering_passphrase",
3016 g_variant_new("(s)", passphrase), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3020 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3022 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3023 ret = TETHERING_ERROR_PERMISSION_DENIED;
3025 ret = TETHERING_ERROR_OPERATION_FAILED;
3027 g_error_free(error);
3032 g_variant_get(parameters, "(u)", &ret);
3033 g_variant_unref(parameters);
3035 if (ret == TETHERING_ERROR_NONE) {
3036 __send_dbus_signal(th->client_bus,
3037 SIGNAL_NAME_PASSPHRASE_CHANGED, NULL);
3046 * @brief Gets the passphrase.
3048 * @privlevel platform
3049 * @privilege http://tizen.org/privilege/tethering.admin
3050 * @remarks @a passphrase must be released with free() by you.
3051 * @param[in] tethering The handle of tethering
3052 * @param[out] passphrase The passphrase
3053 * @return 0 on success, otherwise negative error value.
3054 * @retval #TETHERING_ERROR_NONE Successful
3055 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3056 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
3057 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3058 * @see tethering_wifi_set_passphrase()
3060 API int tethering_wifi_get_passphrase(tethering_h tethering, char **passphrase)
3062 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3063 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3065 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3066 "parameter(tethering) is NULL\n");
3067 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3068 "parameter(passphrase) is NULL\n");
3070 __tethering_h *th = (__tethering_h *)tethering;
3071 GDBusProxy *proxy = th->client_bus_proxy;
3072 GVariant *parameters;
3073 GError *error = NULL;
3074 unsigned int len = 0;
3075 tethering_error_e ret = TETHERING_ERROR_NONE;
3077 parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_passphrase",
3078 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3082 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3084 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3085 ret = TETHERING_ERROR_PERMISSION_DENIED;
3087 ret = TETHERING_ERROR_OPERATION_FAILED;
3089 g_error_free(error);
3094 if (parameters != NULL) {
3095 g_variant_get(parameters, "(siu)", passphrase, &len, &ret);
3096 g_variant_unref(parameters);
3099 return TETHERING_ERROR_NONE;
3102 API int tethering_wifi_set_channel(tethering_h tethering, int channel)
3104 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3105 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3107 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3108 "parameter(tethering) is NULL\n");
3110 __tethering_h *th = (__tethering_h *)tethering;
3111 th->channel = channel;
3113 return TETHERING_ERROR_NONE;
3116 API int tethering_wifi_get_channel(tethering_h tethering, int *channel)
3118 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3119 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3121 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3122 "parameter(tethering) is NULL\n");
3124 _retvm_if(channel == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3125 "parameter(channel) is NULL\n");
3127 __tethering_h *th = (__tethering_h *)tethering;
3128 *channel = th->channel;
3130 return TETHERING_ERROR_NONE;
3133 API int tethering_wifi_set_mode(tethering_h tethering, tethering_wifi_mode_type_e type)
3135 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3136 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3138 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3139 "parameter(tethering) is NULL\n");
3141 __tethering_h *th = (__tethering_h *)tethering;
3143 th->mode_type = type;
3145 return TETHERING_ERROR_NONE;
3148 API int tethering_wifi_get_mode(tethering_h tethering, tethering_wifi_mode_type_e *type)
3150 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3151 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3153 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3154 "parameter(tethering) is NULL\n");
3155 _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3156 "parameter(type) is NULL\n");
3158 __tethering_h *th = (__tethering_h *)tethering;
3159 *type = th->mode_type;
3161 return TETHERING_ERROR_NONE;
3167 * @brief Reload the settings (SSID / Passphrase / Security type / SSID visibility).
3169 * @privlevel platform
3170 * @privilege http://tizen.org/privilege/tethering.admin
3171 * @remarks Connected devices via Wi-Fi tethering or MobileAP will be disconnected when the settings are reloaded
3172 * @param[in] tethering The handle of tethering
3173 * @param[in] callback The callback function to invoke
3174 * @param[in] user_data The user data to be passed to the callback function
3175 * @return 0 on success, otherwise negative error value.
3176 * @retval #TETHERING_ERROR_NONE Successful
3177 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3178 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3180 API int tethering_wifi_reload_settings(tethering_h tethering, tethering_wifi_settings_reloaded_cb callback, void *user_data)
3183 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3184 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3186 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3187 "parameter(tethering) is NULL\n");
3188 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3189 "parameter(callback) is NULL\n");
3191 __tethering_h *th = (__tethering_h *)tethering;
3192 _softap_settings_t set = {"", "", "", 0, false};
3193 GDBusProxy *proxy = th->client_bus_proxy;
3198 if (th->settings_reloaded_cb) {
3199 ERR("Operation in progress\n");
3200 return TETHERING_ERROR_OPERATION_FAILED;
3203 ret = __prepare_wifi_settings(tethering, &set);
3204 if (ret != TETHERING_ERROR_NONE) {
3205 ERR("softap settings initialization failed\n");
3206 return TETHERING_ERROR_OPERATION_FAILED;
3209 th->settings_reloaded_cb = callback;
3210 th->settings_reloaded_user_data = user_data;
3212 g_dbus_proxy_call(proxy, "reload_wifi_settings",
3213 g_variant_new("(sssiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type),
3214 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
3215 (GAsyncReadyCallback) __settings_reloaded_cb, (gpointer)tethering);
3217 return TETHERING_ERROR_NONE;
3220 API int tethering_wifi_set_mac_filter(tethering_h tethering, bool mac_filter)
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;
3229 th->mac_filter = mac_filter;
3231 return TETHERING_ERROR_NONE;
3234 API int tethering_wifi_get_mac_filter(tethering_h tethering, bool *mac_filter)
3236 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3237 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3239 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3240 "parameter(mac_filter) is NULL\n");
3241 _retvm_if(mac_filter == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3242 "parameter(mac_filter) is NULL\n");
3244 __tethering_h *th = (__tethering_h *)tethering;
3245 *mac_filter = th->mac_filter;
3247 return TETHERING_ERROR_NONE;
3250 static int __add_mac_to_file(const char *filepath, const char *mac)
3253 char line[MAX_BUF_SIZE] = "\0";
3254 bool mac_exist = false;
3257 p_mac = strdup(mac);
3258 if (p_mac == NULL) {
3259 ERR("strdup failed\n");
3260 return TETHERING_ERROR_OUT_OF_MEMORY;
3263 fp = fopen(filepath, "a+");
3265 ERR("fopen is failed\n");
3266 return TETHERING_ERROR_OPERATION_FAILED;
3269 while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
3270 if (strncmp(mac, line, 17) == 0) {
3271 DBG("MAC %s already exist in the list\n", mac);
3278 fprintf(fp, "%s\n", mac);
3280 if ((strcmp(filepath, ALLOWED_LIST) == 0))
3281 allowed_list = g_slist_append(allowed_list, p_mac);
3282 else if ((strcmp(filepath, BLOCKED_LIST) == 0))
3283 blocked_list = g_slist_append(blocked_list, p_mac);
3288 return TETHERING_ERROR_NONE;
3291 static int __remove_mac_from_file(const char *filepath, const char *mac)
3295 char line[MAX_BUF_SIZE] = "\0";
3297 fp = fopen(filepath, "r");
3299 ERR("fopen is failed\n");
3300 return TETHERING_ERROR_OPERATION_FAILED;
3303 fp1 = fopen(TEMP_LIST, "w+");
3306 ERR("fopen is failed\n");
3307 return TETHERING_ERROR_OPERATION_FAILED;
3310 while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
3311 if (strncmp(mac, line, 17) == 0) {
3312 DBG("MAC %s found in the list\n", mac);
3314 if ((strcmp(filepath, ALLOWED_LIST) == 0)) {
3315 GSList *list = NULL;
3316 for (list = allowed_list; list != NULL; list = list->next) {
3317 char *p_mac = (char *)list->data;
3318 if (strncmp(mac, p_mac, strlen(mac)) == 0)
3319 allowed_list = g_slist_remove(allowed_list, p_mac);
3321 } else if ((strcmp(filepath, BLOCKED_LIST) == 0)) {
3322 GSList *list = NULL;
3323 for (list = blocked_list; list != NULL; list = list->next) {
3324 char *p_mac = (char *)list->data;
3325 if (strncmp(mac, p_mac, strlen(mac)) == 0)
3326 blocked_list = g_slist_remove(blocked_list, p_mac);
3330 fprintf(fp1, "%s", line);
3337 if ((strcmp(filepath, ALLOWED_LIST) == 0))
3338 rename(TEMP_LIST, ALLOWED_LIST);
3339 else if ((strcmp(filepath, BLOCKED_LIST) == 0))
3340 rename(TEMP_LIST, BLOCKED_LIST);
3342 return TETHERING_ERROR_NONE;
3345 API int tethering_wifi_add_allowed_mac_list(tethering_h tethering, const char *mac)
3347 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3348 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3350 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3351 "parameter(tethering) is NULL\n");
3352 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3353 "parameter(mac) is NULL\n");
3355 return __add_mac_to_file(ALLOWED_LIST, mac);
3358 API int tethering_wifi_remove_allowed_mac_list(tethering_h tethering, const char *mac)
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(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3366 "parameter(mac) is NULL\n");
3368 return __remove_mac_from_file(ALLOWED_LIST, mac);
3371 API int tethering_wifi_get_allowed_mac_list(tethering_h tethering, void **allowed_mac_list)
3373 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3374 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3376 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3377 "parameter(tethering) is NULL\n");
3378 _retvm_if(allowed_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3379 "parameter(allowed_mac_list) is NULL\n");
3381 *allowed_mac_list = g_slist_copy(allowed_list);
3382 return TETHERING_ERROR_NONE;
3385 API int tethering_wifi_add_blocked_mac_list(tethering_h tethering, const char *mac)
3387 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3388 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3390 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3391 "parameter(tethering) is NULL\n");
3392 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3393 "parameter(mac) is NULL\n");
3395 return __add_mac_to_file(BLOCKED_LIST, mac);
3398 API int tethering_wifi_remove_blocked_mac_list(tethering_h tethering, const char *mac)
3400 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3401 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3403 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3404 "parameter(tethering) is NULL\n");
3405 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3406 "parameter(mac) is NULL\n");
3408 return __remove_mac_from_file(BLOCKED_LIST, mac);
3411 API int tethering_wifi_get_blocked_mac_list(tethering_h tethering, void **blocked_mac_list)
3413 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3414 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3416 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3417 "parameter(tethering) is NULL\n");
3418 _retvm_if(blocked_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3419 "parameter(blocked_mac_list) is NULL\n");
3421 *blocked_mac_list = g_slist_copy(blocked_list);
3422 return TETHERING_ERROR_NONE;
3425 API int tethering_wifi_enable_dhcp(tethering_h tethering, bool enable)
3427 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3428 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3430 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3431 "parameter(tethering) is NULL\n");
3433 GVariant *parameters;
3434 GError *error = NULL;
3437 __tethering_h *th = (__tethering_h *)tethering;
3439 GDBusProxy *proxy = th->client_bus_proxy;
3441 parameters = g_dbus_proxy_call_sync(proxy, "enable_dhcp",
3442 g_variant_new("(b)", enable),
3443 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3446 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3447 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3448 result = TETHERING_ERROR_PERMISSION_DENIED;
3450 result = TETHERING_ERROR_OPERATION_FAILED;
3452 g_error_free(error);
3453 th->dhcp_enabled = false;
3458 g_variant_get(parameters, "(u)", &result);
3459 g_variant_unref(parameters);
3462 th->dhcp_enabled = true;
3464 th->dhcp_enabled = false;
3466 return TETHERING_ERROR_NONE;
3469 API int tethering_wifi_set_dhcp_range(tethering_h tethering, char *rangestart, char *rangestop)
3471 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3472 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3474 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3475 "parameter(tethering) is NULL\n");
3476 _retvm_if(rangestart == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3477 "parameter(rangestart) is NULL\n");
3478 _retvm_if(rangestop == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3479 "parameter(rangestop) is NULL\n");
3481 GVariant *parameters;
3482 GError *error = NULL;
3485 __tethering_h *th = (__tethering_h *)tethering;
3487 GDBusProxy *proxy = th->client_bus_proxy;
3489 parameters = g_dbus_proxy_call_sync(proxy, "dhcp_range",
3490 g_variant_new("(ss)", rangestart, rangestop),
3491 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3493 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3495 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3496 result = TETHERING_ERROR_PERMISSION_DENIED;
3498 result = TETHERING_ERROR_OPERATION_FAILED;
3500 g_error_free(error);
3501 th->dhcp_enabled = false;
3506 g_variant_get(parameters, "(u)", &result);
3507 g_variant_unref(parameters);
3509 th->dhcp_enabled = true;
3511 return TETHERING_ERROR_NONE;
3514 API int tethering_wifi_is_dhcp_enabled(tethering_h tethering, bool *dhcp_enabled)
3516 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3517 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3519 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3520 "parameter(tethering) is NULL\n");
3521 _retvm_if(dhcp_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3522 "parameter(dhcp_enabled) is NULL\n");
3524 __tethering_h *th = (__tethering_h *)tethering;
3525 *dhcp_enabled = th->dhcp_enabled;
3527 return TETHERING_ERROR_NONE;
3530 API int tethering_wifi_set_txpower(tethering_h tethering, unsigned int txpower)
3532 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3533 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3535 GError *error = NULL;
3537 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3538 "parameter(tethering) is NULL\n");
3539 _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false,
3540 TETHERING_ERROR_NOT_ENABLED,
3541 "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
3542 __tethering_h *th = (__tethering_h *)tethering;
3544 g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_set_txpower",
3545 g_variant_new("(u)", txpower),
3546 G_DBUS_CALL_FLAGS_NONE,
3547 -1, th->cancellable, &error);
3549 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
3550 g_clear_error(&error);
3551 return TETHERING_ERROR_OPERATION_FAILED;
3553 return TETHERING_ERROR_NONE;
3556 API int tethering_wifi_get_txpower(tethering_h tethering, unsigned int *txpower)
3558 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3559 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3561 GError *error = NULL;
3562 GVariant *result = NULL;
3564 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3565 "parameter(tethering) is NULL\n");
3566 _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false,
3567 TETHERING_ERROR_NOT_ENABLED,
3568 "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
3570 __tethering_h *th = (__tethering_h *)tethering;
3572 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_get_txpower",
3574 G_DBUS_CALL_FLAGS_NONE,
3575 -1, th->cancellable, &error);
3577 if (result != NULL) {
3578 g_variant_get(result, "(u)", txpower);
3579 g_variant_unref(result);
3582 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
3583 g_clear_error(&error);
3584 return TETHERING_ERROR_OPERATION_FAILED;
3586 g_clear_error(&error);
3587 return TETHERING_ERROR_NONE;
3590 API int tethering_wifi_set_mtu(tethering_h tethering, unsigned int mtu)
3592 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3593 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3595 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3596 "parameter(tethering) is NULL\n");
3598 GVariant *parameters;
3599 GError *error = NULL;
3602 __tethering_h *th = (__tethering_h *)tethering;
3604 GDBusProxy *proxy = th->client_bus_proxy;
3606 parameters = g_dbus_proxy_call_sync(proxy, "set_mtu",
3607 g_variant_new("(u)", mtu),
3608 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3610 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3612 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3613 result = TETHERING_ERROR_PERMISSION_DENIED;
3615 result = TETHERING_ERROR_OPERATION_FAILED;
3617 g_error_free(error);
3621 g_variant_get(parameters, "(u)", &result);
3623 g_variant_unref(parameters);
3625 return TETHERING_ERROR_NONE;
3628 API int tethering_wifi_change_mac(tethering_h tethering, char *mac)
3630 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3631 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3633 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3634 "parameter(tethering) is NULL\n");
3635 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3636 "parameter(mac) is NULL\n");
3638 GVariant *parameters;
3639 GError *error = NULL;
3642 __tethering_h *th = (__tethering_h *)tethering;
3644 GDBusProxy *proxy = th->client_bus_proxy;
3646 parameters = g_dbus_proxy_call_sync(proxy, "change_mac",
3647 g_variant_new("(s)", mac),
3648 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3650 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3652 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3653 result = TETHERING_ERROR_PERMISSION_DENIED;
3655 result = TETHERING_ERROR_OPERATION_FAILED;
3657 g_error_free(error);
3661 g_variant_get(parameters, "(u)", &result);
3662 g_variant_unref(parameters);
3664 if (result == MOBILE_AP_ERROR_NOT_PERMITTED)
3665 return TETHERING_ERROR_NOT_SUPPORT_API;
3667 return TETHERING_ERROR_NONE;
3670 API int tethering_wifi_set_max_connected_device(tethering_h tethering, int max_device)
3672 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3673 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3675 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3676 "parameter(tethering) is NULL\n");
3678 __tethering_h *th = (__tethering_h *)tethering;
3680 th->wifi_max_connected = max_device;
3682 return TETHERING_ERROR_NONE;
3685 API int tethering_wifi_get_max_connected_device(tethering_h tethering, int *max_device)
3687 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3688 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3690 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3691 "parameter(tethering) is NULL\n");
3692 _retvm_if(max_device == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3693 "parameter(max_device) is NULL\n");
3695 __tethering_h *th = (__tethering_h *)tethering;
3697 *max_device = th->wifi_max_connected;
3698 return TETHERING_ERROR_NONE;
3701 API int tethering_wifi_enable_port_forwarding(tethering_h tethering, bool enable)
3703 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3704 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3706 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3707 "parameter(tethering) is NULL\n");
3709 GVariant *parameters;
3710 GError *error = NULL;
3713 __tethering_h *th = (__tethering_h *)tethering;
3715 GDBusProxy *proxy = th->client_bus_proxy;
3717 parameters = g_dbus_proxy_call_sync(proxy, "enable_port_forwarding",
3718 g_variant_new("(b)", enable),
3719 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3721 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3723 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3724 result = TETHERING_ERROR_PERMISSION_DENIED;
3726 result = TETHERING_ERROR_OPERATION_FAILED;
3728 g_error_free(error);
3732 g_variant_get(parameters, "(u)", &result);
3733 g_variant_unref(parameters);
3735 th->port_forwarding = true;
3737 return TETHERING_ERROR_NONE;
3740 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)
3742 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3743 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3745 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3746 "parameter(tethering) is NULL\n");
3747 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3748 "parameter(protocol) is NULL\n");
3750 GVariant *parameters;
3751 GError *error = NULL;
3753 char cmd[MAX_BUF_SIZE] = { 0, };
3756 __tethering_h *th = (__tethering_h *)tethering;
3758 GDBusProxy *proxy = th->client_bus_proxy;
3760 parameters = g_dbus_proxy_call_sync(proxy, "add_port_forwarding_rule",
3761 g_variant_new("(sssisi)", ifname, protocol, org_ip, org_port, final_ip, final_port),
3762 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3764 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3766 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3767 result = TETHERING_ERROR_PERMISSION_DENIED;
3769 result = TETHERING_ERROR_OPERATION_FAILED;
3771 g_error_free(error);
3775 g_variant_get(parameters, "(u)", &result);
3776 g_variant_unref(parameters);
3778 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);
3782 ERR("strdup failed\n");
3783 return TETHERING_ERROR_OUT_OF_MEMORY;
3786 port_forwarding = g_slist_append(port_forwarding, list);
3788 return TETHERING_ERROR_NONE;
3791 API int tethering_wifi_reset_port_forwarding_rule(tethering_h tethering)
3793 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3794 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3796 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3797 "parameter(tethering) is NULL\n");
3799 GVariant *parameters;
3800 GError *error = NULL;
3803 __tethering_h *th = (__tethering_h *)tethering;
3805 GDBusProxy *proxy = th->client_bus_proxy;
3807 parameters = g_dbus_proxy_call_sync(proxy, "reset_port_forwarding_rule",
3808 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3810 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3812 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3813 result = TETHERING_ERROR_PERMISSION_DENIED;
3815 result = TETHERING_ERROR_OPERATION_FAILED;
3817 g_error_free(error);
3821 g_variant_get(parameters, "(u)", &result);
3823 g_variant_unref(parameters);
3825 return TETHERING_ERROR_NONE;
3828 API int tethering_wifi_is_port_forwarding_enabled(tethering_h tethering, bool* forwarding_enabled)
3830 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3831 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3833 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3834 "parameter(tethering) is NULL\n");
3835 _retvm_if(forwarding_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3836 "parameter(forwarding_enabled) is NULL\n");
3838 __tethering_h *th = (__tethering_h *)tethering;
3840 *forwarding_enabled = th->port_forwarding;
3842 return TETHERING_ERROR_NONE;
3845 API int tethering_wifi_get_port_forwarding_rule(tethering_h tethering, void **port_forwarding_list)
3847 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3848 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3850 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3851 "parameter(tethering) is NULL\n");
3852 _retvm_if(port_forwarding_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3853 "parameter(port_forwarding_list) is NULL\n");
3855 *port_forwarding_list = g_slist_copy(port_forwarding);
3856 return TETHERING_ERROR_NONE;
3859 API int tethering_wifi_enable_port_filtering(tethering_h tethering, bool enable)
3861 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3862 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3864 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3865 "parameter(tethering) is NULL\n");
3867 GVariant *parameters;
3868 GError *error = NULL;
3871 __tethering_h *th = (__tethering_h *)tethering;
3873 GDBusProxy *proxy = th->client_bus_proxy;
3875 parameters = g_dbus_proxy_call_sync(proxy, "enable_port_filtering",
3876 g_variant_new("(b)", enable),
3877 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3879 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3881 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3882 result = TETHERING_ERROR_PERMISSION_DENIED;
3884 result = TETHERING_ERROR_OPERATION_FAILED;
3886 g_error_free(error);
3890 g_variant_get(parameters, "(u)", &result);
3891 g_variant_unref(parameters);
3893 th->port_filtering = true;
3895 return TETHERING_ERROR_NONE;
3898 API int tethering_wifi_add_port_filtering_rule(tethering_h tethering, int port, char *protocol, bool allow)
3900 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3901 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3903 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3904 "parameter(tethering) is NULL\n");
3905 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3906 "parameter(protocol) is NULL\n");
3908 GVariant *parameters;
3909 GError *error = NULL;
3911 char cmd[MAX_BUF_SIZE] = { 0, };
3914 __tethering_h *th = (__tethering_h *)tethering;
3916 GDBusProxy *proxy = th->client_bus_proxy;
3918 parameters = g_dbus_proxy_call_sync(proxy, "add_port_filtering_rule",
3919 g_variant_new("(isb)", port, protocol, allow),
3920 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3922 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3924 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3925 result = TETHERING_ERROR_PERMISSION_DENIED;
3927 result = TETHERING_ERROR_OPERATION_FAILED;
3929 g_error_free(error);
3933 g_variant_get(parameters, "(u)", &result);
3934 g_variant_unref(parameters);
3937 snprintf(cmd, sizeof(cmd), "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_ACCEPT);
3939 snprintf(cmd, sizeof(cmd), "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_DROP);
3945 ERR("strdup failed\n");
3946 return TETHERING_ERROR_OUT_OF_MEMORY;
3949 port_filtering = g_slist_append(port_filtering, list);
3951 return TETHERING_ERROR_NONE;
3954 API int tethering_wifi_add_custom_port_filtering_rule(tethering_h tethering, int port1, int port2, char *protocol, bool allow)
3956 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3957 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3959 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3960 "parameter(tethering) is NULL\n");
3961 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3962 "parameter(protocol) is NULL\n");
3964 GVariant *parameters;
3965 GError *error = NULL;
3967 char cmd[MAX_BUF_SIZE] = { 0, };
3970 __tethering_h *th = (__tethering_h *)tethering;
3972 GDBusProxy *proxy = th->client_bus_proxy;
3974 parameters = g_dbus_proxy_call_sync(proxy, "add_custom_port_filtering_rule",
3975 g_variant_new("(iisb)", port1, port2, protocol, allow),
3976 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3978 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3980 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3981 result = TETHERING_ERROR_PERMISSION_DENIED;
3983 result = TETHERING_ERROR_OPERATION_FAILED;
3985 g_error_free(error);
3989 g_variant_get(parameters, "(u)", &result);
3990 g_variant_unref(parameters);
3993 snprintf(cmd, sizeof(cmd), "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_ACCEPT);
3995 snprintf(cmd, sizeof(cmd), "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_DROP);
4001 ERR("strdup failed\n");
4002 return TETHERING_ERROR_OUT_OF_MEMORY;
4005 custom_port_filtering = g_slist_append(custom_port_filtering, list);
4007 return TETHERING_ERROR_NONE;
4010 API int tethering_wifi_get_port_filtering_rule(tethering_h tethering, void **port_filtering_list)
4012 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4013 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4015 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4016 "parameter(tethering) is NULL\n");
4017 _retvm_if(port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4018 "parameter(port_filtering_list) is NULL\n");
4020 *port_filtering_list = g_slist_copy(port_filtering);
4021 return TETHERING_ERROR_NONE;
4024 API int tethering_wifi_get_custom_port_filtering_rule(tethering_h tethering, void **custom_port_filtering_list)
4026 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4027 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4029 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4030 "parameter(tethering) is NULL\n");
4031 _retvm_if(custom_port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4032 "parameter(custom_port_filtering_list) is NULL\n");
4034 *custom_port_filtering_list = g_slist_copy(custom_port_filtering);
4035 return TETHERING_ERROR_NONE;
4038 API int tethering_wifi_is_port_filtering_enabled(tethering_h tethering, bool* filtering_enabled)
4040 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4041 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4043 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4044 "parameter(tethering) is NULL\n");
4045 _retvm_if(filtering_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4046 "parameter(filtering_enabled) is NULL\n");
4048 __tethering_h *th = (__tethering_h *)tethering;
4050 *filtering_enabled = th->port_filtering;
4052 return TETHERING_ERROR_NONE;
4055 API int tethering_wifi_set_vpn_passthrough_rule(tethering_h tethering, tethering_vpn_passthrough_type_e type, bool enable)
4057 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4058 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4060 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4061 "parameter(tethering) is NULL\n");
4063 GVariant *parameters;
4064 GError *error = NULL;
4067 __tethering_h *th = (__tethering_h *)tethering;
4069 GDBusProxy *proxy = th->client_bus_proxy;
4071 parameters = g_dbus_proxy_call_sync(proxy, "set_vpn_passthrough_rule",
4072 g_variant_new("(ib)", type, enable),
4073 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4075 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4077 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4078 result = TETHERING_ERROR_PERMISSION_DENIED;
4080 result = TETHERING_ERROR_OPERATION_FAILED;
4082 g_error_free(error);
4086 g_variant_get(parameters, "(u)", &result);
4088 g_variant_unref(parameters);
4090 return TETHERING_ERROR_NONE;
4093 API int tethering_wifi_push_wps_button(tethering_h tethering)
4095 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4096 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4098 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4099 "parameter(tethering) is NULL");
4100 __tethering_h *th = (__tethering_h *)tethering;
4101 GDBusProxy *proxy = th->client_bus_proxy;
4102 GVariant *parameters = NULL;
4104 GError *error = NULL;
4106 parameters = g_dbus_proxy_call_sync(proxy, "push_wps_button",
4107 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4110 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4112 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4113 ret = TETHERING_ERROR_PERMISSION_DENIED;
4115 ret = TETHERING_ERROR_OPERATION_FAILED;
4117 g_error_free(error);
4121 if (parameters != NULL) {
4122 g_variant_get(parameters, "(u)", &ret);
4123 g_variant_unref(parameters);
4126 return TETHERING_ERROR_NONE;
4129 API int tethering_wifi_set_wps_pin(tethering_h tethering, const char *wps_pin)
4131 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4132 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4134 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4135 "parameter(tethering) is NULL");
4136 __tethering_h *th = (__tethering_h *)tethering;
4137 GDBusProxy *proxy = th->client_bus_proxy;
4138 GVariant *parameters = NULL;
4140 GError *error = NULL;
4142 parameters = g_dbus_proxy_call_sync(proxy, "set_wps_pin",
4143 g_variant_new("(s)", wps_pin), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4146 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4148 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4149 ret = TETHERING_ERROR_PERMISSION_DENIED;
4151 ret = TETHERING_ERROR_OPERATION_FAILED;
4153 g_error_free(error);
4157 if (parameters != NULL) {
4158 g_variant_get(parameters, "(u)", &ret);
4159 g_variant_unref(parameters);
4162 return TETHERING_ERROR_NONE;