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
151 static bool __any_tethering_is_enabled(tethering_h tethering)
153 if (tethering_is_enabled(tethering, TETHERING_TYPE_USB) ||
154 tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) ||
155 tethering_is_enabled(tethering, TETHERING_TYPE_BT) ||
156 tethering_is_enabled(tethering, TETHERING_TYPE_P2P))
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"); //LCOV_EXCL_LINE
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"); //LCOV_EXCL_LINE
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"); //LCOV_EXCL_LINE
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"); //LCOV_EXCL_LINE
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"); //LCOV_EXCL_LINE
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"); //LCOV_EXCL_LINE
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"); //LCOV_EXCL_LINE
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;
289 case MOBILE_AP_ERROR_ALREADY_ENABLED:
290 err = TETHERING_ERROR_OPERATION_FAILED;
293 case MOBILE_AP_ERROR_NOT_ENABLED:
294 err = TETHERING_ERROR_NOT_ENABLED;
297 case MOBILE_AP_ERROR_NET_OPEN:
298 err = TETHERING_ERROR_OPERATION_FAILED;
301 case MOBILE_AP_ERROR_NET_CLOSE:
302 err = TETHERING_ERROR_OPERATION_FAILED;
305 case MOBILE_AP_ERROR_DHCP:
306 err = TETHERING_ERROR_OPERATION_FAILED;
309 case MOBILE_AP_ERROR_IN_PROGRESS:
310 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;
370 else if (ap_type == MOBILE_AP_TYPE_P2P)
371 type = TETHERING_TYPE_P2P;
373 ERR("Not supported tethering type [%d]\n", ap_type);
377 ccb = th->changed_cb[type];
380 data = th->changed_user_data[type];
382 client.interface = type;
383 g_strlcpy(client.ip, ip, sizeof(client.ip));
384 g_strlcpy(client.mac, mac, sizeof(client.mac));
386 client.hostname = g_strdup(name);
387 client.tm = (time_t)timestamp;
389 ccb((tethering_client_h)&client, opened, data);
390 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); //LCOV_EXCL_LINE
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)
707 DBG("+\n"); //LCOV_EXCL_LINE
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;
719 DBG("-\n"); //LCOV_EXCL_LINE
722 g_variant_get(parameters, "(s)", &buf);
723 data = th->ssid_visibility_user_data;
724 if (g_strcmp0(buf, SIGNAL_MSG_SSID_VISIBLE) == 0)
729 DBG("-\n"); //LCOV_EXCL_LINE
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)
736 DBG("+\n"); //LCOV_EXCL_LINE
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;
751 DBG("-\n"); //LCOV_EXCL_LINE
754 static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
757 INFO("+\n"); //LCOV_EXCL_LINE
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 if (!_tethering_check_handle((tethering_h)user_data))
771 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
774 ERR("DBus error [%s]\n", g_error->message);
775 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
776 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
777 g_error_free(g_error);
778 tethering_enable((tethering_h)th, TETHERING_TYPE_WIFI);
780 } else if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
781 error = TETHERING_ERROR_PERMISSION_DENIED;
783 error = TETHERING_ERROR_OPERATION_FAILED;
784 g_error_free(g_error);
787 g_variant_get(g_var, "(u)", &info);
788 error = __get_error(info);
792 INFO("cfm event : wifi tethering enable info : %d\n", error); //LCOV_EXCL_LINE
794 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
795 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_ON].name,
796 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
797 sigs[E_SIGNAL_WIFI_TETHER_ON].cb, (gpointer)th, NULL);
800 INFO("-\n"); //LCOV_EXCL_LINE
803 ecb(error, TETHERING_TYPE_WIFI, true, data);
804 g_variant_unref(g_var);
805 INFO("-\n"); //LCOV_EXCL_LINE
808 static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
811 DBG("+\n"); //LCOV_EXCL_LINE
812 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
813 GError *g_error = NULL;
816 tethering_error_e error;
818 __tethering_h *th = (__tethering_h *)user_data;
819 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_BT];
820 void *data = th->enabled_user_data[TETHERING_TYPE_BT];
822 if (!_tethering_check_handle((tethering_h)user_data))
825 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
828 ERR("DBus error [%s]\n", g_error->message);
829 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
830 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
831 g_error_free(g_error);
832 tethering_enable((tethering_h)th, TETHERING_TYPE_BT);
836 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
837 error = TETHERING_ERROR_PERMISSION_DENIED;
839 error = TETHERING_ERROR_OPERATION_FAILED;
840 g_error_free(g_error);
843 g_variant_get(g_var, "(u)", &info);
844 g_variant_unref(g_var);
845 error = __get_error(info);
849 sigs[E_SIGNAL_BT_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
850 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_ON].name,
851 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
852 sigs[E_SIGNAL_BT_TETHER_ON].cb, (gpointer)th, NULL);
855 DBG("-\n"); //LCOV_EXCL_LINE
859 ecb(error, TETHERING_TYPE_BT, true, data);
864 static void __usb_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
869 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
870 __tethering_h *th = (__tethering_h *)user_data;
871 GError *g_error = NULL;
874 tethering_error_e error;
875 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_USB];
876 void *data = th->enabled_user_data[TETHERING_TYPE_USB];
878 if (!_tethering_check_handle((tethering_h)user_data))
881 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
883 ERR("DBus error [%s]\n", g_error->message);
884 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
885 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
886 g_error_free(g_error);
887 tethering_enable((tethering_h)th, TETHERING_TYPE_USB);
891 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
892 error = TETHERING_ERROR_PERMISSION_DENIED;
894 error = TETHERING_ERROR_OPERATION_FAILED;
895 g_error_free(g_error);
897 g_variant_get(g_var, "(u)", &info);
898 g_variant_unref(g_var);
899 error = __get_error(info);
903 sigs[E_SIGNAL_USB_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
904 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_ON].name,
905 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
906 sigs[E_SIGNAL_USB_TETHER_ON].cb, (gpointer)th, NULL);
913 ecb(error, TETHERING_TYPE_USB, true, data);
917 static void __p2p_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
922 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
923 __tethering_h *th = (__tethering_h *)user_data;
924 GError *g_error = NULL;
927 tethering_error_e error;
928 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_P2P];
929 void *data = th->enabled_user_data[TETHERING_TYPE_P2P];
931 if (!_tethering_check_handle((tethering_h)user_data))
934 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
936 ERR("DBus error [%s]\n", g_error->message);
937 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
938 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
939 g_error_free(g_error);
940 tethering_enable((tethering_h)th, TETHERING_TYPE_P2P);
944 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
945 error = TETHERING_ERROR_PERMISSION_DENIED;
947 error = TETHERING_ERROR_OPERATION_FAILED;
948 g_error_free(g_error);
950 g_variant_get(g_var, "(u)", &info);
951 g_variant_unref(g_var);
952 error = __get_error(info);
961 ecb(error, TETHERING_TYPE_P2P, true, data);
966 static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res,
969 INFO("+\n"); //LCOV_EXCL_LINE
971 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
972 GError *g_error = NULL;
974 guint info, event_type;
975 tethering_error_e error;
976 tethering_type_e type;
977 tethering_h tethering = (tethering_h)user_data;
978 __tethering_h *th = (__tethering_h *)tethering;
979 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_REQUEST;
980 tethering_disabled_cb dcb = NULL;
983 if (!_tethering_check_handle((tethering_h)user_data))
986 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
989 ERR("DBus error [%s]\n", g_error->message);
990 g_error_free(g_error);
994 g_variant_get(g_var, "(uu)", &event_type, &info);
995 INFO("cfm event : %d info : %d\n", event_type, info);
996 g_variant_unref(g_var);
997 error = __get_error(info);
998 INFO("cfm event : %d info : %d\n", event_type, error);
999 switch (event_type) {
1000 case MOBILE_AP_DISABLE_WIFI_TETHERING_CFM:
1001 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1002 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_OFF].name,
1003 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1004 sigs[E_SIGNAL_WIFI_TETHER_OFF].cb, (gpointer)th, NULL);
1006 type = TETHERING_TYPE_WIFI;
1007 dcb = th->disabled_cb[type];
1008 data = th->disabled_user_data[type];
1010 dcb(error, type, code, data);
1013 case MOBILE_AP_DISABLE_BT_TETHERING_CFM:
1014 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1015 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_OFF].name,
1016 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1017 sigs[E_SIGNAL_BT_TETHER_OFF].cb, (gpointer)th, NULL);
1019 type = TETHERING_TYPE_BT;
1020 dcb = th->disabled_cb[type];
1021 data = th->disabled_user_data[type];
1023 dcb(error, type, code, data);
1027 case MOBILE_AP_DISABLE_USB_TETHERING_CFM:
1028 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1029 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
1030 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1031 sigs[E_SIGNAL_USB_TETHER_OFF].cb, (gpointer)th, NULL);
1033 type = TETHERING_TYPE_USB;
1034 dcb = th->disabled_cb[type];
1035 data = th->disabled_user_data[type];
1037 dcb(error, type, code, data);
1040 case MOBILE_AP_DISABLE_P2P_TETHERING_CFM:
1041 type = TETHERING_TYPE_P2P;
1042 dcb = th->disabled_cb[type];
1043 data = th->disabled_user_data[type];
1045 dcb(error, type, code, data);
1048 case MOBILE_AP_DISABLE_CFM:
1050 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1051 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_OFF].name,
1052 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1053 sigs[E_SIGNAL_WIFI_TETHER_OFF].cb, (gpointer)th, NULL);
1054 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1055 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_OFF].name,
1056 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1057 sigs[E_SIGNAL_BT_TETHER_OFF].cb, (gpointer)th, NULL);
1058 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1059 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
1060 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1061 sigs[E_SIGNAL_USB_TETHER_OFF].cb, (gpointer)th, NULL);
1063 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
1064 dcb = th->disabled_cb[type];
1067 data = th->disabled_user_data[type];
1069 dcb(error, type, code, data);
1074 ERR("Invalid event\n");
1078 INFO("-\n"); //LCOV_EXCL_LINE
1081 static void __get_data_usage_cb(GObject *source_object, GAsyncResult *res,
1086 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1088 GError *g_error = NULL;
1091 guint64 tx_bytes, rx_bytes;
1092 __tethering_h *th = (__tethering_h *)user_data;
1093 tethering_error_e tethering_error = TETHERING_ERROR_NONE;
1096 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1099 ERR("DBus fail [%s]\n", g_error->message);
1100 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1101 tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1103 tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1108 if (th->data_usage_cb == NULL) {
1109 ERR("There is no data_usage_cb\n"); //LCOV_EXCL_LINE
1113 th->data_usage_cb(tethering_error, 0LL, 0LL, th->data_usage_user_data);
1115 g_variant_get(g_var, "(utt)", &event_type, &tx_bytes, &rx_bytes);
1116 th->data_usage_cb(TETHERING_ERROR_NONE,
1117 rx_bytes, tx_bytes, th->data_usage_user_data);
1118 g_variant_unref(g_var);
1120 th->data_usage_cb = NULL;
1121 th->data_usage_user_data = NULL;
1126 static void __settings_reloaded_cb(GObject *source_object, GAsyncResult *res,
1131 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1132 GError *g_error = NULL;
1135 __tethering_h *th = (__tethering_h *)user_data;
1136 tethering_error_e tethering_error = TETHERING_ERROR_NONE;
1138 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1140 ERR("DBus fail [%s]\n", g_error->message); //LCOV_EXCL_LINE
1141 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1142 tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1144 tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1145 g_error_free(g_error);
1147 if (th->settings_reloaded_cb == NULL) {
1148 DBG("There is no settings_reloaded_cb\n-\n");
1151 g_variant_get(g_var, "(u)", &info);
1152 if (tethering_error == TETHERING_ERROR_NONE)
1153 tethering_error = __get_error(info);
1154 g_variant_unref(g_var);
1156 th->settings_reloaded_cb(tethering_error,
1157 th->settings_reloaded_user_data);
1159 th->settings_reloaded_cb = NULL;
1160 th->settings_reloaded_user_data = NULL;
1164 static void __connect_signals(tethering_h tethering)
1167 _retm_if(tethering == NULL, "parameter(tethering) is NULL\n");
1169 __tethering_h *th = (__tethering_h *)tethering;
1170 GDBusConnection *connection = th->client_bus;
1173 for (i = E_SIGNAL_NET_CLOSED; i < E_SIGNAL_MAX; i++) {
1174 sigs[i].sig_id = g_dbus_connection_signal_subscribe(connection,
1175 NULL, TETHERING_SERVICE_INTERFACE, sigs[i].name,
1176 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1177 sigs[i].cb, tethering, NULL);
1182 static void __disconnect_signals(tethering_h tethering)
1186 _retm_if(tethering == NULL, "parameter(tethering) is NULL\n");
1188 __tethering_h *th = (__tethering_h *)tethering;
1189 GDBusConnection *connection = th->client_bus;
1193 for (i = E_SIGNAL_NET_CLOSED; i < E_SIGNAL_MAX; i++)
1194 g_dbus_connection_signal_unsubscribe(connection, sigs[i].sig_id);
1200 static bool __get_intf_name(tethering_type_e type, char *buf, unsigned int len)
1202 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1206 case TETHERING_TYPE_USB:
1207 g_strlcpy(buf, TETHERING_USB_IF, len);
1210 case TETHERING_TYPE_WIFI:
1211 g_strlcpy(buf, TETHERING_WIFI_IF, len);
1214 case TETHERING_TYPE_BT:
1215 g_strlcpy(buf, TETHERING_BT_IF, len);
1220 ERR("Not supported type : %d\n", type);
1227 static bool __get_gateway_addr(tethering_type_e type, char *buf, unsigned int len)
1229 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1233 case TETHERING_TYPE_USB:
1234 g_strlcpy(buf, TETHERING_USB_GATEWAY, len);
1237 case TETHERING_TYPE_WIFI:
1238 g_strlcpy(buf, TETHERING_WIFI_GATEWAY, len);
1241 case TETHERING_TYPE_BT:
1242 g_strlcpy(buf, TETHERING_BT_GATEWAY, len);
1246 ERR("Not supported type : %d\n", type);
1253 static int __get_common_ssid(char *ssid, unsigned int size)
1256 ERR("ssid is null\n"); //LCOV_EXCL_LINE
1257 return TETHERING_ERROR_INVALID_PARAMETER;
1261 char *ptr_tmp = NULL;
1263 ptr = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
1265 ERR("vconf_get_str is failed and set default ssid");
1266 g_strlcpy(ssid, TETHERING_DEFAULT_SSID, size);
1268 g_strlcpy(ssid, ptr, size);
1272 if (!g_utf8_validate(ssid, -1, (const char **)&ptr_tmp))
1275 return TETHERING_ERROR_NONE;
1278 static bool __get_wifi_mode_type(tethering_wifi_mode_type_e type, char **buf)
1280 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1283 case TETHERING_WIFI_MODE_TYPE_B:
1284 *buf = g_strdup("b");
1286 case TETHERING_WIFI_MODE_TYPE_G:
1287 *buf = g_strdup("g");
1289 case TETHERING_WIFI_MODE_TYPE_A:
1290 *buf = g_strdup("a");
1292 case TETHERING_WIFI_MODE_TYPE_AD:
1293 *buf = g_strdup("ad");
1296 ERR("Not supported type : %d\n", type);
1302 static int __prepare_wifi_settings(tethering_h tethering, _softap_settings_t *set)
1306 __tethering_h *th = (__tethering_h *)tethering;
1307 tethering_error_e ret = TETHERING_ERROR_NONE;
1310 if (th == NULL || set == NULL) {
1311 ERR("null parameter\n-\n"); //LCOV_EXCL_LINE
1312 return TETHERING_ERROR_INVALID_PARAMETER;
1315 if (th->ssid == NULL)
1316 __get_common_ssid(set->ssid, sizeof(set->ssid));
1318 g_strlcpy(set->ssid, th->ssid, sizeof(set->ssid));
1320 ret = __get_security_type(&set->sec_type);
1321 if (ret != TETHERING_ERROR_NONE)
1322 set->sec_type = th->sec_type;
1324 ret = __get_visible(&set->visibility);
1325 if (ret != TETHERING_ERROR_NONE)
1326 set->visibility = th->visibility;
1328 set->mac_filter = th->mac_filter;
1329 set->max_connected = th->wifi_max_connected;
1330 set->channel = th->channel;
1332 __get_wifi_mode_type(th->mode_type, &ptr);
1334 g_strlcpy(set->mode, "", sizeof(set->mode));
1336 g_strlcpy(set->mode, ptr, sizeof(set->mode));
1340 if (set->sec_type == TETHERING_WIFI_SECURITY_TYPE_NONE) {
1341 g_strlcpy(set->key, "", sizeof(set->key));
1343 GDBusProxy *proxy = th->client_bus_proxy;
1344 GVariant *parameters;
1345 GError *error = NULL;
1346 char *passphrase = NULL;
1347 unsigned int len = 0;
1349 parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_passphrase",
1350 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1354 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
1356 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
1357 ret = TETHERING_ERROR_PERMISSION_DENIED;
1359 ret = TETHERING_ERROR_OPERATION_FAILED;
1361 g_error_free(error);
1366 if (parameters != NULL) {
1367 g_variant_get(parameters, "(siu)", &passphrase, &len, &ret);
1368 g_variant_unref(parameters);
1371 g_strlcpy(set->key, passphrase, sizeof(set->key));
1374 INFO("ssid: %s security: %d mode: %s channel: %d visibility: %s\n",
1375 set->ssid, set->sec_type, set->mode, set->channel,
1376 (set->visibility) ? "true" : "false");
1378 return TETHERING_ERROR_NONE;
1381 static bool __check_precondition(tethering_type_e type)
1383 int dnet_status = 0;
1384 int cellular_state = 0;
1386 /* data network through cellular */
1387 vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &cellular_state);
1388 if (cellular_state == VCONFKEY_NETWORK_CELLULAR_ON) {
1389 INFO("Data Network can be connected later");
1393 /* data network status */
1394 vconf_get_int(VCONFKEY_NETWORK_STATUS, &dnet_status);
1395 if ((dnet_status == VCONFKEY_NETWORK_WIFI
1396 && type != TETHERING_TYPE_WIFI)
1397 || dnet_status == VCONFKEY_NETWORK_ETHERNET)
1400 ERR("Network is not available!");
1406 * @brief Creates the handle of tethering.
1408 * @privlevel platform
1409 * @privilege http://tizen.org/privilege/tethering.admin
1410 * @remarks The @a tethering must be released tethering_destroy() by you.
1411 * @param[out] tethering A handle of a new mobile ap handle on success
1412 * @return 0 on success, otherwise a negative error value.
1413 * @retval #TETHERING_ERROR_NONE Successful
1414 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1415 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1416 * @retval #TETHERING_ERROR_NOT_SUPPORT_API API is not supported
1417 * @see tethering_destroy()
1419 API int tethering_create(tethering_h *tethering)
1421 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1422 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1423 "parameter(tethering) is NULL\n");
1426 __tethering_h *th = NULL;
1427 GError *error = NULL;
1428 char ssid[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
1430 th = (__tethering_h *)malloc(sizeof(__tethering_h));
1432 _retvm_if(th == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
1433 "malloc is failed\n");
1434 memset(th, 0x00, sizeof(__tethering_h));
1435 th->sec_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK;
1436 th->visibility = true;
1437 th->mac_filter = false;
1438 th->channel = TETHERING_WIFI_CHANNEL;
1439 th->mode_type = TETHERING_WIFI_MODE_TYPE_G;
1440 th->wifi_max_connected = TETHERING_WIFI_MAX_STA;
1442 if (__generate_initial_passphrase(th->passphrase,
1443 sizeof(th->passphrase)) == 0) {
1445 ERR("random passphrase generation failed\n");
1447 return TETHERING_ERROR_OPERATION_FAILED;
1451 if (__get_common_ssid(ssid, sizeof(ssid)) != TETHERING_ERROR_NONE) {
1453 ERR("common ssid get failed\n");
1455 return TETHERING_ERROR_OPERATION_FAILED;
1459 #if !GLIB_CHECK_VERSION(2, 36, 0)
1462 GCancellable *cancellable = g_cancellable_new();
1463 th->client_bus = g_bus_get_sync(DBUS_BUS_SYSTEM, cancellable, &error);
1466 ERR("Couldn't connect to the System bus[%s]", error->message);
1467 g_error_free(error);
1468 g_cancellable_cancel(cancellable);
1469 g_object_unref(cancellable);
1471 return TETHERING_ERROR_OPERATION_FAILED;
1474 th->cancellable = cancellable;
1476 th->client_bus_proxy = g_dbus_proxy_new_sync(th->client_bus, G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION,
1477 NULL, TETHERING_SERVICE_NAME, TETHERING_SERVICE_OBJECT_PATH,
1478 TETHERING_SERVICE_INTERFACE, th->cancellable, &error);
1479 if (!th->client_bus_proxy) {
1482 ERR("Couldn't create the proxy object because of %s\n", error->message);
1483 g_cancellable_cancel(th->cancellable);
1484 g_object_unref(th->cancellable);
1485 g_object_unref(th->client_bus);
1487 return TETHERING_ERROR_OPERATION_FAILED;
1491 __connect_signals((tethering_h)th);
1493 *tethering = (tethering_h)th;
1494 _tethering_add_handle(th);
1495 INFO("Tethering Handle : %p\n", th);
1497 return TETHERING_ERROR_NONE;
1502 * @brief Destroys the handle of tethering.
1504 * @privlevel platform
1505 * @privilege http://tizen.org/privilege/tethering.admin
1506 * @param[in] tethering The handle of tethering
1507 * @return 0 on success, otherwise a negative error value.
1508 * @retval #TETHERING_ERROR_NONE Successful
1509 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1510 * @see tethering_create()
1512 API int tethering_destroy(tethering_h tethering)
1515 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1516 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1517 "parameter(tethering) is NULL\n");
1519 __tethering_h *th = (__tethering_h *)tethering;
1521 INFO("Tethering Handle : %p\n", th);
1523 __disconnect_signals(tethering);
1524 _tethering_remove_handle(th);
1529 g_object_unref(th->cancellable);
1530 g_object_unref(th->client_bus_proxy);
1531 g_object_unref(th->client_bus);
1532 memset(th, 0x00, sizeof(__tethering_h));
1537 return TETHERING_ERROR_NONE;
1542 * @brief Enables the tethering, asynchronously.
1544 * @privlevel platform
1545 * @privilege http://tizen.org/privilege/tethering.admin
1546 * @param[in] tethering The handle of tethering
1547 * @param[in] type The type of tethering
1548 * @return 0 on success, otherwise negative error value.
1549 * @retval #TETHERING_ERROR_NONE Successful
1550 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1551 * @post tethering_enabled_cb() will be invoked.
1552 * @see tethering_is_enabled()
1553 * @see tethering_disable()
1555 API int tethering_enable(tethering_h tethering, tethering_type_e type)
1557 INFO("+ type : %d\n", type);
1558 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1559 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1560 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1561 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1563 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1564 "parameter(tethering) is NULL\n");
1566 tethering_error_e ret = TETHERING_ERROR_NONE;
1567 __tethering_h *th = (__tethering_h *)tethering;
1568 GDBusProxy *proxy = th->client_bus_proxy;
1569 GDBusConnection *connection = th->client_bus;
1571 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
1573 if (__check_precondition(type) == FALSE) {
1576 return TETHERING_ERROR_OPERATION_FAILED;
1582 case TETHERING_TYPE_USB:
1583 g_dbus_connection_signal_unsubscribe(connection,
1584 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1586 g_dbus_proxy_call(proxy, "enable_usb_tethering",
1587 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1588 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1589 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1593 case TETHERING_TYPE_WIFI: {
1594 _softap_settings_t set = {"", "", "", 0, false};
1596 ret = __prepare_wifi_settings(tethering, &set);
1597 if (ret != TETHERING_ERROR_NONE) {
1599 ERR("softap settings initialization failed\n");
1601 return TETHERING_ERROR_OPERATION_FAILED;
1604 g_dbus_connection_signal_unsubscribe(connection,
1605 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1607 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1608 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),
1609 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1610 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1614 case TETHERING_TYPE_BT:
1615 g_dbus_connection_signal_unsubscribe(connection,
1616 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1618 g_dbus_proxy_call(proxy, "enable_bt_tethering",
1619 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1620 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1621 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1626 case TETHERING_TYPE_P2P: {
1627 _softap_settings_t p2p_set = {"", "", "", 0, false};
1628 ret = __prepare_wifi_settings(tethering, &p2p_set);
1629 if (ret != TETHERING_ERROR_NONE) {
1630 ERR("p2p settings initialization failed\n");
1632 return TETHERING_ERROR_OPERATION_FAILED;
1635 g_dbus_proxy_call(proxy, "enable_p2p_tethering",
1636 g_variant_new("(ssi)", p2p_set.ssid, p2p_set.key, p2p_set.channel),
1637 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1638 (GAsyncReadyCallback) __p2p_enabled_cfm_cb, (gpointer)tethering);
1642 case TETHERING_TYPE_ALL: {
1643 _softap_settings_t set = {"", "", "", 0, false};
1645 ret = __prepare_wifi_settings(tethering, &set);
1646 if (ret != TETHERING_ERROR_NONE) {
1647 ERR("softap settings initialization failed\n");
1648 return TETHERING_ERROR_OPERATION_FAILED;
1651 /* TETHERING_TYPE_USB */
1652 g_dbus_connection_signal_unsubscribe(connection,
1653 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1655 g_dbus_proxy_call(proxy, "enable_usb_tethering",
1656 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1657 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1658 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1660 /* TETHERING_TYPE_WIFI */
1661 g_dbus_connection_signal_unsubscribe(connection,
1662 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1664 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1665 g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode,
1666 set.channel, set.visibility, set.mac_filter, set.max_connected,
1667 set.sec_type, TETHERING_ADDRESS_FAMILY_IPV4),
1668 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1669 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1671 /* TETHERING_TYPE_BT */
1672 g_dbus_connection_signal_unsubscribe(connection,
1673 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1675 g_dbus_proxy_call(proxy, "enable_bt_tethering",
1676 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1677 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1678 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1682 ERR("Unknown type : %d\n", type);
1684 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1687 return TETHERING_ERROR_INVALID_PARAMETER;
1691 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1693 return TETHERING_ERROR_NONE;
1696 API int tethering_ipv6_enable(tethering_h tethering, tethering_type_e type)
1698 DBG("+ type : %d\n", type);
1699 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1700 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1701 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1702 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1704 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1705 "parameter(tethering) is NULL\n");
1707 __tethering_h *th = (__tethering_h *)tethering;
1708 GDBusProxy *proxy = th->client_bus_proxy;
1709 GDBusConnection *connection = th->client_bus;
1712 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
1714 if (__check_precondition(type) == FALSE) {
1717 return TETHERING_ERROR_OPERATION_FAILED;
1722 case TETHERING_TYPE_USB: {
1723 g_dbus_connection_signal_unsubscribe(connection,
1724 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1726 g_dbus_proxy_call(proxy, "enable_usb_tethering",
1727 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1728 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1729 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1733 case TETHERING_TYPE_WIFI: {
1734 _softap_settings_t set = {"", "", "", 0, false, false, 0, 0};
1736 ret = __prepare_wifi_settings(tethering, &set);
1737 if (ret != TETHERING_ERROR_NONE) {
1738 ERR("softap settings initialization failed\n");
1740 return TETHERING_ERROR_OPERATION_FAILED;
1742 g_dbus_connection_signal_unsubscribe(connection,
1743 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1744 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1745 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),
1746 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1747 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1751 case TETHERING_TYPE_BT: {
1752 g_dbus_connection_signal_unsubscribe(connection,
1753 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1755 g_dbus_proxy_call(proxy, "enable_bt_tethering",
1756 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1757 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1758 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1764 ERR("Unknown type : %d\n", type);
1766 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1769 return TETHERING_ERROR_INVALID_PARAMETER;
1773 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1775 return TETHERING_ERROR_NONE;
1778 API int tethering_ipv6_disable(tethering_h tethering, tethering_type_e type)
1780 DBG("+ type : %d\n", type);
1781 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1782 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1783 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1784 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1786 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1787 "parameter(tethering) is NULL\n");
1789 __tethering_h *th = (__tethering_h *)tethering;
1790 GDBusProxy *proxy = th->client_bus_proxy;
1791 GDBusConnection *connection = th->client_bus;
1794 case TETHERING_TYPE_USB:
1795 g_dbus_connection_signal_unsubscribe(connection,
1796 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1798 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1799 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1800 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1801 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1804 case TETHERING_TYPE_WIFI:
1805 DBG("Disable wifi tethering..");
1806 g_dbus_connection_signal_unsubscribe(connection,
1807 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1809 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1810 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1811 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1812 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1815 case TETHERING_TYPE_BT:
1816 g_dbus_connection_signal_unsubscribe(connection,
1817 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1819 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1820 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1821 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1822 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1826 ERR("Not supported tethering type [%d]\n", type);
1828 return TETHERING_ERROR_INVALID_PARAMETER;
1831 return TETHERING_ERROR_NONE;
1835 * @brief Disables the tethering, asynchronously.
1837 * @privlevel platform
1838 * @privilege http://tizen.org/privilege/tethering.admin
1839 * @param[in] tethering The handle of tethering
1840 * @param[in] type The type of tethering
1841 * @return 0 on success, otherwise negative error value.
1842 * @retval #TETHERING_ERROR_NONE Successful
1843 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1844 * @post tethering_disabled_cb() will be invoked.
1845 * @see tethering_is_enabled()
1846 * @see tethering_enable()
1848 API int tethering_disable(tethering_h tethering, tethering_type_e type)
1850 INFO("+ type : %d\n", type);
1851 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1852 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1853 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1854 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1856 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1857 "parameter(tethering) is NULL\n");
1859 __tethering_h *th = (__tethering_h *)tethering;
1860 GDBusProxy *proxy = th->client_bus_proxy;
1861 GDBusConnection *connection = th->client_bus;
1865 case TETHERING_TYPE_USB:
1866 g_dbus_connection_signal_unsubscribe(connection,
1867 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1869 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1870 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1871 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1872 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1877 case TETHERING_TYPE_WIFI:
1879 g_dbus_connection_signal_unsubscribe(connection,
1880 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1882 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1883 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1884 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1885 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1888 case TETHERING_TYPE_BT:
1890 g_dbus_connection_signal_unsubscribe(connection,
1891 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1893 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1894 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1895 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1896 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1900 case TETHERING_TYPE_P2P:
1901 g_dbus_proxy_call(proxy, "disable_p2p_tethering",
1902 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1903 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1906 case TETHERING_TYPE_ALL:
1907 g_dbus_connection_signal_unsubscribe(connection,
1908 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1910 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1911 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1912 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1913 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1915 g_dbus_connection_signal_unsubscribe(connection,
1916 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1918 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1919 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1920 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1921 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1923 g_dbus_connection_signal_unsubscribe(connection,
1924 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1926 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1927 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1928 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1929 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1933 ERR("Not supported tethering type [%d]\n", type);
1935 return TETHERING_ERROR_INVALID_PARAMETER;
1939 return TETHERING_ERROR_NONE;
1944 * @brief Checks whetehr the tethering is enabled or not.
1946 * @privlevel platform
1947 * @privilege http://tizen.org/privilege/tethering.admin
1948 * @param[in] tethering The handle of tethering
1949 * @param[in] type The type of tethering
1950 * @return @c true if tethering is enabled, \n @c false if tethering is disabled.
1952 API bool tethering_is_enabled(tethering_h tethering, tethering_type_e type)
1954 INFO("+ type : %d\n", type);
1956 int vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_NONE;
1958 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1960 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &is_on) != 0)
1964 case TETHERING_TYPE_USB:
1965 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_USB;
1968 case TETHERING_TYPE_WIFI:
1969 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI;
1972 case TETHERING_TYPE_BT:
1973 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_BT;
1976 case TETHERING_TYPE_P2P:
1977 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_P2P;
1981 ERR("Not supported type : %d\n", type);
1984 INFO("- enabled: %s\n", (is_on & vconf_type) ? "true" : "false");
1985 return is_on & vconf_type ? true : false;
1990 * @brief Gets the MAC address of local device as "FC:A1:3E:D6:B1:B1".
1992 * @privlevel platform
1993 * @privilege http://tizen.org/privilege/tethering.admin
1994 * @remarks @a mac_address must be released with free() by you.
1995 * @param[in] tethering The handle of tethering
1996 * @param[in] type The type of tethering
1997 * @param[out] mac_address The MAC address
1998 * @return 0 on success, otherwise a negative error value.
1999 * @retval #TETHERING_ERROR_NONE Successful
2000 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2001 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2002 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2003 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2004 * @pre tethering must be enabled.
2005 * @see tethering_is_enabled()
2006 * @see tethering_enable()
2008 API int tethering_get_mac_address(tethering_h tethering, tethering_type_e type, char **mac_address)
2010 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2011 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE); //LCOV_EXCL_LINE
2012 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2013 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE); //LCOV_EXCL_LINE
2015 _retvm_if(tethering_is_enabled(tethering, type) == false,
2016 TETHERING_ERROR_NOT_ENABLED,
2017 "tethering type[%d] is not enabled\n", type);
2018 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2019 "parameter(tethering) is NULL\n");
2020 _retvm_if(mac_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2021 "parameter(mac_address) is NULL\n");
2025 char *macbuf = NULL;
2027 _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
2028 TETHERING_ERROR_OPERATION_FAILED,
2029 "getting interface name is failed\n");
2031 s = socket(AF_INET, SOCK_DGRAM, 0);
2032 _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
2033 "getting socket is failed\n");
2034 if (ioctl(s, SIOCGIFHWADDR, &ifr) < 0) {
2036 ERR("getting mac is failed\n");
2038 return TETHERING_ERROR_OPERATION_FAILED;
2043 macbuf = (char *)malloc(TETHERING_STR_INFO_LEN);
2044 _retvm_if(macbuf == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2045 "Not enough memory\n");
2046 snprintf(macbuf, TETHERING_STR_INFO_LEN, "%02X:%02X:%02X:%02X:%02X:%02X",
2047 (unsigned char)ifr.ifr_hwaddr.sa_data[0],
2048 (unsigned char)ifr.ifr_hwaddr.sa_data[1],
2049 (unsigned char)ifr.ifr_hwaddr.sa_data[2],
2050 (unsigned char)ifr.ifr_hwaddr.sa_data[3],
2051 (unsigned char)ifr.ifr_hwaddr.sa_data[4],
2052 (unsigned char)ifr.ifr_hwaddr.sa_data[5]);
2054 *mac_address = macbuf;
2056 return TETHERING_ERROR_NONE;
2061 * @brief Gets the name of network interface. For example, usb0.
2063 * @privlevel platform
2064 * @privilege http://tizen.org/privilege/tethering.admin
2065 * @remarks @a interface_name must be released with free() by you.
2066 * @param[in] tethering The handle of tethering
2067 * @param[in] type The type of tethering
2068 * @param[out] interface_name The name of network interface
2069 * @return 0 on success, otherwise negative error value.
2070 * @retval #TETHERING_ERROR_NONE Successful
2071 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2072 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2073 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2074 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2075 * @pre tethering must be enabled.
2076 * @see tethering_is_enabled()
2077 * @see tethering_enable()
2079 API int tethering_get_network_interface_name(tethering_h tethering, tethering_type_e type, char **interface_name)
2081 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2082 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2083 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2084 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2086 _retvm_if(tethering_is_enabled(tethering, type) == false,
2087 TETHERING_ERROR_NOT_ENABLED,
2088 "tethering type[%d] is not enabled\n", type);
2089 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2090 "parameter(tethering) is NULL\n");
2091 _retvm_if(interface_name == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2092 "parameter(interface_name) is NULL\n");
2094 char intf[TETHERING_STR_INFO_LEN] = {0, };
2096 _retvm_if(!__get_intf_name(type, intf, sizeof(intf)),
2097 TETHERING_ERROR_OPERATION_FAILED,
2098 "getting interface name is failed\n");
2099 *interface_name = strdup(intf);
2100 _retvm_if(*interface_name == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2101 "Not enough memory\n");
2103 return TETHERING_ERROR_NONE;
2108 * @brief Gets the local IP address.
2110 * @privlevel platform
2111 * @privilege http://tizen.org/privilege/tethering.admin
2112 * @remarks @a ip_address must be released with free() by you.
2113 * @param[in] tethering The handle of tethering
2114 * @param[in] type The type of tethering
2115 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2116 * @param[out] ip_address The local IP address
2117 * @return 0 on success, otherwise negative error value.
2118 * @retval #TETHERING_ERROR_NONE Successful
2119 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2120 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2121 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2122 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2123 * @pre tethering must be enabled.
2124 * @see tethering_is_enabled()
2125 * @see tethering_enable()
2127 API int tethering_get_ip_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **ip_address)
2129 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2130 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE); //LCOV_EXCL_LINE
2131 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2132 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE); //LCOV_EXCL_LINE
2134 _retvm_if(tethering_is_enabled(tethering, type) == false,
2135 TETHERING_ERROR_NOT_ENABLED,
2136 "tethering type[%d] is not enabled\n", type);
2137 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2138 "parameter(tethering) is NULL\n");
2139 _retvm_if(ip_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2140 "parameter(ip_address) is NULL\n");
2146 _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
2147 TETHERING_ERROR_OPERATION_FAILED,
2148 "getting interface name is failed\n");
2150 s = socket(AF_INET, SOCK_DGRAM, 0);
2151 _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
2152 "getting socket is failed\n");
2153 if (ioctl(s, SIOCGIFADDR, &ifr) < 0) {
2154 ERR("ioctl is failed\n");
2156 return TETHERING_ERROR_OPERATION_FAILED;
2160 ipbuf = inet_ntoa(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr);
2161 *ip_address = strdup(ipbuf);
2162 _retvm_if(*ip_address == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2163 "Not enough memory\n");
2165 return TETHERING_ERROR_NONE;
2170 * @brief Gets the Gateway address.
2172 * @privlevel platform
2173 * @privilege http://tizen.org/privilege/tethering.admin
2174 * @remarks @a gateway_address must be released with free() by you.
2175 * @param[in] tethering The handle of tethering
2176 * @param[in] type The type of tethering
2177 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2178 * @param[out] gateway_address The local IP address
2179 * @return 0 on success, otherwise negative error value.
2180 * @retval #TETHERING_ERROR_NONE Successful
2181 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2182 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2183 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2184 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2185 * @pre tethering must be enabled.
2186 * @see tethering_is_enabled()
2187 * @see tethering_enable()
2189 API int tethering_get_gateway_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **gateway_address)
2191 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2192 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2193 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2194 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2196 _retvm_if(tethering_is_enabled(tethering, type) == false,
2197 TETHERING_ERROR_NOT_ENABLED,
2198 "tethering type[%d] is not enabled\n", type);
2199 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2200 "parameter(tethering) is NULL\n");
2201 _retvm_if(gateway_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2202 "parameter(gateway_address) is NULL\n");
2204 char gateway_buf[TETHERING_STR_INFO_LEN] = {0, };
2206 _retvm_if(!__get_gateway_addr(type, gateway_buf, sizeof(gateway_buf)),
2207 TETHERING_ERROR_OPERATION_FAILED,
2208 "getting gateway address is failed\n");
2210 *gateway_address = strdup(gateway_buf);
2212 return TETHERING_ERROR_NONE;
2217 * @brief Gets the Subnet Mask.
2219 * @privlevel platform
2220 * @privilege http://tizen.org/privilege/tethering.admin
2221 * @remarks @a subnet_mask must be released with free() by you.
2222 * @param[in] tethering The handle of tethering
2223 * @param[in] type The type of tethering
2224 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2225 * @param[out] subnet_mask The local IP address
2226 * @return 0 on success, otherwise negative error value.
2227 * @retval #TETHERING_ERROR_NONE Successful
2228 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2229 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2230 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2231 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2232 * @pre tethering must be enabled.
2233 * @see tethering_is_enabled()
2234 * @see tethering_enable()
2236 API int tethering_get_subnet_mask(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **subnet_mask)
2238 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2239 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2240 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2241 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2243 _retvm_if(tethering_is_enabled(tethering, type) == false,
2244 TETHERING_ERROR_NOT_ENABLED,
2245 "tethering is not enabled\n");
2246 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2247 "parameter(tethering) is NULL\n");
2248 _retvm_if(subnet_mask == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2249 "parameter(subnet_mask) is NULL\n");
2251 *subnet_mask = strdup(TETHERING_SUBNET_MASK);
2252 _retvm_if(*subnet_mask == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2253 "Not enough memory\n");
2255 return TETHERING_ERROR_NONE;
2260 * @brief Gets the data usage.
2262 * @privlevel platform
2263 * @privilege http://tizen.org/privilege/tethering.admin
2264 * @param[in] tethering The handle of tethering
2265 * @param[out] usage The data usage
2266 * @return 0 on success, otherwise negative error value.
2267 * @retval #TETHERING_ERROR_NONE Successful
2268 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2269 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2270 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2271 * @pre tethering must be enabled.
2272 * @see tethering_is_enabled()
2273 * @see tethering_enable()
2275 API int tethering_get_data_usage(tethering_h tethering, tethering_data_usage_cb callback, void *user_data)
2277 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2279 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2280 "parameter(tethering) is NULL\n");
2281 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2282 "parameter(callback) is NULL\n");
2283 _retvm_if(__any_tethering_is_enabled(tethering) == false,
2284 TETHERING_ERROR_NOT_ENABLED,
2285 "tethering is not enabled\n");
2287 __tethering_h *th = (__tethering_h *)tethering;
2288 GDBusProxy *proxy = th->client_bus_proxy;
2290 th->data_usage_cb = callback;
2291 th->data_usage_user_data = user_data;
2293 g_dbus_proxy_call(proxy, "get_data_packet_usage",
2294 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2295 (GAsyncReadyCallback) __get_data_usage_cb, (gpointer)tethering);
2297 return TETHERING_ERROR_NONE;
2302 * @brief Gets the client which is connected by tethering "type".
2304 * @privlevel platform
2305 * @privilege http://tizen.org/privilege/tethering.admin
2306 * @param[in] tethering The handle of tethering
2307 * @param[in] type The type of tethering
2308 * @param[in] callback The callback function to invoke
2309 * @param[in] user_data The user data to be passed to the callback function
2310 * @retval #TETHERING_ERROR_NONE Successful
2311 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2312 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2313 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2314 * @pre tethering must be enabled.
2315 * @see tethering_is_enabled()
2316 * @see tethering_enable()
2318 API int tethering_foreach_connected_clients(tethering_h tethering, tethering_type_e type, tethering_connected_client_cb callback, void *user_data)
2320 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2321 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2322 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2323 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2325 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2326 "parameter(tethering) is NULL\n");
2327 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2328 "parameter(callback) is NULL\n");
2329 _retvm_if(__any_tethering_is_enabled(tethering) == false,
2330 TETHERING_ERROR_NOT_ENABLED,
2331 "tethering is not enabled\n");
2333 mobile_ap_type_e interface;
2334 __tethering_h *th = (__tethering_h *)tethering;
2335 __tethering_client_h client = {0, };
2338 gchar *hostname = NULL;
2339 guint timestamp = 0;
2340 GError *error = NULL;
2341 GVariant *result = NULL;
2342 GVariantIter *outer_iter = NULL;
2343 GVariantIter *inner_iter = NULL;
2344 GVariant *station = NULL;
2345 GVariant *value = NULL;
2348 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "get_station_info",
2349 NULL, G_DBUS_CALL_FLAGS_NONE,
2350 -1, th->cancellable, &error);
2352 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message); //LCOV_EXCL_LINE
2353 g_variant_get(result, "(a(a{sv}))", &outer_iter);
2355 while (g_variant_iter_loop(outer_iter, "(@a{sv})", &station)) {
2356 g_variant_get(station, "a{sv}", &inner_iter);
2357 while (g_variant_iter_loop(inner_iter, "{sv}", &key, &value)) {
2358 if (g_strcmp0(key, "Type") == 0) {
2359 interface = g_variant_get_int32(value);
2360 if (interface == MOBILE_AP_TYPE_USB)
2361 client.interface = TETHERING_TYPE_USB;
2362 else if (interface == MOBILE_AP_TYPE_WIFI)
2363 client.interface = TETHERING_TYPE_WIFI;
2364 else if (interface == MOBILE_AP_TYPE_BT)
2365 client.interface = TETHERING_TYPE_BT;
2366 else if (interface == MOBILE_AP_TYPE_P2P)
2367 client.interface = TETHERING_TYPE_P2P;
2369 ERR("Invalid interface\n");
2371 g_variant_unref(value);
2374 DBG("interface is %d\n", client.interface);
2375 if (client.interface != type && (TETHERING_TYPE_ALL != type)) {
2377 g_variant_unref(value);
2380 } else if (g_strcmp0(key, "IP") == 0) {
2381 g_variant_get(value, "s", &ip);
2382 SDBG("ip is %s\n", ip);
2383 g_strlcpy(client.ip, ip, sizeof(client.ip));
2384 } else if (g_strcmp0(key, "MAC") == 0) {
2385 g_variant_get(value, "s", &mac);
2386 SDBG("mac is %s\n", mac);
2387 g_strlcpy(client.mac, mac, sizeof(client.mac));
2388 } else if (g_strcmp0(key, "Name") == 0) {
2389 g_variant_get(value, "s", &hostname);
2390 SDBG("hsotname is %s\n", hostname);
2392 client.hostname = g_strdup(hostname);
2393 } else if (g_strcmp0(key, "Time") == 0) {
2394 timestamp = g_variant_get_int32(value);
2395 DBG("timestamp is %d\n", timestamp);
2396 client.tm = (time_t)timestamp;
2398 ERR("Key %s not required\n", key);
2409 g_variant_iter_free(inner_iter);
2410 if (callback((tethering_client_h)&client, user_data) == false) {
2411 DBG("iteration is stopped\n");
2412 g_free(client.hostname);
2413 client.hostname = NULL;
2414 g_variant_iter_free(outer_iter);
2415 g_variant_unref(station);
2416 g_variant_unref(result);
2418 return TETHERING_ERROR_OPERATION_FAILED;
2420 g_free(client.hostname);
2421 client.hostname = NULL;
2424 g_variant_iter_free(outer_iter);
2425 g_variant_unref(station);
2426 g_variant_unref(result);
2428 return TETHERING_ERROR_NONE;
2433 * @brief Registers the callback function called when tethering is enabled.
2435 * @privlevel platform
2436 * @privilege http://tizen.org/privilege/tethering.admin
2437 * @param[in] tethering The handle of tethering
2438 * @param[in] type The type of tethering
2439 * @param[in] callback The callback function to invoke
2440 * @param[in] user_data The user data to be passed to the callback function
2441 * @retval #TETHERING_ERROR_NONE Successful
2442 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2443 * @see tethering_unset_enabled_cb()
2445 API int tethering_set_enabled_cb(tethering_h tethering, tethering_type_e type, tethering_enabled_cb callback, void *user_data)
2447 INFO("+ type: %d\n", type);
2448 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2449 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2450 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2451 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2453 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2454 "parameter(tethering) is NULL\n");
2455 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2456 "parameter(callback) is NULL\n");
2458 __tethering_h *th = (__tethering_h *)tethering;
2459 tethering_type_e ti;
2461 if (type != TETHERING_TYPE_ALL) {
2462 th->enabled_cb[type] = callback;
2463 th->enabled_user_data[type] = user_data;
2465 return TETHERING_ERROR_NONE;
2468 /* TETHERING_TYPE_ALL */
2469 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2470 th->enabled_cb[ti] = callback;
2471 th->enabled_user_data[ti] = user_data;
2475 return TETHERING_ERROR_NONE;
2480 * @brief Unregisters the callback function called when tethering is disabled.
2482 * @privlevel platform
2483 * @privilege http://tizen.org/privilege/tethering.admin
2484 * @param[in] tethering The handle of tethering
2485 * @param[in] type The type of tethering
2486 * @retval #TETHERING_ERROR_NONE Successful
2487 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2488 * @see tethering_set_enabled_cb()
2490 API int tethering_unset_enabled_cb(tethering_h tethering, tethering_type_e type)
2492 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2493 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2494 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2495 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2497 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2498 "parameter(tethering) is NULL\n");
2500 __tethering_h *th = (__tethering_h *)tethering;
2501 tethering_type_e ti;
2503 if (type != TETHERING_TYPE_ALL) {
2504 th->enabled_cb[type] = NULL;
2505 th->enabled_user_data[type] = NULL;
2507 return TETHERING_ERROR_NONE;
2510 /* TETHERING_TYPE_ALL */
2511 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2512 th->enabled_cb[ti] = NULL;
2513 th->enabled_user_data[ti] = NULL;
2516 return TETHERING_ERROR_NONE;
2521 * @brief Registers the callback function called when tethering is disabled.
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 * @param[in] callback The callback function to invoke
2528 * @param[in] user_data The user data to be passed to the callback function
2529 * @retval #TETHERING_ERROR_NONE Successful
2530 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2531 * @see tethering_unset_disabled_cb()
2533 API int tethering_set_disabled_cb(tethering_h tethering, tethering_type_e type, tethering_disabled_cb callback, void *user_data)
2535 INFO("+ type: %d\n", type);
2536 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2537 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2538 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2539 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2541 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2542 "parameter(tethering) is NULL\n");
2543 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2544 "parameter(callback) is NULL\n");
2546 __tethering_h *th = (__tethering_h *)tethering;
2547 tethering_type_e ti;
2549 if (type != TETHERING_TYPE_ALL) {
2550 th->disabled_cb[type] = callback;
2551 th->disabled_user_data[type] = user_data;
2553 return TETHERING_ERROR_NONE;
2556 /* TETHERING_TYPE_ALL */
2557 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2558 th->disabled_cb[ti] = callback;
2559 th->disabled_user_data[ti] = user_data;
2562 return TETHERING_ERROR_NONE;
2567 * @brief Unregisters the callback function called when tethering is disabled.
2569 * @privlevel platform
2570 * @privilege http://tizen.org/privilege/tethering.admin
2571 * @param[in] tethering The handle of tethering
2572 * @param[in] type The type of tethering
2573 * @retval #TETHERING_ERROR_NONE Successful
2574 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2575 * @see tethering_set_disabled_cb()
2577 API int tethering_unset_disabled_cb(tethering_h tethering, tethering_type_e type)
2579 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2580 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2581 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2582 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2584 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2585 "parameter(tethering) is NULL\n");
2587 __tethering_h *th = (__tethering_h *)tethering;
2588 tethering_type_e ti;
2590 if (type != TETHERING_TYPE_ALL) {
2591 th->disabled_cb[type] = NULL;
2592 th->disabled_user_data[type] = NULL;
2594 return TETHERING_ERROR_NONE;
2597 /* TETHERING_TYPE_ALL */
2598 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2599 th->disabled_cb[ti] = NULL;
2600 th->disabled_user_data[ti] = NULL;
2603 return TETHERING_ERROR_NONE;
2608 * @brief Registers the callback function called when the state of connection is changed.
2610 * @privlevel platform
2611 * @privilege http://tizen.org/privilege/tethering.admin
2612 * @param[in] tethering The handle of tethering
2613 * @param[in] type The type of tethering
2614 * @param[in] callback The callback function to invoke
2615 * @param[in] user_data The user data to be passed to the callback function
2616 * @retval #TETHERING_ERROR_NONE Successful
2617 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2618 * @see tethering_unset_connection_state_changed_cb_cb()
2620 API int tethering_set_connection_state_changed_cb(tethering_h tethering, tethering_type_e type, tethering_connection_state_changed_cb callback, void *user_data)
2622 INFO("+ type: %d\n", type);
2623 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2624 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2625 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2626 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2628 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2629 "parameter(tethering) is NULL\n");
2630 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2631 "parameter(callback) is NULL\n");
2633 __tethering_h *th = (__tethering_h *)tethering;
2634 tethering_type_e ti;
2636 if (type != TETHERING_TYPE_ALL) {
2637 th->changed_cb[type] = callback;
2638 th->changed_user_data[type] = user_data;
2640 return TETHERING_ERROR_NONE;
2643 /* TETHERING_TYPE_ALL */
2644 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2645 th->changed_cb[ti] = callback;
2646 th->changed_user_data[ti] = user_data;
2649 return TETHERING_ERROR_NONE;
2654 * @brief Unregisters the callback function called when the state of connection is changed.
2656 * @privlevel platform
2657 * @privilege http://tizen.org/privilege/tethering.admin
2658 * @param[in] tethering The handle of tethering
2659 * @param[in] type The type of tethering
2660 * @retval #TETHERING_ERROR_NONE Successful
2661 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2662 * @see tethering_set_connection_state_changed_cb()
2664 API int tethering_unset_connection_state_changed_cb(tethering_h tethering, tethering_type_e type)
2666 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2667 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2668 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2669 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2671 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2672 "parameter(tethering) is NULL\n");
2674 __tethering_h *th = (__tethering_h *)tethering;
2675 tethering_type_e ti;
2677 if (type != TETHERING_TYPE_ALL) {
2678 th->changed_cb[type] = NULL;
2679 th->changed_user_data[type] = NULL;
2681 return TETHERING_ERROR_NONE;
2684 /* TETHERING_TYPE_ALL */
2685 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2686 th->changed_cb[ti] = NULL;
2687 th->changed_user_data[ti] = NULL;
2690 return TETHERING_ERROR_NONE;
2695 * @brief Registers the callback function called when the security type of Wi-Fi tethering is changed.
2697 * @privlevel platform
2698 * @privilege http://tizen.org/privilege/tethering.admin
2699 * @param[in] tethering The handle of tethering
2700 * @param[in] callback The callback function to invoke
2701 * @param[in] user_data The user data to be passed to the callback function
2702 * @retval #TETHERING_ERROR_NONE Successful
2703 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2704 * @see tethering_wifi_unset_security_type_changed_cb()
2706 API int tethering_wifi_set_security_type_changed_cb(tethering_h tethering, tethering_wifi_security_type_changed_cb callback, void *user_data)
2708 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2709 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2711 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2712 "parameter(tethering) is NULL\n");
2713 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2714 "parameter(callback) is NULL\n");
2716 __tethering_h *th = (__tethering_h *)tethering;
2718 th->security_type_changed_cb = callback;
2719 th->security_type_user_data = user_data;
2721 return TETHERING_ERROR_NONE;
2727 * @brief Unregisters the callback function called when the security type of Wi-Fi tethering is changed.
2729 * @privlevel platform
2730 * @privilege http://tizen.org/privilege/tethering.admin
2731 * @param[in] tethering The handle of tethering
2732 * @param[in] type The type of tethering
2733 * @retval #TETHERING_ERROR_NONE Successful
2734 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2735 * @see tethering_wifi_set_security_type_changed_cb()
2737 API int tethering_wifi_unset_security_type_changed_cb(tethering_h tethering)
2739 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2740 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2742 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2743 "parameter(tethering) is NULL\n");
2745 __tethering_h *th = (__tethering_h *)tethering;
2747 th->security_type_changed_cb = NULL;
2748 th->security_type_user_data = NULL;
2750 return TETHERING_ERROR_NONE;
2755 * @brief Registers the callback function called when the visibility of SSID is changed.
2757 * @privlevel platform
2758 * @privilege http://tizen.org/privilege/tethering.admin
2759 * @param[in] tethering The handle of tethering
2760 * @param[in] callback The callback function to invoke
2761 * @param[in] user_data The user data to be passed to the callback function
2762 * @retval #TETHERING_ERROR_NONE Successful
2763 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2764 * @see tethering_wifi_unset_ssid_visibility_changed_cb_cb()
2766 API int tethering_wifi_set_ssid_visibility_changed_cb(tethering_h tethering, tethering_wifi_ssid_visibility_changed_cb callback, void *user_data)
2768 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2769 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2771 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2772 "parameter(tethering) is NULL\n");
2773 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2774 "parameter(callback) is NULL\n");
2776 __tethering_h *th = (__tethering_h *)tethering;
2778 th->ssid_visibility_changed_cb = callback;
2779 th->ssid_visibility_user_data = user_data;
2781 return TETHERING_ERROR_NONE;
2786 * @brief Unregisters the callback function called when the visibility of SSID is changed.
2788 * @privlevel platform
2789 * @privilege http://tizen.org/privilege/tethering.admin
2790 * @param[in] tethering The handle of tethering
2791 * @retval #TETHERING_ERROR_NONE Successful
2792 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2793 * @see tethering_wifi_set_ssid_visibility_changed_cb()
2795 API int tethering_wifi_unset_ssid_visibility_changed_cb(tethering_h tethering)
2797 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2798 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2800 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2801 "parameter(tethering) is NULL\n");
2803 __tethering_h *th = (__tethering_h *)tethering;
2805 th->ssid_visibility_changed_cb = NULL;
2806 th->ssid_visibility_user_data = NULL;
2808 return TETHERING_ERROR_NONE;
2813 * @brief Registers the callback function called when the passphrase of Wi-Fi tethering is changed.
2815 * @privlevel platform
2816 * @privilege http://tizen.org/privilege/tethering.admin
2817 * @param[in] tethering The handle of tethering
2818 * @param[in] callback The callback function to invoke
2819 * @param[in] user_data The user data to be passed to the callback function
2820 * @retval #TETHERING_ERROR_NONE Successful
2821 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2822 * @see tethering_wifi_unset_passphrase_changed_cb()
2824 API int tethering_wifi_set_passphrase_changed_cb(tethering_h tethering, tethering_wifi_passphrase_changed_cb callback, void *user_data)
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(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2832 "parameter(callback) is NULL\n");
2834 __tethering_h *th = (__tethering_h *)tethering;
2836 th->passphrase_changed_cb = callback;
2837 th->passphrase_user_data = user_data;
2839 return TETHERING_ERROR_NONE;
2844 * @brief Unregisters the callback function called when the passphrase of Wi-Fi tethering is changed.
2846 * @privlevel platform
2847 * @privilege http://tizen.org/privilege/tethering.admin
2848 * @param[in] tethering The handle of tethering
2849 * @retval #TETHERING_ERROR_NONE Successful
2850 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2851 * @see tethering_wifi_set_passphrase_changed_cb()
2853 API int tethering_wifi_unset_passphrase_changed_cb(tethering_h tethering)
2855 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2856 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2858 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2859 "parameter(tethering) is NULL\n");
2861 __tethering_h *th = (__tethering_h *)tethering;
2863 th->passphrase_changed_cb = NULL;
2864 th->passphrase_user_data = NULL;
2866 return TETHERING_ERROR_NONE;
2871 * @brief Sets the security type of Wi-Fi tethering.
2873 * @privlevel platform
2874 * @privilege http://tizen.org/privilege/tethering.admin
2875 * @remarks This change is applied next time Wi-Fi tethering is enabled
2876 * @param[in] tethering The handle of tethering
2877 * @param[in] type The security type
2878 * @return 0 on success, otherwise negative error value.
2879 * @retval #TETHERING_ERROR_NONE Successful
2880 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2881 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2882 * @see tethering_wifi_get_security_type()
2884 API int tethering_wifi_set_security_type(tethering_h tethering, tethering_wifi_security_type_e type)
2886 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2887 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2889 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2890 "parameter(tethering) is NULL\n");
2892 __tethering_h *th = (__tethering_h *)tethering;
2893 tethering_error_e ret = TETHERING_ERROR_NONE;
2894 char *sec_str = NULL;
2896 ret = __set_security_type(type);
2897 if (ret == TETHERING_ERROR_NONE) {
2900 case TETHERING_WIFI_SECURITY_TYPE_NONE:
2901 sec_str = TETHERING_WIFI_SECURITY_TYPE_OPEN_STR;
2903 case TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK:
2904 sec_str = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR;
2906 case TETHERING_WIFI_SECURITY_TYPE_WPS:
2907 sec_str = TETHERING_WIFI_SECURITY_TYPE_WPS_STR;
2911 __send_dbus_signal(th->client_bus,
2912 SIGNAL_NAME_SECURITY_TYPE_CHANGED, sec_str);
2919 * @brief Gets the security type of Wi-Fi tethering.
2921 * @privlevel platform
2922 * @privilege http://tizen.org/privilege/tethering.admin
2923 * @param[in] tethering The handle of tethering
2924 * @param[out] type The security type
2925 * @return 0 on success, otherwise negative error value.
2926 * @retval #TETHERING_ERROR_NONE Successful
2927 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2928 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2929 * @see tethering_wifi_set_security_type()
2931 API int tethering_wifi_get_security_type(tethering_h tethering, tethering_wifi_security_type_e *type)
2933 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2934 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2936 _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2937 "parameter(type) is NULL\n");
2939 return __get_security_type(type);
2944 * @brief Sets the SSID (service set identifier).
2946 * @privlevel platform
2947 * @privilege http://tizen.org/privilege/tethering.admin
2948 * @details If SSID is not set, Device name is used as SSID
2949 * @remarks This change is applied next time Wi-Fi tethering is enabled with same @a tethering handle
2950 * @param[in] tethering The handle of tethering
2951 * @param[out] ssid The SSID
2952 * @return 0 on success, otherwise negative error value.
2953 * @retval #TETHERING_ERROR_NONE Successful
2954 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2955 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2957 API int tethering_wifi_set_ssid(tethering_h tethering, const char *ssid)
2959 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2960 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2962 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2963 "parameter(tethering) is NULL\n");
2964 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2965 "parameter(ssid) is NULL\n");
2967 __tethering_h *th = (__tethering_h *)tethering;
2968 char *p_ssid = NULL;
2971 ssid_len = strlen(ssid);
2972 if (ssid_len > TETHERING_WIFI_SSID_MAX_LEN) {
2973 ERR("parameter(ssid) is too long");
2974 return TETHERING_ERROR_INVALID_PARAMETER;
2977 p_ssid = strdup(ssid);
2978 _retvm_if(p_ssid == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2979 "strdup is failed\n");
2985 return TETHERING_ERROR_NONE;
2990 * @brief Gets the SSID (service set identifier).
2992 * @privlevel platform
2993 * @privilege http://tizen.org/privilege/tethering.admin
2994 * @remarks @a ssid must be released with free() by you.
2995 * @param[in] tethering The handle of tethering
2996 * @param[out] ssid The SSID
2997 * @return 0 on success, otherwise negative error value.
2998 * @retval #TETHERING_ERROR_NONE Successful
2999 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3000 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
3001 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3003 API int tethering_wifi_get_ssid(tethering_h tethering, char **ssid)
3005 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3006 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3008 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3009 "parameter(tethering) is NULL\n");
3010 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3011 "parameter(ssid) is NULL\n");
3014 __tethering_h *th = (__tethering_h *)tethering;
3015 char val[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
3017 if (!tethering_is_enabled(NULL, TETHERING_TYPE_WIFI)) {
3018 if (th->ssid != NULL) {
3019 DBG("Private SSID is set\n");
3020 *ssid = strdup(th->ssid);
3022 if (__get_ssid_from_vconf(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
3023 val, sizeof(val)) == false) {
3024 return TETHERING_ERROR_OPERATION_FAILED;
3026 *ssid = strdup(val);
3029 if (__get_ssid_from_vconf(VCONFKEY_MOBILE_HOTSPOT_SSID,
3030 val, sizeof(val)) == false) {
3031 return TETHERING_ERROR_OPERATION_FAILED;
3033 *ssid = strdup(val);
3036 if (*ssid == NULL) {
3037 ERR("strdup is failed\n"); //LCOV_EXCL_LINE
3038 return TETHERING_ERROR_OUT_OF_MEMORY;
3041 return TETHERING_ERROR_NONE;
3046 * @brief Sets the visibility of SSID(service set identifier).
3048 * @privlevel platform
3049 * @privilege http://tizen.org/privilege/tethering.admin
3050 * @details If you set the visibility invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
3051 * @remarks This change is applied next time Wi-Fi tethering is enabled
3052 * @param[in] tethering The handle of tethering
3053 * @param[in] visible The visibility of SSID: (@c true = visible, @c false = invisible)
3054 * @return 0 on success, otherwise negative error value.
3055 * @retval #TETHERING_ERROR_NONE Successful
3056 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3057 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3058 * @see tethering_wifi_get_ssid_visibility()
3060 API int tethering_wifi_set_ssid_visibility(tethering_h tethering, bool visible)
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");
3068 __tethering_h *th = (__tethering_h *)tethering;
3069 tethering_error_e ret = TETHERING_ERROR_NONE;
3071 ret = __set_visible(visible);
3072 if (ret == TETHERING_ERROR_NONE) {
3073 __send_dbus_signal(th->client_bus,
3074 SIGNAL_NAME_SSID_VISIBILITY_CHANGED,
3075 visible ? SIGNAL_MSG_SSID_VISIBLE :
3076 SIGNAL_MSG_SSID_HIDE);
3083 * @brief Gets the visibility of SSID(service set identifier).
3085 * @privlevel platform
3086 * @privilege http://tizen.org/privilege/tethering.admin
3087 * @details If the visibility is set invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
3088 * @param[in] tethering The handle of tethering
3089 * @param[out] visible The visibility of SSID: (@c true = visible, @c false = invisible)
3090 * @return 0 on success, otherwise negative error value.
3091 * @retval #TETHERING_ERROR_NONE Successful
3092 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3093 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3094 * @see tethering_wifi_set_ssid_visibility()
3096 API int tethering_wifi_get_ssid_visibility(tethering_h tethering, bool *visible)
3098 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3099 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3101 _retvm_if(visible == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3102 "parameter(visible) is NULL\n");
3104 return __get_visible(visible);
3109 * @brief Sets the passphrase.
3111 * @privlevel platform
3112 * @privilege http://tizen.org/privilege/tethering.admin
3113 * @remarks This change is applied next time Wi-Fi tethering is enabled
3114 * @param[in] tethering The handle of tethering
3115 * @param[in] passphrase The passphrase
3116 * @return 0 on success, otherwise negative error value.
3117 * @retval #TETHERING_ERROR_NONE Successful
3118 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3119 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3120 * @see tethering_wifi_get_passphrase()
3122 API int tethering_wifi_set_passphrase(tethering_h tethering, const char *passphrase)
3124 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3125 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3127 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3128 "parameter(tethering) is NULL\n");
3129 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3130 "parameter(passphrase) is NULL\n");
3132 __tethering_h *th = (__tethering_h *)tethering;
3133 GDBusProxy *proxy = th->client_bus_proxy;
3134 GVariant *parameters;
3135 GError *error = NULL;
3136 int passphrase_len = 0;
3140 passphrase_len = strlen(passphrase);
3141 if (passphrase_len < TETHERING_WIFI_KEY_MIN_LEN ||
3142 passphrase_len > TETHERING_WIFI_KEY_MAX_LEN) {
3143 ERR("parameter(passphrase) is too short or long\n");
3144 return TETHERING_ERROR_INVALID_PARAMETER;
3147 parameters = g_dbus_proxy_call_sync(proxy, "set_wifi_tethering_passphrase",
3148 g_variant_new("(s)", passphrase), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3152 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3154 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3155 ret = TETHERING_ERROR_PERMISSION_DENIED;
3157 ret = TETHERING_ERROR_OPERATION_FAILED;
3159 g_error_free(error);
3164 g_variant_get(parameters, "(u)", &ret);
3165 g_variant_unref(parameters);
3167 if (ret == TETHERING_ERROR_NONE) {
3168 __send_dbus_signal(th->client_bus,
3169 SIGNAL_NAME_PASSPHRASE_CHANGED, NULL);
3178 * @brief Gets the passphrase.
3180 * @privlevel platform
3181 * @privilege http://tizen.org/privilege/tethering.admin
3182 * @remarks @a passphrase must be released with free() by you.
3183 * @param[in] tethering The handle of tethering
3184 * @param[out] passphrase The passphrase
3185 * @return 0 on success, otherwise negative error value.
3186 * @retval #TETHERING_ERROR_NONE Successful
3187 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3188 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
3189 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3190 * @see tethering_wifi_set_passphrase()
3192 API int tethering_wifi_get_passphrase(tethering_h tethering, char **passphrase)
3194 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3195 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3197 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3198 "parameter(tethering) is NULL\n");
3199 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3200 "parameter(passphrase) is NULL\n");
3202 __tethering_h *th = (__tethering_h *)tethering;
3203 GDBusProxy *proxy = th->client_bus_proxy;
3204 GVariant *parameters;
3205 GError *error = NULL;
3206 unsigned int len = 0;
3207 tethering_error_e ret = TETHERING_ERROR_NONE;
3209 parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_passphrase",
3210 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3214 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3216 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3217 ret = TETHERING_ERROR_PERMISSION_DENIED;
3219 ret = TETHERING_ERROR_OPERATION_FAILED;
3221 g_error_free(error);
3226 if (parameters != NULL) {
3227 g_variant_get(parameters, "(siu)", passphrase, &len, &ret);
3228 g_variant_unref(parameters);
3231 return TETHERING_ERROR_NONE;
3234 API int tethering_wifi_set_channel(tethering_h tethering, int channel)
3236 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3237 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3239 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3240 "parameter(tethering) is NULL\n");
3242 __tethering_h *th = (__tethering_h *)tethering;
3243 th->channel = channel;
3245 return TETHERING_ERROR_NONE;
3248 API int tethering_wifi_get_channel(tethering_h tethering, int *channel)
3250 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3251 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3253 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3254 "parameter(tethering) is NULL\n");
3256 _retvm_if(channel == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3257 "parameter(channel) is NULL\n");
3259 __tethering_h *th = (__tethering_h *)tethering;
3260 *channel = th->channel;
3262 return TETHERING_ERROR_NONE;
3265 API int tethering_wifi_set_mode(tethering_h tethering, tethering_wifi_mode_type_e type)
3267 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3268 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3270 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3271 "parameter(tethering) is NULL\n");
3273 __tethering_h *th = (__tethering_h *)tethering;
3275 th->mode_type = type;
3277 return TETHERING_ERROR_NONE;
3280 API int tethering_wifi_get_mode(tethering_h tethering, tethering_wifi_mode_type_e *type)
3282 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3283 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3285 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3286 "parameter(tethering) is NULL\n");
3287 _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3288 "parameter(type) is NULL\n");
3290 __tethering_h *th = (__tethering_h *)tethering;
3291 *type = th->mode_type;
3293 return TETHERING_ERROR_NONE;
3299 * @brief Reload the settings (SSID / Passphrase / Security type / SSID visibility).
3301 * @privlevel platform
3302 * @privilege http://tizen.org/privilege/tethering.admin
3303 * @remarks Connected devices via Wi-Fi tethering or MobileAP will be disconnected when the settings are reloaded
3304 * @param[in] tethering The handle of tethering
3305 * @param[in] callback The callback function to invoke
3306 * @param[in] user_data The user data to be passed to the callback function
3307 * @return 0 on success, otherwise negative error value.
3308 * @retval #TETHERING_ERROR_NONE Successful
3309 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3310 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3312 API int tethering_wifi_reload_settings(tethering_h tethering, tethering_wifi_settings_reloaded_cb callback, void *user_data)
3315 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3316 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3318 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3319 "parameter(tethering) is NULL\n");
3320 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3321 "parameter(callback) is NULL\n");
3323 __tethering_h *th = (__tethering_h *)tethering;
3324 _softap_settings_t set = {"", "", "", 0, false};
3325 GDBusProxy *proxy = th->client_bus_proxy;
3330 if (th->settings_reloaded_cb) {
3331 ERR("Operation in progress\n"); //LCOV_EXCL_LINE
3332 return TETHERING_ERROR_OPERATION_FAILED;
3335 ret = __prepare_wifi_settings(tethering, &set);
3336 if (ret != TETHERING_ERROR_NONE) {
3337 ERR("softap settings initialization failed\n"); //LCOV_EXCL_LINE
3338 return TETHERING_ERROR_OPERATION_FAILED;
3341 th->settings_reloaded_cb = callback;
3342 th->settings_reloaded_user_data = user_data;
3344 g_dbus_proxy_call(proxy, "reload_wifi_settings",
3345 g_variant_new("(sssiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type),
3346 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
3347 (GAsyncReadyCallback) __settings_reloaded_cb, (gpointer)tethering);
3349 return TETHERING_ERROR_NONE;
3352 API int tethering_wifi_set_mac_filter(tethering_h tethering, bool mac_filter)
3354 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3355 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3357 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3358 "parameter(tethering) is NULL\n");
3360 __tethering_h *th = (__tethering_h *)tethering;
3361 th->mac_filter = mac_filter;
3363 return TETHERING_ERROR_NONE;
3366 API int tethering_wifi_get_mac_filter(tethering_h tethering, bool *mac_filter)
3368 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3369 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3371 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3372 "parameter(mac_filter) is NULL\n");
3373 _retvm_if(mac_filter == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3374 "parameter(mac_filter) is NULL\n");
3376 __tethering_h *th = (__tethering_h *)tethering;
3377 *mac_filter = th->mac_filter;
3379 return TETHERING_ERROR_NONE;
3382 static int __add_mac_to_file(const char *filepath, const char *mac)
3385 char line[MAX_BUF_SIZE] = "\0";
3386 bool mac_exist = false;
3389 p_mac = strdup(mac);
3390 if (p_mac == NULL) {
3391 ERR("strdup failed\n"); //LCOV_EXCL_LINE
3392 return TETHERING_ERROR_OUT_OF_MEMORY;
3395 fp = fopen(filepath, "a+");
3397 ERR("fopen is failed\n"); //LCOV_EXCL_LINE
3398 return TETHERING_ERROR_OPERATION_FAILED;
3401 while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
3402 if (strncmp(mac, line, 17) == 0) {
3403 DBG("MAC %s already exist in the list\n", mac); //LCOV_EXCL_LINE
3410 fprintf(fp, "%s\n", mac);
3412 if ((strcmp(filepath, ALLOWED_LIST) == 0))
3413 allowed_list = g_slist_append(allowed_list, p_mac);
3414 else if ((strcmp(filepath, BLOCKED_LIST) == 0))
3415 blocked_list = g_slist_append(blocked_list, p_mac);
3420 return TETHERING_ERROR_NONE;
3423 static int __remove_mac_from_file(const char *filepath, const char *mac)
3427 char line[MAX_BUF_SIZE] = "\0";
3429 fp = fopen(filepath, "r");
3431 ERR("fopen is failed\n");
3432 return TETHERING_ERROR_OPERATION_FAILED;
3435 fp1 = fopen(TEMP_LIST, "w+");
3438 ERR("fopen is failed\n");
3439 return TETHERING_ERROR_OPERATION_FAILED;
3442 while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
3443 if (strncmp(mac, line, 17) == 0) {
3444 DBG("MAC %s found in the list\n", mac);
3446 if ((strcmp(filepath, ALLOWED_LIST) == 0)) {
3447 GSList *list = NULL;
3448 for (list = allowed_list; list != NULL; list = list->next) {
3449 char *p_mac = (char *)list->data;
3450 if (strncmp(mac, p_mac, strlen(mac)) == 0)
3451 allowed_list = g_slist_remove(allowed_list, p_mac);
3453 } else if ((strcmp(filepath, BLOCKED_LIST) == 0)) {
3454 GSList *list = NULL;
3455 for (list = blocked_list; list != NULL; list = list->next) {
3456 char *p_mac = (char *)list->data;
3457 if (strncmp(mac, p_mac, strlen(mac)) == 0)
3458 blocked_list = g_slist_remove(blocked_list, p_mac);
3462 fprintf(fp1, "%s", line);
3469 if ((strcmp(filepath, ALLOWED_LIST) == 0)) {
3470 if (rename(TEMP_LIST, ALLOWED_LIST) != 0) {
3471 ERR("rename is failed (%s -> %s)", TEMP_LIST, ALLOWED_LIST);
3472 return TETHERING_ERROR_OPERATION_FAILED;
3474 } else if ((strcmp(filepath, BLOCKED_LIST) == 0)) {
3475 if (rename(TEMP_LIST, BLOCKED_LIST) != 0) {
3476 ERR("rename is failed (%s -> %s)", TEMP_LIST, BLOCKED_LIST);
3477 return TETHERING_ERROR_OPERATION_FAILED;
3481 return TETHERING_ERROR_NONE;
3484 API int tethering_wifi_add_allowed_mac_list(tethering_h tethering, const char *mac)
3486 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3487 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3489 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3490 "parameter(tethering) is NULL\n");
3491 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3492 "parameter(mac) is NULL\n");
3494 return __add_mac_to_file(ALLOWED_LIST, mac);
3497 API int tethering_wifi_remove_allowed_mac_list(tethering_h tethering, const char *mac)
3499 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3500 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3502 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3503 "parameter(tethering) is NULL\n");
3504 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3505 "parameter(mac) is NULL\n");
3507 return __remove_mac_from_file(ALLOWED_LIST, mac);
3510 API int tethering_wifi_get_allowed_mac_list(tethering_h tethering, void **allowed_mac_list)
3512 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3513 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3515 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3516 "parameter(tethering) is NULL\n");
3517 _retvm_if(allowed_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3518 "parameter(allowed_mac_list) is NULL\n");
3520 *allowed_mac_list = g_slist_copy(allowed_list);
3521 return TETHERING_ERROR_NONE;
3524 API int tethering_wifi_add_blocked_mac_list(tethering_h tethering, const char *mac)
3526 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3527 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3529 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3530 "parameter(tethering) is NULL\n");
3531 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3532 "parameter(mac) is NULL\n");
3534 return __add_mac_to_file(BLOCKED_LIST, mac);
3537 API int tethering_wifi_remove_blocked_mac_list(tethering_h tethering, const char *mac)
3539 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3540 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3542 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3543 "parameter(tethering) is NULL\n");
3544 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3545 "parameter(mac) is NULL\n");
3547 return __remove_mac_from_file(BLOCKED_LIST, mac);
3550 API int tethering_wifi_get_blocked_mac_list(tethering_h tethering, void **blocked_mac_list)
3552 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3553 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3555 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3556 "parameter(tethering) is NULL\n");
3557 _retvm_if(blocked_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3558 "parameter(blocked_mac_list) is NULL\n");
3560 *blocked_mac_list = g_slist_copy(blocked_list);
3561 return TETHERING_ERROR_NONE;
3564 API int tethering_wifi_enable_dhcp(tethering_h tethering, bool enable)
3566 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3567 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3569 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3570 "parameter(tethering) is NULL\n");
3572 GVariant *parameters;
3573 GError *error = NULL;
3576 __tethering_h *th = (__tethering_h *)tethering;
3578 GDBusProxy *proxy = th->client_bus_proxy;
3580 parameters = g_dbus_proxy_call_sync(proxy, "enable_dhcp",
3581 g_variant_new("(b)", enable),
3582 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3586 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3587 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3588 result = TETHERING_ERROR_PERMISSION_DENIED;
3590 result = TETHERING_ERROR_OPERATION_FAILED;
3592 g_error_free(error);
3593 th->dhcp_enabled = false;
3599 g_variant_get(parameters, "(u)", &result);
3600 g_variant_unref(parameters);
3603 th->dhcp_enabled = true;
3605 th->dhcp_enabled = false;
3607 return TETHERING_ERROR_NONE;
3610 API int tethering_wifi_set_dhcp_range(tethering_h tethering, char *rangestart, char *rangestop)
3612 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3613 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3615 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3616 "parameter(tethering) is NULL\n");
3617 _retvm_if(rangestart == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3618 "parameter(rangestart) is NULL\n");
3619 _retvm_if(rangestop == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3620 "parameter(rangestop) is NULL\n");
3622 GVariant *parameters;
3623 GError *error = NULL;
3626 __tethering_h *th = (__tethering_h *)tethering;
3628 GDBusProxy *proxy = th->client_bus_proxy;
3630 parameters = g_dbus_proxy_call_sync(proxy, "dhcp_range",
3631 g_variant_new("(ss)", rangestart, rangestop),
3632 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3635 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3637 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3638 result = TETHERING_ERROR_PERMISSION_DENIED;
3640 result = TETHERING_ERROR_OPERATION_FAILED;
3642 g_error_free(error);
3643 th->dhcp_enabled = false;
3649 g_variant_get(parameters, "(u)", &result);
3650 g_variant_unref(parameters);
3652 th->dhcp_enabled = true;
3654 return TETHERING_ERROR_NONE;
3657 API int tethering_wifi_is_dhcp_enabled(tethering_h tethering, bool *dhcp_enabled)
3659 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3660 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3662 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3663 "parameter(tethering) is NULL\n");
3664 _retvm_if(dhcp_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3665 "parameter(dhcp_enabled) is NULL\n");
3667 __tethering_h *th = (__tethering_h *)tethering;
3668 *dhcp_enabled = th->dhcp_enabled;
3670 return TETHERING_ERROR_NONE;
3673 API int tethering_wifi_set_txpower(tethering_h tethering, unsigned int txpower)
3675 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3676 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3678 GError *error = NULL;
3680 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3681 "parameter(tethering) is NULL\n");
3682 _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false,
3683 TETHERING_ERROR_NOT_ENABLED,
3684 "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
3685 __tethering_h *th = (__tethering_h *)tethering;
3687 g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_set_txpower",
3688 g_variant_new("(u)", txpower),
3689 G_DBUS_CALL_FLAGS_NONE,
3690 -1, th->cancellable, &error);
3693 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
3694 g_clear_error(&error);
3695 return TETHERING_ERROR_OPERATION_FAILED;
3698 return TETHERING_ERROR_NONE;
3701 API int tethering_wifi_get_txpower(tethering_h tethering, unsigned int *txpower)
3703 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3704 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3706 GError *error = NULL;
3707 GVariant *result = NULL;
3709 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3710 "parameter(tethering) is NULL\n");
3711 _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false,
3712 TETHERING_ERROR_NOT_ENABLED,
3713 "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
3715 __tethering_h *th = (__tethering_h *)tethering;
3717 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_get_txpower",
3719 G_DBUS_CALL_FLAGS_NONE,
3720 -1, th->cancellable, &error);
3722 if (result != NULL) {
3723 g_variant_get(result, "(u)", txpower);
3724 g_variant_unref(result);
3728 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
3729 g_clear_error(&error);
3730 return TETHERING_ERROR_OPERATION_FAILED;
3733 g_clear_error(&error);
3734 return TETHERING_ERROR_NONE;
3737 API int tethering_wifi_set_mtu(tethering_h tethering, unsigned int mtu)
3739 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3740 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3742 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3743 "parameter(tethering) is NULL\n");
3745 GVariant *parameters;
3746 GError *error = NULL;
3749 __tethering_h *th = (__tethering_h *)tethering;
3751 GDBusProxy *proxy = th->client_bus_proxy;
3753 parameters = g_dbus_proxy_call_sync(proxy, "set_mtu",
3754 g_variant_new("(u)", mtu),
3755 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3758 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3760 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3761 result = TETHERING_ERROR_PERMISSION_DENIED;
3763 result = TETHERING_ERROR_OPERATION_FAILED;
3765 g_error_free(error);
3770 g_variant_get(parameters, "(u)", &result);
3772 g_variant_unref(parameters);
3774 return TETHERING_ERROR_NONE;
3777 API int tethering_wifi_change_mac(tethering_h tethering, char *mac)
3779 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3780 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3782 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3783 "parameter(tethering) is NULL\n");
3784 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3785 "parameter(mac) is NULL\n");
3787 GVariant *parameters;
3788 GError *error = NULL;
3791 __tethering_h *th = (__tethering_h *)tethering;
3793 GDBusProxy *proxy = th->client_bus_proxy;
3795 parameters = g_dbus_proxy_call_sync(proxy, "change_mac",
3796 g_variant_new("(s)", mac),
3797 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3800 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3802 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3803 result = TETHERING_ERROR_PERMISSION_DENIED;
3805 result = TETHERING_ERROR_OPERATION_FAILED;
3807 g_error_free(error);
3812 g_variant_get(parameters, "(u)", &result);
3813 g_variant_unref(parameters);
3815 if (result == MOBILE_AP_ERROR_NOT_PERMITTED)
3816 return TETHERING_ERROR_NOT_SUPPORT_API;
3818 return TETHERING_ERROR_NONE;
3821 API int tethering_wifi_set_max_connected_device(tethering_h tethering, int max_device)
3823 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3824 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3826 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3827 "parameter(tethering) is NULL\n");
3829 __tethering_h *th = (__tethering_h *)tethering;
3831 th->wifi_max_connected = max_device;
3833 return TETHERING_ERROR_NONE;
3836 API int tethering_wifi_get_max_connected_device(tethering_h tethering, int *max_device)
3838 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3839 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3841 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3842 "parameter(tethering) is NULL\n");
3843 _retvm_if(max_device == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3844 "parameter(max_device) is NULL\n");
3846 __tethering_h *th = (__tethering_h *)tethering;
3848 *max_device = th->wifi_max_connected;
3849 return TETHERING_ERROR_NONE;
3852 API int tethering_wifi_enable_port_forwarding(tethering_h tethering, bool enable)
3854 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3855 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3857 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3858 "parameter(tethering) is NULL\n");
3860 GVariant *parameters;
3861 GError *error = NULL;
3864 __tethering_h *th = (__tethering_h *)tethering;
3866 GDBusProxy *proxy = th->client_bus_proxy;
3868 parameters = g_dbus_proxy_call_sync(proxy, "enable_port_forwarding",
3869 g_variant_new("(b)", enable),
3870 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3873 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3875 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3876 result = TETHERING_ERROR_PERMISSION_DENIED;
3878 result = TETHERING_ERROR_OPERATION_FAILED;
3880 g_error_free(error);
3885 g_variant_get(parameters, "(u)", &result);
3886 g_variant_unref(parameters);
3888 th->port_forwarding = true;
3890 return TETHERING_ERROR_NONE;
3893 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)
3895 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3896 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3898 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3899 "parameter(tethering) is NULL\n");
3900 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3901 "parameter(protocol) is NULL\n");
3903 GVariant *parameters;
3904 GError *error = NULL;
3906 char cmd[MAX_BUF_SIZE] = { 0, };
3909 __tethering_h *th = (__tethering_h *)tethering;
3911 GDBusProxy *proxy = th->client_bus_proxy;
3913 parameters = g_dbus_proxy_call_sync(proxy, "add_port_forwarding_rule",
3914 g_variant_new("(sssisi)", ifname, protocol, org_ip, org_port, final_ip, final_port),
3915 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3918 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3920 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3921 result = TETHERING_ERROR_PERMISSION_DENIED;
3923 result = TETHERING_ERROR_OPERATION_FAILED;
3925 g_error_free(error);
3930 g_variant_get(parameters, "(u)", &result);
3931 g_variant_unref(parameters);
3933 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);
3937 ERR("strdup failed\n"); //LCOV_EXCL_LINE
3938 return TETHERING_ERROR_OUT_OF_MEMORY;
3941 port_forwarding = g_slist_append(port_forwarding, list);
3943 return TETHERING_ERROR_NONE;
3946 API int tethering_wifi_reset_port_forwarding_rule(tethering_h tethering)
3948 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3949 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3951 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3952 "parameter(tethering) is NULL\n");
3954 GVariant *parameters;
3955 GError *error = NULL;
3958 __tethering_h *th = (__tethering_h *)tethering;
3960 GDBusProxy *proxy = th->client_bus_proxy;
3962 parameters = g_dbus_proxy_call_sync(proxy, "reset_port_forwarding_rule",
3963 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3966 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3968 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3969 result = TETHERING_ERROR_PERMISSION_DENIED;
3971 result = TETHERING_ERROR_OPERATION_FAILED;
3973 g_error_free(error);
3978 g_variant_get(parameters, "(u)", &result);
3980 g_variant_unref(parameters);
3982 return TETHERING_ERROR_NONE;
3985 API int tethering_wifi_is_port_forwarding_enabled(tethering_h tethering, bool* forwarding_enabled)
3987 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3988 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3990 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3991 "parameter(tethering) is NULL\n");
3992 _retvm_if(forwarding_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3993 "parameter(forwarding_enabled) is NULL\n");
3995 __tethering_h *th = (__tethering_h *)tethering;
3997 *forwarding_enabled = th->port_forwarding;
3999 return TETHERING_ERROR_NONE;
4002 API int tethering_wifi_get_port_forwarding_rule(tethering_h tethering, void **port_forwarding_list)
4004 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4005 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4007 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4008 "parameter(tethering) is NULL\n");
4009 _retvm_if(port_forwarding_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4010 "parameter(port_forwarding_list) is NULL\n");
4012 *port_forwarding_list = g_slist_copy(port_forwarding);
4013 return TETHERING_ERROR_NONE;
4016 API int tethering_wifi_enable_port_filtering(tethering_h tethering, bool enable)
4018 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4019 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4021 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4022 "parameter(tethering) is NULL\n");
4024 GVariant *parameters;
4025 GError *error = NULL;
4028 __tethering_h *th = (__tethering_h *)tethering;
4030 GDBusProxy *proxy = th->client_bus_proxy;
4032 parameters = g_dbus_proxy_call_sync(proxy, "enable_port_filtering",
4033 g_variant_new("(b)", enable),
4034 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4037 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4039 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4040 result = TETHERING_ERROR_PERMISSION_DENIED;
4042 result = TETHERING_ERROR_OPERATION_FAILED;
4044 g_error_free(error);
4049 g_variant_get(parameters, "(u)", &result);
4050 g_variant_unref(parameters);
4052 th->port_filtering = true;
4054 return TETHERING_ERROR_NONE;
4057 API int tethering_wifi_add_port_filtering_rule(tethering_h tethering, int port, char *protocol, bool allow)
4059 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4060 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4062 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4063 "parameter(tethering) is NULL\n");
4064 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4065 "parameter(protocol) is NULL\n");
4067 GVariant *parameters;
4068 GError *error = NULL;
4070 char cmd[MAX_BUF_SIZE] = { 0, };
4073 __tethering_h *th = (__tethering_h *)tethering;
4075 GDBusProxy *proxy = th->client_bus_proxy;
4077 parameters = g_dbus_proxy_call_sync(proxy, "add_port_filtering_rule",
4078 g_variant_new("(isb)", port, protocol, allow),
4079 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4082 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4084 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4085 result = TETHERING_ERROR_PERMISSION_DENIED;
4087 result = TETHERING_ERROR_OPERATION_FAILED;
4089 g_error_free(error);
4094 g_variant_get(parameters, "(u)", &result);
4095 g_variant_unref(parameters);
4098 snprintf(cmd, sizeof(cmd), "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_ACCEPT);
4100 snprintf(cmd, sizeof(cmd), "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_DROP);
4106 ERR("strdup failed\n"); //LCOV_EXCL_LINE
4107 return TETHERING_ERROR_OUT_OF_MEMORY;
4110 port_filtering = g_slist_append(port_filtering, list);
4112 return TETHERING_ERROR_NONE;
4115 API int tethering_wifi_add_custom_port_filtering_rule(tethering_h tethering, int port1, int port2, char *protocol, bool allow)
4117 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4118 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4120 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4121 "parameter(tethering) is NULL\n");
4122 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4123 "parameter(protocol) is NULL\n");
4125 GVariant *parameters;
4126 GError *error = NULL;
4128 char cmd[MAX_BUF_SIZE] = { 0, };
4131 __tethering_h *th = (__tethering_h *)tethering;
4133 GDBusProxy *proxy = th->client_bus_proxy;
4135 parameters = g_dbus_proxy_call_sync(proxy, "add_custom_port_filtering_rule",
4136 g_variant_new("(iisb)", port1, port2, protocol, allow),
4137 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4140 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4142 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4143 result = TETHERING_ERROR_PERMISSION_DENIED;
4145 result = TETHERING_ERROR_OPERATION_FAILED;
4147 g_error_free(error);
4152 g_variant_get(parameters, "(u)", &result);
4153 g_variant_unref(parameters);
4156 snprintf(cmd, sizeof(cmd), "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_ACCEPT);
4158 snprintf(cmd, sizeof(cmd), "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_DROP);
4164 ERR("strdup failed\n"); //LCOV_EXCL_LINE
4165 return TETHERING_ERROR_OUT_OF_MEMORY;
4168 custom_port_filtering = g_slist_append(custom_port_filtering, list);
4170 return TETHERING_ERROR_NONE;
4173 API int tethering_wifi_get_port_filtering_rule(tethering_h tethering, void **port_filtering_list)
4175 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4176 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4178 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4179 "parameter(tethering) is NULL\n");
4180 _retvm_if(port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4181 "parameter(port_filtering_list) is NULL\n");
4183 *port_filtering_list = g_slist_copy(port_filtering);
4184 return TETHERING_ERROR_NONE;
4187 API int tethering_wifi_get_custom_port_filtering_rule(tethering_h tethering, void **custom_port_filtering_list)
4189 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4190 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4192 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4193 "parameter(tethering) is NULL\n");
4194 _retvm_if(custom_port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4195 "parameter(custom_port_filtering_list) is NULL\n");
4197 *custom_port_filtering_list = g_slist_copy(custom_port_filtering);
4198 return TETHERING_ERROR_NONE;
4201 API int tethering_wifi_is_port_filtering_enabled(tethering_h tethering, bool* filtering_enabled)
4203 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4204 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4206 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4207 "parameter(tethering) is NULL\n");
4208 _retvm_if(filtering_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4209 "parameter(filtering_enabled) is NULL\n");
4211 __tethering_h *th = (__tethering_h *)tethering;
4213 *filtering_enabled = th->port_filtering;
4215 return TETHERING_ERROR_NONE;
4218 API int tethering_wifi_set_vpn_passthrough_rule(tethering_h tethering, tethering_vpn_passthrough_type_e type, bool enable)
4220 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4221 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4223 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4224 "parameter(tethering) is NULL\n");
4226 GVariant *parameters;
4227 GError *error = NULL;
4230 __tethering_h *th = (__tethering_h *)tethering;
4232 GDBusProxy *proxy = th->client_bus_proxy;
4234 parameters = g_dbus_proxy_call_sync(proxy, "set_vpn_passthrough_rule",
4235 g_variant_new("(ib)", type, enable),
4236 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4239 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4241 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4242 result = TETHERING_ERROR_PERMISSION_DENIED;
4244 result = TETHERING_ERROR_OPERATION_FAILED;
4246 g_error_free(error);
4251 g_variant_get(parameters, "(u)", &result);
4253 g_variant_unref(parameters);
4255 return TETHERING_ERROR_NONE;
4258 API int tethering_wifi_push_wps_button(tethering_h tethering)
4260 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4261 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4263 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4264 "parameter(tethering) is NULL");
4265 __tethering_h *th = (__tethering_h *)tethering;
4266 GDBusProxy *proxy = th->client_bus_proxy;
4267 GVariant *parameters = NULL;
4269 GError *error = NULL;
4271 parameters = g_dbus_proxy_call_sync(proxy, "push_wps_button",
4272 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4276 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4278 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4279 ret = TETHERING_ERROR_PERMISSION_DENIED;
4281 ret = TETHERING_ERROR_OPERATION_FAILED;
4283 g_error_free(error);
4288 if (parameters != NULL) {
4289 g_variant_get(parameters, "(u)", &ret);
4290 g_variant_unref(parameters);
4293 return TETHERING_ERROR_NONE;
4296 API int tethering_wifi_set_wps_pin(tethering_h tethering, const char *wps_pin)
4298 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4299 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4301 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4302 "parameter(tethering) is NULL");
4303 __tethering_h *th = (__tethering_h *)tethering;
4304 GDBusProxy *proxy = th->client_bus_proxy;
4305 GVariant *parameters = NULL;
4307 GError *error = NULL;
4309 parameters = g_dbus_proxy_call_sync(proxy, "set_wps_pin",
4310 g_variant_new("(s)", wps_pin), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4314 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4316 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4317 ret = TETHERING_ERROR_PERMISSION_DENIED;
4319 ret = TETHERING_ERROR_OPERATION_FAILED;
4321 g_error_free(error);
4326 if (parameters != NULL) {
4327 g_variant_get(parameters, "(u)", &ret);
4328 g_variant_unref(parameters);
4331 return TETHERING_ERROR_NONE;