2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
21 #include <sys/ioctl.h>
22 #include <sys/socket.h>
23 #include <netinet/in.h>
25 #include <arpa/inet.h>
27 #include <dbus/dbus.h>
30 #include <ckmc/ckmc-manager.h>
31 #include <tzplatform_config.h>
32 #include "tethering_private.h"
34 #define ALLOWED_LIST tzplatform_mkpath(TZ_SYS_VAR, "/lib/hostapd/hostapd.accept")
35 #define BLOCKED_LIST tzplatform_mkpath(TZ_SYS_VAR, "/lib/hostapd/hostapd.deny")
36 #define TEMP_LIST tzplatform_mkpath(TZ_SYS_VAR, "/lib/hostapd/.hostapd_tmp")
37 #define MAC_ADDR_LEN 18
38 #define MAX_BUF_SIZE 80
40 #define IPTABLES "/usr/sbin/iptables"
41 #define TABLE_NAT "nat"
42 #define TETH_NAT_PRE "teth_nat_pre"
43 #define TABLE_FILTER "filter"
44 #define TETH_FILTER_FW "teth_filter_fw"
45 #define ACTION_DROP "DROP"
46 #define ACTION_ACCEPT "ACCEPT"
47 #define PORT_FORWARD_RULE_STR "-t %s -A %s -i %s -p %s -d %s --dport %d -j DNAT --to %s:%d"
48 #define FILTERING_MULTIPORT_RULE_STR "-t %s -A %s -p %s -m multiport --dport %d,%d -j %s"
49 #define FILTERING_RULE_STR "-t %s -A %s -p %s --dport %d -j %s"
51 static GSList *allowed_list = NULL;
52 static GSList *blocked_list = NULL;
53 static GSList *port_forwarding = NULL;
54 static GSList *port_filtering = NULL;
55 static GSList *custom_port_filtering = NULL;
57 static void __handle_wifi_tether_on(GDBusConnection *connection, const gchar *sender_name,
58 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
59 GVariant *parameters, gpointer user_data);
61 static void __handle_wifi_tether_off(GDBusConnection *connection, const gchar *sender_name,
62 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
63 GVariant *parameters, gpointer user_data);
65 static void __handle_usb_tether_on(GDBusConnection *connection, const gchar *sender_name,
66 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
67 GVariant *parameters, gpointer user_data);
69 static void __handle_usb_tether_off(GDBusConnection *connection, const gchar *sender_name,
70 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
71 GVariant *parameters, gpointer user_data);
73 static void __handle_bt_tether_on(GDBusConnection *connection, const gchar *sender_name,
74 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
75 GVariant *parameters, gpointer user_data);
77 static void __handle_bt_tether_off(GDBusConnection *connection, const gchar *sender_name,
78 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
79 GVariant *parameters, gpointer user_data);
81 static void __handle_net_closed(GDBusConnection *connection, const gchar *sender_name,
82 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
83 GVariant *parameters, gpointer user_data);
85 static void __handle_no_data_timeout(GDBusConnection *connection, const gchar *sender_name,
86 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
87 GVariant *parameters, gpointer user_data);
89 static void __handle_low_battery_mode(GDBusConnection *connection, const gchar *sender_name,
90 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
91 GVariant *parameters, gpointer user_data);
93 static void __handle_flight_mode(GDBusConnection *connection, const gchar *sender_name,
94 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
95 GVariant *parameters, gpointer user_data);
97 static void __handle_security_type_changed(GDBusConnection *connection, const gchar *sender_name,
98 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
99 GVariant *parameters, gpointer user_data);
101 static void __handle_ssid_visibility_changed(GDBusConnection *connection, const gchar *sender_name,
102 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
103 GVariant *parameters, gpointer user_data);
105 static void __handle_passphrase_changed(GDBusConnection *connection, const gchar *sender_name,
106 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
107 GVariant *parameters, gpointer user_data);
109 static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name,
110 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
111 GVariant *parameters, gpointer user_data);
113 static __tethering_sig_t sigs[] = {
114 {0, SIGNAL_NAME_NET_CLOSED, __handle_net_closed},
115 {0, SIGNAL_NAME_WIFI_TETHER_ON, __handle_wifi_tether_on},
116 {0, SIGNAL_NAME_WIFI_TETHER_OFF, __handle_wifi_tether_off},
117 {0, SIGNAL_NAME_USB_TETHER_ON, __handle_usb_tether_on},
118 {0, SIGNAL_NAME_USB_TETHER_OFF, __handle_usb_tether_off},
119 {0, SIGNAL_NAME_BT_TETHER_ON, __handle_bt_tether_on},
120 {0, SIGNAL_NAME_BT_TETHER_OFF, __handle_bt_tether_off},
121 {0, SIGNAL_NAME_NO_DATA_TIMEOUT, __handle_no_data_timeout},
122 {0, SIGNAL_NAME_LOW_BATTERY_MODE, __handle_low_battery_mode},
123 {0, SIGNAL_NAME_FLIGHT_MODE, __handle_flight_mode},
124 {0, SIGNAL_NAME_SECURITY_TYPE_CHANGED, __handle_security_type_changed},
125 {0, SIGNAL_NAME_SSID_VISIBILITY_CHANGED, __handle_ssid_visibility_changed},
126 {0, SIGNAL_NAME_PASSPHRASE_CHANGED, __handle_passphrase_changed},
127 {0, SIGNAL_NAME_DHCP_STATUS, __handle_dhcp} };
129 static int retry = 0;
131 static void __send_dbus_signal(GDBusConnection *conn, const char *signal_name, const char *arg)
133 if (conn == NULL || signal_name == NULL)
136 GVariant *message = NULL;
137 GError *error = NULL;
140 message = g_variant_new("(s)", arg);
142 g_dbus_connection_emit_signal(conn, NULL, TETHERING_SERVICE_OBJECT_PATH,
143 TETHERING_SERVICE_INTERFACE, signal_name, message, &error);
145 ERR("g_dbus_connection_emit_signal is failed because %s\n", error->message);
150 static bool __any_tethering_is_enabled(tethering_h tethering)
152 if (tethering_is_enabled(tethering, TETHERING_TYPE_USB) ||
153 tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) ||
154 tethering_is_enabled(tethering, TETHERING_TYPE_BT) ||
155 tethering_is_enabled(tethering, TETHERING_TYPE_P2P))
161 static tethering_error_e __set_security_type(const tethering_wifi_security_type_e security_type)
163 if (security_type != TETHERING_WIFI_SECURITY_TYPE_NONE &&
164 security_type != TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK &&
165 security_type != TETHERING_WIFI_SECURITY_TYPE_WPS &&
166 security_type != TETHERING_WIFI_SECURITY_TYPE_SAE) {
167 ERR("Invalid param\n");
168 return TETHERING_ERROR_INVALID_PARAMETER;
171 if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY, security_type) < 0) {
172 ERR("vconf_set_int is failed\n");
173 return TETHERING_ERROR_OPERATION_FAILED;
176 return TETHERING_ERROR_NONE;
179 static tethering_error_e __get_security_type(tethering_wifi_security_type_e *security_type)
181 if (security_type == NULL) {
182 ERR("Invalid param\n");
183 return TETHERING_ERROR_INVALID_PARAMETER;
186 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY,
187 (int *)security_type) < 0) {
188 ERR("vconf_get_int is failed\n");
189 return TETHERING_ERROR_OPERATION_FAILED;
192 return TETHERING_ERROR_NONE;
195 static bool __get_ssid_from_vconf(const char *path, char *ssid, unsigned int size)
197 if (path == NULL || ssid == NULL || size == 0)
201 char *ptr_tmp = NULL;
203 ptr = vconf_get_str(path);
207 if (!g_utf8_validate(ptr, -1, (const char **)&ptr_tmp))
210 g_strlcpy(ssid, ptr, size);
216 static tethering_error_e __set_visible(const bool visible)
218 if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, visible ? 0 : 1) < 0) {
219 ERR("vconf_set_int is failed\n");
220 return TETHERING_ERROR_OPERATION_FAILED;
223 return TETHERING_ERROR_NONE;
226 static tethering_error_e __get_visible(bool *visible)
228 if (visible == NULL) {
229 ERR("Invalid param\n");
230 return TETHERING_ERROR_INVALID_PARAMETER;
235 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, &hide) < 0) {
236 ERR("vconf_get_int is failed\n");
237 return TETHERING_ERROR_OPERATION_FAILED;
244 return TETHERING_ERROR_NONE;
247 static unsigned int __generate_initial_passphrase(char *passphrase, unsigned int size)
249 if (passphrase == NULL ||
250 size == 0 || size < TETHERING_WIFI_KEY_MIN_LEN + 1)
253 guint32 rand_int = 0;
256 for (index = 0; index < TETHERING_WIFI_KEY_MIN_LEN; index++) {
257 rand_int = g_random_int_range('a', 'z');
258 passphrase[index] = rand_int;
260 passphrase[index] = '\0';
265 static tethering_error_e __get_error(int agent_error)
267 tethering_error_e err = TETHERING_ERROR_NONE;
269 switch (agent_error) {
270 case MOBILE_AP_ERROR_NONE:
271 err = TETHERING_ERROR_NONE;
274 case MOBILE_AP_ERROR_RESOURCE:
275 err = TETHERING_ERROR_OUT_OF_MEMORY;
278 case MOBILE_AP_ERROR_INTERNAL:
279 err = TETHERING_ERROR_OPERATION_FAILED;
282 case MOBILE_AP_ERROR_INVALID_PARAM:
283 err = TETHERING_ERROR_INVALID_PARAMETER;
286 case MOBILE_AP_ERROR_ALREADY_ENABLED:
287 err = TETHERING_ERROR_OPERATION_FAILED;
290 case MOBILE_AP_ERROR_NOT_ENABLED:
291 err = TETHERING_ERROR_NOT_ENABLED;
294 case MOBILE_AP_ERROR_NET_OPEN:
295 err = TETHERING_ERROR_OPERATION_FAILED;
298 case MOBILE_AP_ERROR_NET_CLOSE:
299 err = TETHERING_ERROR_OPERATION_FAILED;
302 case MOBILE_AP_ERROR_DHCP:
303 err = TETHERING_ERROR_OPERATION_FAILED;
306 case MOBILE_AP_ERROR_IN_PROGRESS:
307 err = TETHERING_ERROR_OPERATION_FAILED;
310 case MOBILE_AP_ERROR_NOT_PERMITTED:
311 err = TETHERING_ERROR_NOT_PERMITTED;
314 case MOBILE_AP_ERROR_PERMISSION_DENIED:
315 err = TETHERING_ERROR_PERMISSION_DENIED;
318 ERR("Not defined error : %d\n", agent_error);
319 err = TETHERING_ERROR_OPERATION_FAILED;
326 static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name,
327 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
328 GVariant *parameters, gpointer user_data)
332 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
334 __tethering_h *th = (__tethering_h *)user_data;
336 tethering_type_e type = 0;
337 mobile_ap_type_e ap_type = 0;
338 tethering_connection_state_changed_cb ccb = NULL;
339 __tethering_client_h client;
347 memset(&client, 0, sizeof(__tethering_client_h));
348 g_variant_get(parameters, "(susssu)", &buf, &ap_type, &ip, &mac, &name, ×tamp);
350 if (!g_strcmp0(buf, "DhcpConnected")) {
352 } else if (!g_strcmp0(buf, "DhcpLeaseDeleted")) {
355 ERR("Unknown event [%s]\n", buf);
359 if (ap_type == MOBILE_AP_TYPE_USB)
360 type = TETHERING_TYPE_USB;
361 else if (ap_type == MOBILE_AP_TYPE_WIFI)
362 type = TETHERING_TYPE_WIFI;
363 else if (ap_type == MOBILE_AP_TYPE_BT)
364 type = TETHERING_TYPE_BT;
365 else if (ap_type == MOBILE_AP_TYPE_P2P)
366 type = TETHERING_TYPE_P2P;
368 ERR("Not supported tethering type [%d]\n", ap_type);
372 ccb = th->changed_cb[type];
375 data = th->changed_user_data[type];
377 client.interface = type;
378 g_strlcpy(client.ip, ip, sizeof(client.ip));
379 g_strlcpy(client.mac, mac, sizeof(client.mac));
381 client.hostname = g_strdup(name);
382 client.tm = (time_t)timestamp;
384 ccb((tethering_client_h)&client, opened, data);
385 g_free(client.hostname);
394 static void __handle_net_closed(GDBusConnection *connection, const gchar *sender_name,
395 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
396 GVariant *parameters, gpointer user_data)
400 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
402 __tethering_h *th = (__tethering_h *)user_data;
403 tethering_type_e type = 0;
404 tethering_disabled_cb dcb = NULL;
406 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_NETWORK_CLOSE;
408 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
409 dcb = th->disabled_cb[type];
412 data = th->disabled_user_data[type];
414 dcb(TETHERING_ERROR_NONE, type, code, data);
420 static void __handle_wifi_tether_on(GDBusConnection *connection, const gchar *sender_name,
421 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
422 GVariant *parameters, gpointer user_data)
426 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
428 __tethering_h *th = (__tethering_h *)user_data;
429 tethering_type_e type = TETHERING_TYPE_WIFI;
430 bool is_requested = false;
431 tethering_enabled_cb ecb = NULL;
434 ecb = th->enabled_cb[type];
437 data = th->enabled_user_data[type];
439 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
443 static void __handle_wifi_tether_off(GDBusConnection *connection, const gchar *sender_name,
444 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
445 GVariant *parameters, gpointer user_data)
449 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
451 __tethering_h *th = (__tethering_h *)user_data;
452 tethering_type_e type = TETHERING_TYPE_WIFI;
453 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
454 tethering_disabled_cb dcb = NULL;
458 dcb = th->disabled_cb[type];
461 data = th->disabled_user_data[type];
462 g_variant_get(parameters, "(s)", &buf);
463 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
464 code = TETHERING_DISABLED_BY_WIFI_ON;
465 else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT))
466 code = TETHERING_DISABLED_BY_TIMEOUT;
469 dcb(TETHERING_ERROR_NONE, type, code, data);
474 static void __handle_usb_tether_on(GDBusConnection *connection, const gchar *sender_name,
475 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
476 GVariant *parameters, gpointer user_data)
480 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
482 __tethering_h *th = (__tethering_h *)user_data;
483 tethering_type_e type = TETHERING_TYPE_USB;
484 bool is_requested = false;
485 tethering_enabled_cb ecb = NULL;
488 ecb = th->enabled_cb[type];
491 data = th->enabled_user_data[type];
493 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
497 static void __handle_usb_tether_off(GDBusConnection *connection, const gchar *sender_name,
498 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
499 GVariant *parameters, gpointer user_data)
503 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
505 __tethering_h *th = (__tethering_h *)user_data;
506 tethering_type_e type = TETHERING_TYPE_USB;
507 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
508 tethering_disabled_cb dcb = NULL;
512 dcb = th->disabled_cb[type];
515 data = th->disabled_user_data[type];
517 g_variant_get(parameters, "(s)", &buf);
518 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
519 code = TETHERING_DISABLED_BY_USB_DISCONNECTION;
521 dcb(TETHERING_ERROR_NONE, type, code, data);
526 static void __handle_bt_tether_on(GDBusConnection *connection, const gchar *sender_name,
527 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
528 GVariant *parameters, gpointer user_data)
532 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
534 __tethering_h *th = (__tethering_h *)user_data;
535 tethering_type_e type = TETHERING_TYPE_BT;
536 bool is_requested = false;
537 tethering_enabled_cb ecb = NULL;
540 ecb = th->enabled_cb[type];
543 data = th->enabled_user_data[type];
545 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
549 static void __handle_bt_tether_off(GDBusConnection *connection, const gchar *sender_name,
550 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
551 GVariant *parameters, gpointer user_data)
555 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
557 __tethering_h *th = (__tethering_h *)user_data;
558 tethering_type_e type = TETHERING_TYPE_BT;
559 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
560 tethering_disabled_cb dcb = NULL;
564 dcb = th->disabled_cb[type];
567 data = th->disabled_user_data[type];
568 g_variant_get(parameters, "(s)", &buf);
569 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
570 code = TETHERING_DISABLED_BY_BT_OFF;
571 else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT))
572 code = TETHERING_DISABLED_BY_TIMEOUT;
574 dcb(TETHERING_ERROR_NONE, type, code, data);
580 static void __handle_no_data_timeout(GDBusConnection *connection, const gchar *sender_name,
581 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
582 GVariant *parameters, gpointer user_data)
586 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
588 __tethering_h *th = (__tethering_h *)user_data;
589 tethering_type_e type = 0;
590 tethering_disabled_cb dcb = NULL;
592 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_TIMEOUT;
594 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
595 dcb = th->disabled_cb[type];
598 data = th->disabled_user_data[type];
600 dcb(TETHERING_ERROR_NONE, type, code, data);
605 static void __handle_low_battery_mode(GDBusConnection *connection, const gchar *sender_name,
606 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
607 GVariant *parameters, gpointer user_data)
611 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
613 __tethering_h *th = (__tethering_h *)user_data;
614 tethering_type_e type = 0;
615 tethering_disabled_cb dcb = NULL;
617 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_LOW_BATTERY;
619 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
620 dcb = th->disabled_cb[type];
623 data = th->disabled_user_data[type];
625 dcb(TETHERING_ERROR_NONE, type, code, data);
630 static void __handle_flight_mode(GDBusConnection *connection, const gchar *sender_name,
631 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
632 GVariant *parameters, gpointer user_data)
636 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
638 __tethering_h *th = (__tethering_h *)user_data;
639 tethering_type_e type = 0;
640 tethering_disabled_cb dcb = NULL;
642 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_FLIGHT_MODE;
644 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
645 dcb = th->disabled_cb[type];
648 data = th->disabled_user_data[type];
650 dcb(TETHERING_ERROR_NONE, type, code, data);
655 static void __handle_security_type_changed(GDBusConnection *connection, const gchar *sender_name,
656 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
657 GVariant *parameters, gpointer user_data)
662 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
663 __tethering_h *th = (__tethering_h *)user_data;
665 tethering_wifi_security_type_changed_cb scb = NULL;
667 tethering_wifi_security_type_e security_type;
670 scb = th->security_type_changed_cb;
674 g_variant_get(parameters, "(s)", &buf);
675 data = th->security_type_user_data;
676 if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_OPEN_STR) == 0)
677 security_type = TETHERING_WIFI_SECURITY_TYPE_NONE;
678 else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR) == 0)
679 security_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK;
680 else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_WPS_STR) == 0)
681 security_type = TETHERING_WIFI_SECURITY_TYPE_WPS;
682 else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_SAE_STR) == 0)
683 security_type = TETHERING_WIFI_SECURITY_TYPE_SAE;
685 SERR("Unknown type : %s\n", buf);
690 scb(security_type, data);
695 static void __handle_ssid_visibility_changed(GDBusConnection *connection, const gchar *sender_name,
696 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
697 GVariant *parameters, gpointer user_data)
701 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
702 __tethering_h *th = (__tethering_h *)user_data;
704 tethering_wifi_ssid_visibility_changed_cb scb = NULL;
706 bool visible = false;
709 scb = th->ssid_visibility_changed_cb;
714 g_variant_get(parameters, "(s)", &buf);
715 data = th->ssid_visibility_user_data;
716 if (g_strcmp0(buf, SIGNAL_MSG_SSID_VISIBLE) == 0)
724 static void __handle_passphrase_changed(GDBusConnection *connection, const gchar *sender_name,
725 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
726 GVariant *parameters, gpointer user_data)
730 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
731 __tethering_h *th = (__tethering_h *)user_data;
733 tethering_wifi_passphrase_changed_cb pcb = NULL;
736 pcb = th->passphrase_changed_cb;
740 data = th->passphrase_user_data;
746 static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
751 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
752 GError *g_error = NULL;
755 tethering_error_e error;
756 __tethering_h *th = (__tethering_h *)user_data;
757 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_WIFI];
758 void *data = th->enabled_user_data[TETHERING_TYPE_WIFI];
760 if (!_tethering_check_handle((tethering_h)user_data))
763 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
765 ERR("DBus error [%s]\n", g_error->message);
766 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
767 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
768 g_error_free(g_error);
769 tethering_enable((tethering_h)th, TETHERING_TYPE_WIFI);
771 } else if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
772 error = TETHERING_ERROR_PERMISSION_DENIED;
774 error = TETHERING_ERROR_OPERATION_FAILED;
775 g_error_free(g_error);
777 g_variant_get(g_var, "(u)", &info);
778 error = __get_error(info);
782 INFO("cfm event : wifi tethering enable info : %d\n", error);
784 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
785 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_ON].name,
786 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
787 sigs[E_SIGNAL_WIFI_TETHER_ON].cb, (gpointer)th, NULL);
793 ecb(error, TETHERING_TYPE_WIFI, true, data);
794 g_variant_unref(g_var);
798 static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
802 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
803 GError *g_error = NULL;
806 tethering_error_e error;
808 __tethering_h *th = (__tethering_h *)user_data;
809 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_BT];
810 void *data = th->enabled_user_data[TETHERING_TYPE_BT];
812 if (!_tethering_check_handle((tethering_h)user_data))
815 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
817 ERR("DBus error [%s]\n", g_error->message);
818 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
819 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
820 g_error_free(g_error);
821 tethering_enable((tethering_h)th, TETHERING_TYPE_BT);
825 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
826 error = TETHERING_ERROR_PERMISSION_DENIED;
828 error = TETHERING_ERROR_OPERATION_FAILED;
829 g_error_free(g_error);
831 g_variant_get(g_var, "(u)", &info);
832 g_variant_unref(g_var);
833 error = __get_error(info);
837 sigs[E_SIGNAL_BT_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
838 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_ON].name,
839 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
840 sigs[E_SIGNAL_BT_TETHER_ON].cb, (gpointer)th, NULL);
847 ecb(error, TETHERING_TYPE_BT, true, data);
851 static void __usb_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
856 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
857 __tethering_h *th = (__tethering_h *)user_data;
858 GError *g_error = NULL;
861 tethering_error_e error;
862 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_USB];
863 void *data = th->enabled_user_data[TETHERING_TYPE_USB];
865 if (!_tethering_check_handle((tethering_h)user_data))
868 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
870 ERR("DBus error [%s]\n", g_error->message);
871 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
872 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
873 g_error_free(g_error);
874 tethering_enable((tethering_h)th, TETHERING_TYPE_USB);
878 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
879 error = TETHERING_ERROR_PERMISSION_DENIED;
881 error = TETHERING_ERROR_OPERATION_FAILED;
882 g_error_free(g_error);
884 g_variant_get(g_var, "(u)", &info);
885 g_variant_unref(g_var);
886 error = __get_error(info);
890 sigs[E_SIGNAL_USB_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
891 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_ON].name,
892 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
893 sigs[E_SIGNAL_USB_TETHER_ON].cb, (gpointer)th, NULL);
900 ecb(error, TETHERING_TYPE_USB, true, data);
904 static void __p2p_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
909 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
910 __tethering_h *th = (__tethering_h *)user_data;
911 GError *g_error = NULL;
914 tethering_error_e error;
915 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_P2P];
916 void *data = th->enabled_user_data[TETHERING_TYPE_P2P];
918 if (!_tethering_check_handle((tethering_h)user_data))
921 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
923 ERR("DBus error [%s]\n", g_error->message);
924 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
925 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
926 g_error_free(g_error);
927 tethering_enable((tethering_h)th, TETHERING_TYPE_P2P);
931 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
932 error = TETHERING_ERROR_PERMISSION_DENIED;
934 error = TETHERING_ERROR_OPERATION_FAILED;
935 g_error_free(g_error);
937 g_variant_get(g_var, "(u)", &info);
938 g_variant_unref(g_var);
939 error = __get_error(info);
948 ecb(error, TETHERING_TYPE_P2P, true, data);
952 static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res,
957 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
958 GError *g_error = NULL;
960 guint info, event_type;
961 tethering_error_e error;
962 tethering_type_e type;
963 tethering_h tethering = (tethering_h)user_data;
964 __tethering_h *th = (__tethering_h *)tethering;
965 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_REQUEST;
966 tethering_disabled_cb dcb = NULL;
969 if (!_tethering_check_handle((tethering_h)user_data))
972 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
974 ERR("DBus error [%s]\n", g_error->message);
975 g_error_free(g_error);
978 g_variant_get(g_var, "(uu)", &event_type, &info);
979 INFO("cfm event : %d info : %d\n", event_type, info);
980 g_variant_unref(g_var);
981 error = __get_error(info);
982 INFO("cfm event : %d info : %d\n", event_type, error);
983 switch (event_type) {
984 case MOBILE_AP_DISABLE_WIFI_TETHERING_CFM:
985 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
986 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_OFF].name,
987 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
988 sigs[E_SIGNAL_WIFI_TETHER_OFF].cb, (gpointer)th, NULL);
990 type = TETHERING_TYPE_WIFI;
991 dcb = th->disabled_cb[type];
992 data = th->disabled_user_data[type];
994 dcb(error, type, code, data);
997 case MOBILE_AP_DISABLE_BT_TETHERING_CFM:
998 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
999 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_OFF].name,
1000 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1001 sigs[E_SIGNAL_BT_TETHER_OFF].cb, (gpointer)th, NULL);
1003 type = TETHERING_TYPE_BT;
1004 dcb = th->disabled_cb[type];
1005 data = th->disabled_user_data[type];
1007 dcb(error, type, code, data);
1010 case MOBILE_AP_DISABLE_USB_TETHERING_CFM:
1011 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1012 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
1013 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1014 sigs[E_SIGNAL_USB_TETHER_OFF].cb, (gpointer)th, NULL);
1016 type = TETHERING_TYPE_USB;
1017 dcb = th->disabled_cb[type];
1018 data = th->disabled_user_data[type];
1020 dcb(error, type, code, data);
1023 case MOBILE_AP_DISABLE_P2P_TETHERING_CFM:
1024 type = TETHERING_TYPE_P2P;
1025 dcb = th->disabled_cb[type];
1026 data = th->disabled_user_data[type];
1028 dcb(error, type, code, data);
1031 case MOBILE_AP_DISABLE_CFM:
1033 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1034 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_OFF].name,
1035 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1036 sigs[E_SIGNAL_WIFI_TETHER_OFF].cb, (gpointer)th, NULL);
1037 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1038 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_OFF].name,
1039 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1040 sigs[E_SIGNAL_BT_TETHER_OFF].cb, (gpointer)th, NULL);
1041 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1042 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
1043 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1044 sigs[E_SIGNAL_USB_TETHER_OFF].cb, (gpointer)th, NULL);
1046 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
1047 dcb = th->disabled_cb[type];
1050 data = th->disabled_user_data[type];
1052 dcb(error, type, code, data);
1057 ERR("Invalid event\n");
1063 static void __get_data_usage_cb(GObject *source_object, GAsyncResult *res,
1068 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1070 GError *g_error = NULL;
1073 guint64 tx_bytes, rx_bytes;
1074 __tethering_h *th = (__tethering_h *)user_data;
1075 tethering_error_e tethering_error = TETHERING_ERROR_NONE;
1078 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1080 ERR("DBus fail [%s]\n", g_error->message);
1081 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1082 tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1084 tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1088 if (th->data_usage_cb == NULL) {
1089 ERR("There is no data_usage_cb\n");
1093 th->data_usage_cb(tethering_error, 0LL, 0LL, th->data_usage_user_data);
1095 g_variant_get(g_var, "(utt)", &event_type, &tx_bytes, &rx_bytes);
1096 th->data_usage_cb(TETHERING_ERROR_NONE,
1097 rx_bytes, tx_bytes, th->data_usage_user_data);
1098 g_variant_unref(g_var);
1100 th->data_usage_cb = NULL;
1101 th->data_usage_user_data = NULL;
1106 static void __settings_reloaded_cb(GObject *source_object, GAsyncResult *res,
1111 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1112 GError *g_error = NULL;
1115 __tethering_h *th = (__tethering_h *)user_data;
1116 tethering_error_e tethering_error = TETHERING_ERROR_NONE;
1118 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1120 ERR("DBus fail [%s]\n", g_error->message);
1121 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1122 tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1124 tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1125 g_error_free(g_error);
1127 g_variant_get(g_var, "(u)", &info);
1128 if (tethering_error == TETHERING_ERROR_NONE)
1129 tethering_error = __get_error(info);
1130 g_variant_unref(g_var);
1133 if (th->settings_reloaded_cb == NULL) {
1134 DBG("There is no settings_reloaded_cb\n-\n");
1138 th->settings_reloaded_cb(tethering_error,
1139 th->settings_reloaded_user_data);
1141 th->settings_reloaded_cb = NULL;
1142 th->settings_reloaded_user_data = NULL;
1146 static void __connect_signals(tethering_h tethering)
1149 _retm_if(tethering == NULL, "parameter(tethering) is NULL\n");
1151 __tethering_h *th = (__tethering_h *)tethering;
1152 GDBusConnection *connection = th->client_bus;
1155 for (i = E_SIGNAL_NET_CLOSED; i < E_SIGNAL_MAX; i++) {
1156 sigs[i].sig_id = g_dbus_connection_signal_subscribe(connection,
1157 NULL, TETHERING_SERVICE_INTERFACE, sigs[i].name,
1158 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1159 sigs[i].cb, tethering, NULL);
1164 static void __disconnect_signals(tethering_h tethering)
1168 _retm_if(tethering == NULL, "parameter(tethering) is NULL\n");
1170 __tethering_h *th = (__tethering_h *)tethering;
1171 GDBusConnection *connection = th->client_bus;
1175 for (i = E_SIGNAL_NET_CLOSED; i < E_SIGNAL_MAX; i++)
1176 g_dbus_connection_signal_unsubscribe(connection, sigs[i].sig_id);
1182 static bool __get_intf_name(tethering_type_e type, char *buf, unsigned int len)
1184 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1187 case TETHERING_TYPE_USB:
1188 g_strlcpy(buf, TETHERING_USB_IF, len);
1190 case TETHERING_TYPE_WIFI:
1191 g_strlcpy(buf, TETHERING_WIFI_IF, len);
1193 case TETHERING_TYPE_BT:
1194 g_strlcpy(buf, TETHERING_BT_IF, len);
1196 case TETHERING_TYPE_P2P:
1197 g_strlcpy(buf, TETHERING_P2P_IF, len);
1200 ERR("Not supported type : %d\n", type);
1206 static bool __get_gateway_addr(tethering_type_e type, char *buf, unsigned int len)
1208 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1211 case TETHERING_TYPE_USB:
1212 g_strlcpy(buf, TETHERING_USB_GATEWAY, len);
1214 case TETHERING_TYPE_WIFI:
1215 g_strlcpy(buf, TETHERING_WIFI_GATEWAY, len);
1217 case TETHERING_TYPE_BT:
1218 g_strlcpy(buf, TETHERING_BT_GATEWAY, len);
1220 case TETHERING_TYPE_P2P:
1221 g_strlcpy(buf, TETHERING_P2P_GATEWAY, len);
1224 ERR("Not supported type : %d\n", type);
1230 static int __get_common_ssid(char *ssid, unsigned int size)
1233 ERR("ssid is null\n");
1234 return TETHERING_ERROR_INVALID_PARAMETER;
1238 char *ptr_tmp = NULL;
1240 ptr = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
1242 ERR("vconf_get_str is failed and set default ssid");
1243 g_strlcpy(ssid, TETHERING_DEFAULT_SSID, size);
1245 g_strlcpy(ssid, ptr, size);
1249 if (!g_utf8_validate(ssid, -1, (const char **)&ptr_tmp))
1252 return TETHERING_ERROR_NONE;
1255 static bool __get_wifi_mode_type(tethering_wifi_mode_type_e type, char **buf)
1257 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1260 case TETHERING_WIFI_MODE_TYPE_B:
1261 *buf = g_strdup("b");
1263 case TETHERING_WIFI_MODE_TYPE_G:
1264 *buf = g_strdup("g");
1266 case TETHERING_WIFI_MODE_TYPE_A:
1267 *buf = g_strdup("a");
1269 case TETHERING_WIFI_MODE_TYPE_AD:
1270 *buf = g_strdup("ad");
1273 ERR("Not supported type : %d\n", type);
1279 static int __prepare_wifi_settings(tethering_h tethering, _softap_settings_t *set)
1283 __tethering_h *th = (__tethering_h *)tethering;
1284 tethering_error_e ret = TETHERING_ERROR_NONE;
1287 if (th == NULL || set == NULL) {
1288 ERR("null parameter\n-\n");
1289 return TETHERING_ERROR_INVALID_PARAMETER;
1292 if (th->ssid == NULL)
1293 __get_common_ssid(set->ssid, sizeof(set->ssid));
1295 g_strlcpy(set->ssid, th->ssid, sizeof(set->ssid));
1297 ret = __get_security_type(&set->sec_type);
1298 if (ret != TETHERING_ERROR_NONE)
1299 set->sec_type = th->sec_type;
1301 ret = __get_visible(&set->visibility);
1302 if (ret != TETHERING_ERROR_NONE)
1303 set->visibility = th->visibility;
1305 set->mac_filter = th->mac_filter;
1306 set->max_connected = th->wifi_max_connected;
1307 set->channel = th->channel;
1309 __get_wifi_mode_type(th->mode_type, &ptr);
1311 g_strlcpy(set->mode, "", sizeof(set->mode));
1313 g_strlcpy(set->mode, ptr, sizeof(set->mode));
1317 if (set->sec_type == TETHERING_WIFI_SECURITY_TYPE_NONE) {
1318 g_strlcpy(set->key, "", sizeof(set->key));
1320 GDBusProxy *proxy = th->client_bus_proxy;
1321 GVariant *parameters;
1322 GError *error = NULL;
1323 char *passphrase = NULL;
1324 unsigned int len = 0;
1326 parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_passphrase",
1327 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1330 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
1332 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
1333 ret = TETHERING_ERROR_PERMISSION_DENIED;
1335 ret = TETHERING_ERROR_OPERATION_FAILED;
1337 g_error_free(error);
1341 if (parameters != NULL) {
1342 g_variant_get(parameters, "(siu)", &passphrase, &len, &ret);
1343 g_strlcpy(set->key, passphrase, sizeof(set->key) - 1);
1345 g_variant_unref(parameters);
1349 INFO("ssid: %s security: %d mode: %s channel: %d visibility: %s\n",
1350 set->ssid, set->sec_type, set->mode, set->channel,
1351 (set->visibility) ? "true" : "false");
1353 return TETHERING_ERROR_NONE;
1356 static bool __check_precondition(tethering_type_e type)
1358 int dnet_status = 0;
1359 int cellular_state = 0;
1361 /* data network through cellular */
1362 vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &cellular_state);
1363 if (cellular_state == VCONFKEY_NETWORK_CELLULAR_ON) {
1364 INFO("Data Network can be connected later");
1368 /* data network status */
1369 vconf_get_int(VCONFKEY_NETWORK_STATUS, &dnet_status);
1370 if ((dnet_status == VCONFKEY_NETWORK_WIFI
1371 && type != TETHERING_TYPE_WIFI)
1372 || dnet_status == VCONFKEY_NETWORK_ETHERNET)
1375 ERR("Network is not available!");
1381 * @brief Creates the handle of tethering.
1383 * @privlevel platform
1384 * @privilege http://tizen.org/privilege/tethering.admin
1385 * @remarks The @a tethering must be released tethering_destroy() by you.
1386 * @param[out] tethering A handle of a new mobile ap handle on success
1387 * @return 0 on success, otherwise a negative error value.
1388 * @retval #TETHERING_ERROR_NONE Successful
1389 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1390 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1391 * @retval #TETHERING_ERROR_NOT_SUPPORT_API API is not supported
1392 * @see tethering_destroy()
1394 API int tethering_create(tethering_h *tethering)
1396 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1397 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1398 "parameter(tethering) is NULL\n");
1401 __tethering_h *th = NULL;
1402 GError *error = NULL;
1403 char ssid[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
1405 th = (__tethering_h *)malloc(sizeof(__tethering_h));
1407 _retvm_if(th == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
1408 "malloc is failed\n");
1409 memset(th, 0x00, sizeof(__tethering_h));
1410 th->sec_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK;
1411 th->visibility = true;
1412 th->mac_filter = false;
1413 th->channel = TETHERING_WIFI_CHANNEL;
1414 th->mode_type = TETHERING_WIFI_MODE_TYPE_G;
1415 th->wifi_max_connected = TETHERING_WIFI_MAX_STA;
1417 if (__generate_initial_passphrase(th->passphrase,
1418 sizeof(th->passphrase)) == 0) {
1419 ERR("random passphrase generation failed\n");
1421 return TETHERING_ERROR_OPERATION_FAILED;
1424 if (__get_common_ssid(ssid, sizeof(ssid)) != TETHERING_ERROR_NONE) {
1425 ERR("common ssid get failed\n");
1427 return TETHERING_ERROR_OPERATION_FAILED;
1430 #if !GLIB_CHECK_VERSION(2, 36, 0)
1433 GCancellable *cancellable = g_cancellable_new();
1434 th->client_bus = g_bus_get_sync(DBUS_BUS_SYSTEM, cancellable, &error);
1436 ERR("Couldn't connect to the System bus[%s]", error->message);
1437 g_error_free(error);
1438 g_cancellable_cancel(cancellable);
1439 g_object_unref(cancellable);
1441 return TETHERING_ERROR_OPERATION_FAILED;
1443 th->cancellable = cancellable;
1445 th->client_bus_proxy = g_dbus_proxy_new_sync(th->client_bus, G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION,
1446 NULL, TETHERING_SERVICE_NAME, TETHERING_SERVICE_OBJECT_PATH,
1447 TETHERING_SERVICE_INTERFACE, th->cancellable, &error);
1448 if (!th->client_bus_proxy) {
1450 ERR("Couldn't create the proxy object because of %s\n", error->message);
1451 g_cancellable_cancel(th->cancellable);
1452 g_object_unref(th->cancellable);
1453 g_object_unref(th->client_bus);
1455 return TETHERING_ERROR_OPERATION_FAILED;
1458 __connect_signals((tethering_h)th);
1460 *tethering = (tethering_h)th;
1461 _tethering_add_handle(th);
1462 INFO("Tethering Handle : %p\n", th);
1464 return TETHERING_ERROR_NONE;
1469 * @brief Destroys the handle of tethering.
1471 * @privlevel platform
1472 * @privilege http://tizen.org/privilege/tethering.admin
1473 * @param[in] tethering The handle of tethering
1474 * @return 0 on success, otherwise a negative error value.
1475 * @retval #TETHERING_ERROR_NONE Successful
1476 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1477 * @see tethering_create()
1479 API int tethering_destroy(tethering_h tethering)
1482 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1483 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1484 "parameter(tethering) is NULL\n");
1486 __tethering_h *th = (__tethering_h *)tethering;
1488 INFO("Tethering Handle : %p\n", th);
1490 __disconnect_signals(tethering);
1491 _tethering_remove_handle(th);
1496 g_object_unref(th->cancellable);
1497 g_object_unref(th->client_bus_proxy);
1498 g_object_unref(th->client_bus);
1499 memset(th, 0x00, sizeof(__tethering_h));
1504 return TETHERING_ERROR_NONE;
1509 * @brief Enables the tethering, asynchronously.
1511 * @privlevel platform
1512 * @privilege http://tizen.org/privilege/tethering.admin
1513 * @param[in] tethering The handle of tethering
1514 * @param[in] type The type of tethering
1515 * @return 0 on success, otherwise negative error value.
1516 * @retval #TETHERING_ERROR_NONE Successful
1517 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1518 * @post tethering_enabled_cb() will be invoked.
1519 * @see tethering_is_enabled()
1520 * @see tethering_disable()
1522 API int tethering_enable(tethering_h tethering, tethering_type_e type)
1524 INFO("+ type : %d\n", type);
1525 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1526 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1527 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1528 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1530 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1531 "parameter(tethering) is NULL\n");
1533 tethering_error_e ret = TETHERING_ERROR_NONE;
1534 __tethering_h *th = (__tethering_h *)tethering;
1535 GDBusProxy *proxy = th->client_bus_proxy;
1536 GDBusConnection *connection = th->client_bus;
1538 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
1540 if (__check_precondition(type) == FALSE) {
1542 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1543 return TETHERING_ERROR_OPERATION_FAILED;
1547 case TETHERING_TYPE_USB:
1548 g_dbus_connection_signal_unsubscribe(connection,
1549 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1551 g_dbus_proxy_call(proxy, "enable_usb_tethering",
1552 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1553 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1554 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1557 case TETHERING_TYPE_WIFI: {
1558 _softap_settings_t set = {"", "", "", 0, false};
1560 ret = __prepare_wifi_settings(tethering, &set);
1561 if (ret != TETHERING_ERROR_NONE) {
1562 ERR("softap settings initialization failed\n");
1564 return TETHERING_ERROR_OPERATION_FAILED;
1566 g_dbus_connection_signal_unsubscribe(connection,
1567 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1569 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1570 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),
1571 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1572 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1576 case TETHERING_TYPE_BT:
1577 g_dbus_connection_signal_unsubscribe(connection,
1578 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1580 g_dbus_proxy_call(proxy, "enable_bt_tethering",
1581 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1582 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1583 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1587 case TETHERING_TYPE_P2P: {
1588 _softap_settings_t p2p_set = {"", "", "", 0, false};
1589 ret = __prepare_wifi_settings(tethering, &p2p_set);
1590 if (ret != TETHERING_ERROR_NONE) {
1591 ERR("p2p settings initialization failed\n");
1592 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1594 return TETHERING_ERROR_OPERATION_FAILED;
1597 g_dbus_proxy_call(proxy, "enable_p2p_tethering",
1598 g_variant_new("(ssi)", p2p_set.ssid, p2p_set.key, p2p_set.channel),
1599 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1600 (GAsyncReadyCallback) __p2p_enabled_cfm_cb, (gpointer)tethering);
1604 case TETHERING_TYPE_ALL: {
1605 _softap_settings_t set = {"", "", "", 0, false};
1607 ret = __prepare_wifi_settings(tethering, &set);
1608 if (ret != TETHERING_ERROR_NONE) {
1609 ERR("softap settings initialization failed\n");
1610 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1611 return TETHERING_ERROR_OPERATION_FAILED;
1614 /* TETHERING_TYPE_USB */
1615 g_dbus_connection_signal_unsubscribe(connection,
1616 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1618 g_dbus_proxy_call(proxy, "enable_usb_tethering",
1619 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1620 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1621 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1623 /* TETHERING_TYPE_WIFI */
1624 g_dbus_connection_signal_unsubscribe(connection,
1625 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1627 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1628 g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode,
1629 set.channel, set.visibility, set.mac_filter, set.max_connected,
1630 set.sec_type, TETHERING_ADDRESS_FAMILY_IPV4),
1631 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1632 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1634 /* TETHERING_TYPE_BT */
1635 g_dbus_connection_signal_unsubscribe(connection,
1636 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1638 g_dbus_proxy_call(proxy, "enable_bt_tethering",
1639 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1640 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1641 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1645 ERR("Unknown type : %d\n", type);
1647 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1650 return TETHERING_ERROR_INVALID_PARAMETER;
1653 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1655 return TETHERING_ERROR_NONE;
1658 API int tethering_ipv6_enable(tethering_h tethering, tethering_type_e type)
1660 DBG("+ type : %d\n", type);
1661 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1662 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1663 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1664 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1666 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1667 "parameter(tethering) is NULL\n");
1669 __tethering_h *th = (__tethering_h *)tethering;
1670 GDBusProxy *proxy = th->client_bus_proxy;
1671 GDBusConnection *connection = th->client_bus;
1674 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
1676 if (__check_precondition(type) == FALSE) {
1678 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1679 return TETHERING_ERROR_OPERATION_FAILED;
1683 case TETHERING_TYPE_USB: {
1684 g_dbus_connection_signal_unsubscribe(connection,
1685 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1687 g_dbus_proxy_call(proxy, "enable_usb_tethering",
1688 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1689 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1690 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1694 case TETHERING_TYPE_WIFI: {
1695 _softap_settings_t set = {"", "", "", 0, false, false, 0, 0};
1697 ret = __prepare_wifi_settings(tethering, &set);
1698 if (ret != TETHERING_ERROR_NONE) {
1699 ERR("softap settings initialization failed\n");
1701 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1702 return TETHERING_ERROR_OPERATION_FAILED;
1704 g_dbus_connection_signal_unsubscribe(connection,
1705 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1706 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1707 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),
1708 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1709 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1713 case TETHERING_TYPE_BT: {
1714 g_dbus_connection_signal_unsubscribe(connection,
1715 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1717 g_dbus_proxy_call(proxy, "enable_bt_tethering",
1718 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1719 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1720 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1726 ERR("Unknown type : %d\n", type);
1728 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1731 return TETHERING_ERROR_INVALID_PARAMETER;
1735 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1737 return TETHERING_ERROR_NONE;
1740 API int tethering_ipv6_disable(tethering_h tethering, tethering_type_e type)
1742 DBG("+ type : %d\n", type);
1743 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1744 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1745 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1746 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1748 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1749 "parameter(tethering) is NULL\n");
1751 __tethering_h *th = (__tethering_h *)tethering;
1752 GDBusProxy *proxy = th->client_bus_proxy;
1753 GDBusConnection *connection = th->client_bus;
1756 case TETHERING_TYPE_USB:
1757 g_dbus_connection_signal_unsubscribe(connection,
1758 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1760 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1761 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1762 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1763 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1766 case TETHERING_TYPE_WIFI:
1767 DBG("Disable wifi tethering..");
1768 g_dbus_connection_signal_unsubscribe(connection,
1769 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1771 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1772 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1773 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1774 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1777 case TETHERING_TYPE_BT:
1778 g_dbus_connection_signal_unsubscribe(connection,
1779 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1781 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1782 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1783 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1784 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1788 ERR("Not supported tethering type [%d]\n", type);
1790 return TETHERING_ERROR_INVALID_PARAMETER;
1793 return TETHERING_ERROR_NONE;
1797 * @brief Disables the tethering, asynchronously.
1799 * @privlevel platform
1800 * @privilege http://tizen.org/privilege/tethering.admin
1801 * @param[in] tethering The handle of tethering
1802 * @param[in] type The type of tethering
1803 * @return 0 on success, otherwise negative error value.
1804 * @retval #TETHERING_ERROR_NONE Successful
1805 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1806 * @post tethering_disabled_cb() will be invoked.
1807 * @see tethering_is_enabled()
1808 * @see tethering_enable()
1810 API int tethering_disable(tethering_h tethering, tethering_type_e type)
1812 INFO("+ type : %d\n", type);
1813 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1814 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1815 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1816 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1818 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1819 "parameter(tethering) is NULL\n");
1821 __tethering_h *th = (__tethering_h *)tethering;
1822 GDBusProxy *proxy = th->client_bus_proxy;
1823 GDBusConnection *connection = th->client_bus;
1826 case TETHERING_TYPE_USB:
1827 g_dbus_connection_signal_unsubscribe(connection,
1828 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1830 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1831 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1832 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1833 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1837 case TETHERING_TYPE_WIFI:
1839 g_dbus_connection_signal_unsubscribe(connection,
1840 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1842 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1843 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1844 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1845 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1848 case TETHERING_TYPE_BT:
1850 g_dbus_connection_signal_unsubscribe(connection,
1851 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1853 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1854 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1855 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1856 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1859 case TETHERING_TYPE_P2P:
1860 g_dbus_proxy_call(proxy, "disable_p2p_tethering",
1861 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1862 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1865 case TETHERING_TYPE_ALL:
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);
1874 g_dbus_connection_signal_unsubscribe(connection,
1875 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1877 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1878 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1879 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1880 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1882 g_dbus_connection_signal_unsubscribe(connection,
1883 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1885 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1886 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1887 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1888 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1892 ERR("Not supported tethering type [%d]\n", type);
1894 return TETHERING_ERROR_INVALID_PARAMETER;
1897 return TETHERING_ERROR_NONE;
1902 * @brief Checks whetehr the tethering is enabled or not.
1904 * @privlevel platform
1905 * @privilege http://tizen.org/privilege/tethering.admin
1906 * @param[in] tethering The handle of tethering
1907 * @param[in] type The type of tethering
1908 * @return @c true if tethering is enabled, \n @c false if tethering is disabled.
1910 API bool tethering_is_enabled(tethering_h tethering, tethering_type_e type)
1912 INFO("+ type : %d\n", type);
1914 int vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_NONE;
1916 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1918 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &is_on) != 0)
1922 case TETHERING_TYPE_USB:
1923 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_USB;
1926 case TETHERING_TYPE_WIFI:
1927 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI;
1930 case TETHERING_TYPE_BT:
1931 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_BT;
1934 case TETHERING_TYPE_P2P:
1935 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_P2P;
1939 ERR("Not supported type : %d\n", type);
1942 INFO("- enabled: %s\n", (is_on & vconf_type) ? "true" : "false");
1943 return is_on & vconf_type ? true : false;
1948 * @brief Gets the MAC address of local device as "FC:A1:3E:D6:B1:B1".
1950 * @privlevel platform
1951 * @privilege http://tizen.org/privilege/tethering.admin
1952 * @remarks @a mac_address must be released with free() by you.
1953 * @param[in] tethering The handle of tethering
1954 * @param[in] type The type of tethering
1955 * @param[out] mac_address The MAC address
1956 * @return 0 on success, otherwise a negative error value.
1957 * @retval #TETHERING_ERROR_NONE Successful
1958 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1959 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1960 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
1961 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
1962 * @pre tethering must be enabled.
1963 * @see tethering_is_enabled()
1964 * @see tethering_enable()
1966 API int tethering_get_mac_address(tethering_h tethering, tethering_type_e type, char **mac_address)
1968 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1969 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1970 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1971 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1973 _retvm_if(tethering_is_enabled(tethering, type) == false,
1974 TETHERING_ERROR_NOT_ENABLED,
1975 "tethering type[%d] is not enabled\n", type);
1976 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1977 "parameter(tethering) is NULL\n");
1978 _retvm_if(mac_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1979 "parameter(mac_address) is NULL\n");
1983 char *macbuf = NULL;
1985 _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
1986 TETHERING_ERROR_OPERATION_FAILED,
1987 "getting interface name is failed\n");
1989 s = socket(AF_INET, SOCK_DGRAM, 0);
1990 _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
1991 "getting socket is failed\n");
1992 if (ioctl(s, SIOCGIFHWADDR, &ifr) < 0) {
1993 ERR("getting mac is failed\n");
1995 return TETHERING_ERROR_OPERATION_FAILED;
1999 macbuf = (char *)malloc(TETHERING_STR_INFO_LEN);
2000 _retvm_if(macbuf == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2001 "Not enough memory\n");
2002 snprintf(macbuf, TETHERING_STR_INFO_LEN, "%02X:%02X:%02X:%02X:%02X:%02X",
2003 (unsigned char)ifr.ifr_hwaddr.sa_data[0],
2004 (unsigned char)ifr.ifr_hwaddr.sa_data[1],
2005 (unsigned char)ifr.ifr_hwaddr.sa_data[2],
2006 (unsigned char)ifr.ifr_hwaddr.sa_data[3],
2007 (unsigned char)ifr.ifr_hwaddr.sa_data[4],
2008 (unsigned char)ifr.ifr_hwaddr.sa_data[5]);
2010 *mac_address = macbuf;
2012 return TETHERING_ERROR_NONE;
2017 * @brief Gets the name of network interface. For example, usb0.
2019 * @privlevel platform
2020 * @privilege http://tizen.org/privilege/tethering.admin
2021 * @remarks @a interface_name must be released with free() by you.
2022 * @param[in] tethering The handle of tethering
2023 * @param[in] type The type of tethering
2024 * @param[out] interface_name The name of network interface
2025 * @return 0 on success, otherwise negative error value.
2026 * @retval #TETHERING_ERROR_NONE Successful
2027 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2028 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2029 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2030 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2031 * @pre tethering must be enabled.
2032 * @see tethering_is_enabled()
2033 * @see tethering_enable()
2035 API int tethering_get_network_interface_name(tethering_h tethering, tethering_type_e type, char **interface_name)
2037 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2038 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2039 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2040 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2042 _retvm_if(tethering_is_enabled(tethering, type) == false,
2043 TETHERING_ERROR_NOT_ENABLED,
2044 "tethering type[%d] is not enabled\n", type);
2045 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2046 "parameter(tethering) is NULL\n");
2047 _retvm_if(interface_name == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2048 "parameter(interface_name) is NULL\n");
2050 char intf[TETHERING_STR_INFO_LEN] = {0, };
2052 _retvm_if(!__get_intf_name(type, intf, sizeof(intf)),
2053 TETHERING_ERROR_OPERATION_FAILED,
2054 "getting interface name is failed\n");
2055 *interface_name = strdup(intf);
2056 _retvm_if(*interface_name == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2057 "Not enough memory\n");
2059 return TETHERING_ERROR_NONE;
2064 * @brief Gets the local IP address.
2066 * @privlevel platform
2067 * @privilege http://tizen.org/privilege/tethering.admin
2068 * @remarks @a ip_address must be released with free() by you.
2069 * @param[in] tethering The handle of tethering
2070 * @param[in] type The type of tethering
2071 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2072 * @param[out] ip_address The local IP address
2073 * @return 0 on success, otherwise negative error value.
2074 * @retval #TETHERING_ERROR_NONE Successful
2075 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2076 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2077 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2078 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2079 * @pre tethering must be enabled.
2080 * @see tethering_is_enabled()
2081 * @see tethering_enable()
2083 API int tethering_get_ip_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **ip_address)
2085 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2086 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2087 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2088 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2090 _retvm_if(tethering_is_enabled(tethering, type) == false,
2091 TETHERING_ERROR_NOT_ENABLED,
2092 "tethering type[%d] is not enabled\n", type);
2093 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2094 "parameter(tethering) is NULL\n");
2095 _retvm_if(ip_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2096 "parameter(ip_address) is NULL\n");
2102 _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
2103 TETHERING_ERROR_OPERATION_FAILED,
2104 "getting interface name is failed\n");
2106 s = socket(AF_INET, SOCK_DGRAM, 0);
2107 _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
2108 "getting socket is failed\n");
2109 if (ioctl(s, SIOCGIFADDR, &ifr) < 0) {
2110 ERR("ioctl is failed\n");
2112 return TETHERING_ERROR_OPERATION_FAILED;
2116 ipbuf = inet_ntoa(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr);
2117 *ip_address = strdup(ipbuf);
2118 _retvm_if(*ip_address == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2119 "Not enough memory\n");
2121 return TETHERING_ERROR_NONE;
2126 * @brief Gets the Gateway address.
2128 * @privlevel platform
2129 * @privilege http://tizen.org/privilege/tethering.admin
2130 * @remarks @a gateway_address must be released with free() by you.
2131 * @param[in] tethering The handle of tethering
2132 * @param[in] type The type of tethering
2133 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2134 * @param[out] gateway_address The local IP address
2135 * @return 0 on success, otherwise negative error value.
2136 * @retval #TETHERING_ERROR_NONE Successful
2137 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2138 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2139 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2140 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2141 * @pre tethering must be enabled.
2142 * @see tethering_is_enabled()
2143 * @see tethering_enable()
2145 API int tethering_get_gateway_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **gateway_address)
2147 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2148 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2149 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2150 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2152 _retvm_if(tethering_is_enabled(tethering, type) == false,
2153 TETHERING_ERROR_NOT_ENABLED,
2154 "tethering type[%d] is not enabled\n", type);
2155 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2156 "parameter(tethering) is NULL\n");
2157 _retvm_if(gateway_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2158 "parameter(gateway_address) is NULL\n");
2160 char gateway_buf[TETHERING_STR_INFO_LEN] = {0, };
2162 _retvm_if(!__get_gateway_addr(type, gateway_buf, sizeof(gateway_buf)),
2163 TETHERING_ERROR_OPERATION_FAILED,
2164 "getting gateway address is failed\n");
2166 *gateway_address = strdup(gateway_buf);
2168 return TETHERING_ERROR_NONE;
2173 * @brief Gets the Subnet Mask.
2175 * @privlevel platform
2176 * @privilege http://tizen.org/privilege/tethering.admin
2177 * @remarks @a subnet_mask must be released with free() by you.
2178 * @param[in] tethering The handle of tethering
2179 * @param[in] type The type of tethering
2180 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2181 * @param[out] subnet_mask The local IP address
2182 * @return 0 on success, otherwise negative error value.
2183 * @retval #TETHERING_ERROR_NONE Successful
2184 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2185 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2186 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2187 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2188 * @pre tethering must be enabled.
2189 * @see tethering_is_enabled()
2190 * @see tethering_enable()
2192 API int tethering_get_subnet_mask(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **subnet_mask)
2194 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2195 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2196 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2197 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2199 _retvm_if(tethering_is_enabled(tethering, type) == false,
2200 TETHERING_ERROR_NOT_ENABLED,
2201 "tethering is not enabled\n");
2202 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2203 "parameter(tethering) is NULL\n");
2204 _retvm_if(subnet_mask == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2205 "parameter(subnet_mask) is NULL\n");
2207 *subnet_mask = strdup(TETHERING_SUBNET_MASK);
2208 _retvm_if(*subnet_mask == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2209 "Not enough memory\n");
2211 return TETHERING_ERROR_NONE;
2216 * @brief Gets the data usage.
2218 * @privlevel platform
2219 * @privilege http://tizen.org/privilege/tethering.admin
2220 * @param[in] tethering The handle of tethering
2221 * @param[out] usage The data usage
2222 * @return 0 on success, otherwise negative error value.
2223 * @retval #TETHERING_ERROR_NONE Successful
2224 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2225 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2226 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2227 * @pre tethering must be enabled.
2228 * @see tethering_is_enabled()
2229 * @see tethering_enable()
2231 API int tethering_get_data_usage(tethering_h tethering, tethering_data_usage_cb callback, void *user_data)
2233 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2235 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2236 "parameter(tethering) is NULL\n");
2237 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2238 "parameter(callback) is NULL\n");
2239 _retvm_if(__any_tethering_is_enabled(tethering) == false,
2240 TETHERING_ERROR_NOT_ENABLED,
2241 "tethering is not enabled\n");
2243 __tethering_h *th = (__tethering_h *)tethering;
2244 GDBusProxy *proxy = th->client_bus_proxy;
2246 th->data_usage_cb = callback;
2247 th->data_usage_user_data = user_data;
2249 g_dbus_proxy_call(proxy, "get_data_packet_usage",
2250 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2251 (GAsyncReadyCallback) __get_data_usage_cb, (gpointer)tethering);
2253 return TETHERING_ERROR_NONE;
2258 * @brief Gets the client which is connected by tethering "type".
2260 * @privlevel platform
2261 * @privilege http://tizen.org/privilege/tethering.admin
2262 * @param[in] tethering The handle of tethering
2263 * @param[in] type The type of tethering
2264 * @param[in] callback The callback function to invoke
2265 * @param[in] user_data The user data to be passed to the callback function
2266 * @retval #TETHERING_ERROR_NONE Successful
2267 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2268 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2269 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2270 * @pre tethering must be enabled.
2271 * @see tethering_is_enabled()
2272 * @see tethering_enable()
2274 API int tethering_foreach_connected_clients(tethering_h tethering, tethering_type_e type, tethering_connected_client_cb callback, void *user_data)
2276 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2277 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2278 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2279 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2281 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2282 "parameter(tethering) is NULL\n");
2283 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2284 "parameter(callback) is NULL\n");
2285 _retvm_if(__any_tethering_is_enabled(tethering) == false,
2286 TETHERING_ERROR_NOT_ENABLED,
2287 "tethering is not enabled\n");
2289 mobile_ap_type_e interface;
2290 __tethering_h *th = (__tethering_h *)tethering;
2291 __tethering_client_h client = {0, };
2294 gchar *hostname = NULL;
2295 guint timestamp = 0;
2296 GError *error = NULL;
2297 GVariant *result = NULL;
2298 GVariantIter *outer_iter = NULL;
2299 GVariantIter *inner_iter = NULL;
2300 GVariant *station = NULL;
2301 GVariant *value = NULL;
2304 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "get_station_info",
2305 NULL, G_DBUS_CALL_FLAGS_NONE,
2306 -1, th->cancellable, &error);
2309 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
2310 g_error_free(error);
2311 return TETHERING_ERROR_OPERATION_FAILED;
2314 g_variant_get(result, "(a(a{sv}))", &outer_iter);
2315 while (g_variant_iter_loop(outer_iter, "(@a{sv})", &station)) {
2316 g_variant_get(station, "a{sv}", &inner_iter);
2317 while (g_variant_iter_loop(inner_iter, "{sv}", &key, &value)) {
2318 if (g_strcmp0(key, "Type") == 0) {
2319 interface = g_variant_get_int32(value);
2320 if (interface == MOBILE_AP_TYPE_USB)
2321 client.interface = TETHERING_TYPE_USB;
2322 else if (interface == MOBILE_AP_TYPE_WIFI)
2323 client.interface = TETHERING_TYPE_WIFI;
2324 else if (interface == MOBILE_AP_TYPE_BT)
2325 client.interface = TETHERING_TYPE_BT;
2326 else if (interface == MOBILE_AP_TYPE_P2P)
2327 client.interface = TETHERING_TYPE_P2P;
2329 ERR("Invalid interface\n");
2331 g_variant_unref(value);
2334 DBG("interface is %d\n", client.interface);
2335 if (client.interface != type && (TETHERING_TYPE_ALL != type)) {
2337 g_variant_unref(value);
2340 } else if (g_strcmp0(key, "IP") == 0) {
2341 g_variant_get(value, "s", &ip);
2342 SDBG("ip is %s\n", ip);
2343 g_strlcpy(client.ip, ip, sizeof(client.ip));
2344 } else if (g_strcmp0(key, "MAC") == 0) {
2345 g_variant_get(value, "s", &mac);
2346 SDBG("mac is %s\n", mac);
2347 g_strlcpy(client.mac, mac, sizeof(client.mac));
2348 } else if (g_strcmp0(key, "Name") == 0) {
2349 g_variant_get(value, "s", &hostname);
2350 SDBG("hsotname is %s\n", hostname);
2352 client.hostname = g_strdup(hostname);
2353 } else if (g_strcmp0(key, "Time") == 0) {
2354 timestamp = g_variant_get_int32(value);
2355 DBG("timestamp is %d\n", timestamp);
2356 client.tm = (time_t)timestamp;
2358 ERR("Key %s not required\n", key);
2369 g_variant_iter_free(inner_iter);
2370 if (callback((tethering_client_h)&client, user_data) == false) {
2371 DBG("iteration is stopped\n");
2372 g_free(client.hostname);
2373 client.hostname = NULL;
2374 g_variant_iter_free(outer_iter);
2375 g_variant_unref(result);
2377 return TETHERING_ERROR_OPERATION_FAILED;
2379 g_free(client.hostname);
2380 client.hostname = NULL;
2382 g_variant_iter_free(outer_iter);
2383 g_variant_unref(result);
2385 return TETHERING_ERROR_NONE;
2390 * @brief Registers the callback function called when tethering is enabled.
2392 * @privlevel platform
2393 * @privilege http://tizen.org/privilege/tethering.admin
2394 * @param[in] tethering The handle of tethering
2395 * @param[in] type The type of tethering
2396 * @param[in] callback The callback function to invoke
2397 * @param[in] user_data The user data to be passed to the callback function
2398 * @retval #TETHERING_ERROR_NONE Successful
2399 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2400 * @see tethering_unset_enabled_cb()
2402 API int tethering_set_enabled_cb(tethering_h tethering, tethering_type_e type, tethering_enabled_cb callback, void *user_data)
2404 INFO("+ type: %d\n", type);
2405 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2406 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2407 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2408 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2410 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2411 "parameter(tethering) is NULL\n");
2412 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2413 "parameter(callback) is NULL\n");
2415 __tethering_h *th = (__tethering_h *)tethering;
2416 tethering_type_e ti;
2418 if (type != TETHERING_TYPE_ALL) {
2419 th->enabled_cb[type] = callback;
2420 th->enabled_user_data[type] = user_data;
2422 return TETHERING_ERROR_NONE;
2425 /* TETHERING_TYPE_ALL */
2426 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2427 th->enabled_cb[ti] = callback;
2428 th->enabled_user_data[ti] = user_data;
2432 return TETHERING_ERROR_NONE;
2437 * @brief Unregisters the callback function called when tethering is disabled.
2439 * @privlevel platform
2440 * @privilege http://tizen.org/privilege/tethering.admin
2441 * @param[in] tethering The handle of tethering
2442 * @param[in] type The type of tethering
2443 * @retval #TETHERING_ERROR_NONE Successful
2444 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2445 * @see tethering_set_enabled_cb()
2447 API int tethering_unset_enabled_cb(tethering_h tethering, tethering_type_e type)
2449 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2450 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2451 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2452 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2454 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2455 "parameter(tethering) is NULL\n");
2457 __tethering_h *th = (__tethering_h *)tethering;
2458 tethering_type_e ti;
2460 if (type != TETHERING_TYPE_ALL) {
2461 th->enabled_cb[type] = NULL;
2462 th->enabled_user_data[type] = NULL;
2464 return TETHERING_ERROR_NONE;
2467 /* TETHERING_TYPE_ALL */
2468 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2469 th->enabled_cb[ti] = NULL;
2470 th->enabled_user_data[ti] = NULL;
2473 return TETHERING_ERROR_NONE;
2478 * @brief Registers the callback function called when tethering is disabled.
2480 * @privlevel platform
2481 * @privilege http://tizen.org/privilege/tethering.admin
2482 * @param[in] tethering The handle of tethering
2483 * @param[in] type The type of tethering
2484 * @param[in] callback The callback function to invoke
2485 * @param[in] user_data The user data to be passed to the callback function
2486 * @retval #TETHERING_ERROR_NONE Successful
2487 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2488 * @see tethering_unset_disabled_cb()
2490 API int tethering_set_disabled_cb(tethering_h tethering, tethering_type_e type, tethering_disabled_cb callback, void *user_data)
2492 INFO("+ type: %d\n", type);
2493 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2494 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2495 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2496 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2498 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2499 "parameter(tethering) is NULL\n");
2500 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2501 "parameter(callback) is NULL\n");
2503 __tethering_h *th = (__tethering_h *)tethering;
2504 tethering_type_e ti;
2506 if (type != TETHERING_TYPE_ALL) {
2507 th->disabled_cb[type] = callback;
2508 th->disabled_user_data[type] = user_data;
2510 return TETHERING_ERROR_NONE;
2513 /* TETHERING_TYPE_ALL */
2514 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2515 th->disabled_cb[ti] = callback;
2516 th->disabled_user_data[ti] = user_data;
2519 return TETHERING_ERROR_NONE;
2524 * @brief Unregisters the callback function called when tethering is disabled.
2526 * @privlevel platform
2527 * @privilege http://tizen.org/privilege/tethering.admin
2528 * @param[in] tethering The handle of tethering
2529 * @param[in] type The type of tethering
2530 * @retval #TETHERING_ERROR_NONE Successful
2531 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2532 * @see tethering_set_disabled_cb()
2534 API int tethering_unset_disabled_cb(tethering_h tethering, tethering_type_e 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");
2544 __tethering_h *th = (__tethering_h *)tethering;
2545 tethering_type_e ti;
2547 if (type != TETHERING_TYPE_ALL) {
2548 th->disabled_cb[type] = NULL;
2549 th->disabled_user_data[type] = NULL;
2551 return TETHERING_ERROR_NONE;
2554 /* TETHERING_TYPE_ALL */
2555 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2556 th->disabled_cb[ti] = NULL;
2557 th->disabled_user_data[ti] = NULL;
2560 return TETHERING_ERROR_NONE;
2565 * @brief Registers the callback function called when the state of connection is changed.
2567 * @privlevel platform
2568 * @privilege http://tizen.org/privilege/tethering.admin
2569 * @param[in] tethering The handle of tethering
2570 * @param[in] type The type of tethering
2571 * @param[in] callback The callback function to invoke
2572 * @param[in] user_data The user data to be passed to the callback function
2573 * @retval #TETHERING_ERROR_NONE Successful
2574 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2575 * @see tethering_unset_connection_state_changed_cb_cb()
2577 API int tethering_set_connection_state_changed_cb(tethering_h tethering, tethering_type_e type, tethering_connection_state_changed_cb callback, void *user_data)
2579 INFO("+ type: %d\n", type);
2580 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2581 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2582 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2583 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2585 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2586 "parameter(tethering) is NULL\n");
2587 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2588 "parameter(callback) is NULL\n");
2590 __tethering_h *th = (__tethering_h *)tethering;
2591 tethering_type_e ti;
2593 if (type != TETHERING_TYPE_ALL) {
2594 th->changed_cb[type] = callback;
2595 th->changed_user_data[type] = user_data;
2597 return TETHERING_ERROR_NONE;
2600 /* TETHERING_TYPE_ALL */
2601 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2602 th->changed_cb[ti] = callback;
2603 th->changed_user_data[ti] = user_data;
2606 return TETHERING_ERROR_NONE;
2611 * @brief Unregisters the callback function called when the state of connection is changed.
2613 * @privlevel platform
2614 * @privilege http://tizen.org/privilege/tethering.admin
2615 * @param[in] tethering The handle of tethering
2616 * @param[in] type The type of tethering
2617 * @retval #TETHERING_ERROR_NONE Successful
2618 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2619 * @see tethering_set_connection_state_changed_cb()
2621 API int tethering_unset_connection_state_changed_cb(tethering_h tethering, tethering_type_e 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");
2631 __tethering_h *th = (__tethering_h *)tethering;
2632 tethering_type_e ti;
2634 if (type != TETHERING_TYPE_ALL) {
2635 th->changed_cb[type] = NULL;
2636 th->changed_user_data[type] = NULL;
2638 return TETHERING_ERROR_NONE;
2641 /* TETHERING_TYPE_ALL */
2642 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2643 th->changed_cb[ti] = NULL;
2644 th->changed_user_data[ti] = NULL;
2647 return TETHERING_ERROR_NONE;
2652 * @brief Registers the callback function called when the security type of Wi-Fi tethering is changed.
2654 * @privlevel platform
2655 * @privilege http://tizen.org/privilege/tethering.admin
2656 * @param[in] tethering The handle of tethering
2657 * @param[in] callback The callback function to invoke
2658 * @param[in] user_data The user data to be passed to the callback function
2659 * @retval #TETHERING_ERROR_NONE Successful
2660 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2661 * @see tethering_wifi_unset_security_type_changed_cb()
2663 API int tethering_wifi_set_security_type_changed_cb(tethering_h tethering, tethering_wifi_security_type_changed_cb callback, void *user_data)
2665 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2666 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2668 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2669 "parameter(tethering) is NULL\n");
2670 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2671 "parameter(callback) is NULL\n");
2673 __tethering_h *th = (__tethering_h *)tethering;
2675 th->security_type_changed_cb = callback;
2676 th->security_type_user_data = user_data;
2678 return TETHERING_ERROR_NONE;
2684 * @brief Unregisters the callback function called when the security type of Wi-Fi tethering is changed.
2686 * @privlevel platform
2687 * @privilege http://tizen.org/privilege/tethering.admin
2688 * @param[in] tethering The handle of tethering
2689 * @param[in] type The type of tethering
2690 * @retval #TETHERING_ERROR_NONE Successful
2691 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2692 * @see tethering_wifi_set_security_type_changed_cb()
2694 API int tethering_wifi_unset_security_type_changed_cb(tethering_h tethering)
2696 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2697 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2699 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2700 "parameter(tethering) is NULL\n");
2702 __tethering_h *th = (__tethering_h *)tethering;
2704 th->security_type_changed_cb = NULL;
2705 th->security_type_user_data = NULL;
2707 return TETHERING_ERROR_NONE;
2712 * @brief Registers the callback function called when the visibility of SSID is changed.
2714 * @privlevel platform
2715 * @privilege http://tizen.org/privilege/tethering.admin
2716 * @param[in] tethering The handle of tethering
2717 * @param[in] callback The callback function to invoke
2718 * @param[in] user_data The user data to be passed to the callback function
2719 * @retval #TETHERING_ERROR_NONE Successful
2720 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2721 * @see tethering_wifi_unset_ssid_visibility_changed_cb_cb()
2723 API int tethering_wifi_set_ssid_visibility_changed_cb(tethering_h tethering, tethering_wifi_ssid_visibility_changed_cb callback, void *user_data)
2725 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2726 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2728 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2729 "parameter(tethering) is NULL\n");
2730 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2731 "parameter(callback) is NULL\n");
2733 __tethering_h *th = (__tethering_h *)tethering;
2735 th->ssid_visibility_changed_cb = callback;
2736 th->ssid_visibility_user_data = user_data;
2738 return TETHERING_ERROR_NONE;
2743 * @brief Unregisters the callback function called when the visibility of SSID is changed.
2745 * @privlevel platform
2746 * @privilege http://tizen.org/privilege/tethering.admin
2747 * @param[in] tethering The handle of tethering
2748 * @retval #TETHERING_ERROR_NONE Successful
2749 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2750 * @see tethering_wifi_set_ssid_visibility_changed_cb()
2752 API int tethering_wifi_unset_ssid_visibility_changed_cb(tethering_h tethering)
2754 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2755 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2757 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2758 "parameter(tethering) is NULL\n");
2760 __tethering_h *th = (__tethering_h *)tethering;
2762 th->ssid_visibility_changed_cb = NULL;
2763 th->ssid_visibility_user_data = NULL;
2765 return TETHERING_ERROR_NONE;
2770 * @brief Registers the callback function called when the passphrase of Wi-Fi tethering is changed.
2772 * @privlevel platform
2773 * @privilege http://tizen.org/privilege/tethering.admin
2774 * @param[in] tethering The handle of tethering
2775 * @param[in] callback The callback function to invoke
2776 * @param[in] user_data The user data to be passed to the callback function
2777 * @retval #TETHERING_ERROR_NONE Successful
2778 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2779 * @see tethering_wifi_unset_passphrase_changed_cb()
2781 API int tethering_wifi_set_passphrase_changed_cb(tethering_h tethering, tethering_wifi_passphrase_changed_cb callback, void *user_data)
2783 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2784 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2786 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2787 "parameter(tethering) is NULL\n");
2788 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2789 "parameter(callback) is NULL\n");
2791 __tethering_h *th = (__tethering_h *)tethering;
2793 th->passphrase_changed_cb = callback;
2794 th->passphrase_user_data = user_data;
2796 return TETHERING_ERROR_NONE;
2801 * @brief Unregisters the callback function called when the passphrase of Wi-Fi tethering is changed.
2803 * @privlevel platform
2804 * @privilege http://tizen.org/privilege/tethering.admin
2805 * @param[in] tethering The handle of tethering
2806 * @retval #TETHERING_ERROR_NONE Successful
2807 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2808 * @see tethering_wifi_set_passphrase_changed_cb()
2810 API int tethering_wifi_unset_passphrase_changed_cb(tethering_h tethering)
2812 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2813 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2815 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2816 "parameter(tethering) is NULL\n");
2818 __tethering_h *th = (__tethering_h *)tethering;
2820 th->passphrase_changed_cb = NULL;
2821 th->passphrase_user_data = NULL;
2823 return TETHERING_ERROR_NONE;
2828 * @brief Sets the security type of Wi-Fi tethering.
2830 * @privlevel platform
2831 * @privilege http://tizen.org/privilege/tethering.admin
2832 * @remarks This change is applied next time Wi-Fi tethering is enabled
2833 * @param[in] tethering The handle of tethering
2834 * @param[in] type The security type
2835 * @return 0 on success, otherwise negative error value.
2836 * @retval #TETHERING_ERROR_NONE Successful
2837 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2838 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2839 * @see tethering_wifi_get_security_type()
2841 API int tethering_wifi_set_security_type(tethering_h tethering, tethering_wifi_security_type_e type)
2843 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2844 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2846 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2847 "parameter(tethering) is NULL\n");
2849 __tethering_h *th = (__tethering_h *)tethering;
2850 tethering_error_e ret = TETHERING_ERROR_NONE;
2851 char *sec_str = NULL;
2853 ret = __set_security_type(type);
2854 if (ret == TETHERING_ERROR_NONE) {
2856 case TETHERING_WIFI_SECURITY_TYPE_NONE:
2857 sec_str = TETHERING_WIFI_SECURITY_TYPE_OPEN_STR;
2859 case TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK:
2860 sec_str = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR;
2862 case TETHERING_WIFI_SECURITY_TYPE_WPS:
2863 sec_str = TETHERING_WIFI_SECURITY_TYPE_WPS_STR;
2865 case TETHERING_WIFI_SECURITY_TYPE_SAE:
2866 sec_str = TETHERING_WIFI_SECURITY_TYPE_SAE_STR;
2870 __send_dbus_signal(th->client_bus,
2871 SIGNAL_NAME_SECURITY_TYPE_CHANGED, sec_str);
2878 * @brief Gets the security type of Wi-Fi tethering.
2880 * @privlevel platform
2881 * @privilege http://tizen.org/privilege/tethering.admin
2882 * @param[in] tethering The handle of tethering
2883 * @param[out] type The security type
2884 * @return 0 on success, otherwise negative error value.
2885 * @retval #TETHERING_ERROR_NONE Successful
2886 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2887 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2888 * @see tethering_wifi_set_security_type()
2890 API int tethering_wifi_get_security_type(tethering_h tethering, tethering_wifi_security_type_e *type)
2892 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2893 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2895 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2896 "parameter(tethering) is NULL\n");
2897 _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2898 "parameter(type) is NULL\n");
2900 return __get_security_type(type);
2905 * @brief Sets the SSID (service set identifier).
2907 * @privlevel platform
2908 * @privilege http://tizen.org/privilege/tethering.admin
2909 * @details If SSID is not set, Device name is used as SSID
2910 * @remarks This change is applied next time Wi-Fi tethering is enabled with same @a tethering handle
2911 * @param[in] tethering The handle of tethering
2912 * @param[out] ssid The SSID
2913 * @return 0 on success, otherwise negative error value.
2914 * @retval #TETHERING_ERROR_NONE Successful
2915 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2916 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2918 API int tethering_wifi_set_ssid(tethering_h tethering, const char *ssid)
2920 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2921 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2923 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2924 "parameter(tethering) is NULL\n");
2925 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2926 "parameter(ssid) is NULL\n");
2928 __tethering_h *th = (__tethering_h *)tethering;
2929 char *p_ssid = NULL;
2932 ssid_len = strlen(ssid);
2933 if (ssid_len > TETHERING_WIFI_SSID_MAX_LEN) {
2934 ERR("parameter(ssid) is too long");
2935 return TETHERING_ERROR_INVALID_PARAMETER;
2938 p_ssid = strdup(ssid);
2939 _retvm_if(p_ssid == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2940 "strdup is failed\n");
2946 return TETHERING_ERROR_NONE;
2951 * @brief Gets the SSID (service set identifier).
2953 * @privlevel platform
2954 * @privilege http://tizen.org/privilege/tethering.admin
2955 * @remarks @a ssid must be released with free() by you.
2956 * @param[in] tethering The handle of tethering
2957 * @param[out] ssid The SSID
2958 * @return 0 on success, otherwise negative error value.
2959 * @retval #TETHERING_ERROR_NONE Successful
2960 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2961 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2962 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2964 API int tethering_wifi_get_ssid(tethering_h tethering, char **ssid)
2966 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2967 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2969 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2970 "parameter(tethering) is NULL\n");
2971 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2972 "parameter(ssid) is NULL\n");
2975 __tethering_h *th = (__tethering_h *)tethering;
2976 char val[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
2978 if (!tethering_is_enabled(NULL, TETHERING_TYPE_WIFI)) {
2979 if (th->ssid != NULL) {
2980 DBG("Private SSID is set\n");
2981 *ssid = strdup(th->ssid);
2983 if (__get_ssid_from_vconf(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
2984 val, sizeof(val)) == false) {
2985 return TETHERING_ERROR_OPERATION_FAILED;
2987 *ssid = strdup(val);
2990 if (__get_ssid_from_vconf(VCONFKEY_MOBILE_HOTSPOT_SSID,
2991 val, sizeof(val)) == false) {
2992 return TETHERING_ERROR_OPERATION_FAILED;
2994 *ssid = strdup(val);
2997 if (*ssid == NULL) {
2998 ERR("strdup is failed\n");
2999 return TETHERING_ERROR_OUT_OF_MEMORY;
3002 return TETHERING_ERROR_NONE;
3007 * @brief Sets the visibility of SSID(service set identifier).
3009 * @privlevel platform
3010 * @privilege http://tizen.org/privilege/tethering.admin
3011 * @details If you set the visibility invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
3012 * @remarks This change is applied next time Wi-Fi tethering is enabled
3013 * @param[in] tethering The handle of tethering
3014 * @param[in] visible The visibility of SSID: (@c true = visible, @c false = invisible)
3015 * @return 0 on success, otherwise negative error value.
3016 * @retval #TETHERING_ERROR_NONE Successful
3017 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3018 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3019 * @see tethering_wifi_get_ssid_visibility()
3021 API int tethering_wifi_set_ssid_visibility(tethering_h tethering, bool visible)
3023 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3024 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3026 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3027 "parameter(tethering) is NULL\n");
3029 __tethering_h *th = (__tethering_h *)tethering;
3030 tethering_error_e ret = TETHERING_ERROR_NONE;
3032 ret = __set_visible(visible);
3033 if (ret == TETHERING_ERROR_NONE) {
3034 __send_dbus_signal(th->client_bus,
3035 SIGNAL_NAME_SSID_VISIBILITY_CHANGED,
3036 visible ? SIGNAL_MSG_SSID_VISIBLE :
3037 SIGNAL_MSG_SSID_HIDE);
3044 * @brief Gets the visibility of SSID(service set identifier).
3046 * @privlevel platform
3047 * @privilege http://tizen.org/privilege/tethering.admin
3048 * @details If the visibility is set invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
3049 * @param[in] tethering The handle of tethering
3050 * @param[out] visible The visibility of SSID: (@c true = visible, @c false = invisible)
3051 * @return 0 on success, otherwise negative error value.
3052 * @retval #TETHERING_ERROR_NONE Successful
3053 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3054 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3055 * @see tethering_wifi_set_ssid_visibility()
3057 API int tethering_wifi_get_ssid_visibility(tethering_h tethering, bool *visible)
3059 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3060 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3062 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3063 "parameter(tethering) is NULL\n");
3064 _retvm_if(visible == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3065 "parameter(visible) is NULL\n");
3067 return __get_visible(visible);
3072 * @brief Sets the passphrase.
3074 * @privlevel platform
3075 * @privilege http://tizen.org/privilege/tethering.admin
3076 * @remarks This change is applied next time Wi-Fi tethering is enabled
3077 * @param[in] tethering The handle of tethering
3078 * @param[in] passphrase The passphrase
3079 * @return 0 on success, otherwise negative error value.
3080 * @retval #TETHERING_ERROR_NONE Successful
3081 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3082 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3083 * @see tethering_wifi_get_passphrase()
3085 API int tethering_wifi_set_passphrase(tethering_h tethering, const char *passphrase)
3087 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3088 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3090 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3091 "parameter(tethering) is NULL\n");
3092 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3093 "parameter(passphrase) is NULL\n");
3095 __tethering_h *th = (__tethering_h *)tethering;
3096 GDBusProxy *proxy = th->client_bus_proxy;
3097 GVariant *parameters;
3098 GError *error = NULL;
3099 int passphrase_len = 0;
3103 passphrase_len = strlen(passphrase);
3104 if (passphrase_len < TETHERING_WIFI_KEY_MIN_LEN ||
3105 passphrase_len > TETHERING_WIFI_KEY_MAX_LEN) {
3106 ERR("parameter(passphrase) is too short or long\n");
3107 return TETHERING_ERROR_INVALID_PARAMETER;
3110 parameters = g_dbus_proxy_call_sync(proxy, "set_wifi_tethering_passphrase",
3111 g_variant_new("(s)", passphrase), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3114 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3116 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3117 ret = TETHERING_ERROR_PERMISSION_DENIED;
3119 ret = TETHERING_ERROR_OPERATION_FAILED;
3121 g_error_free(error);
3125 g_variant_get(parameters, "(u)", &ret);
3126 g_variant_unref(parameters);
3128 if (ret == TETHERING_ERROR_NONE) {
3129 __send_dbus_signal(th->client_bus,
3130 SIGNAL_NAME_PASSPHRASE_CHANGED, NULL);
3139 * @brief Gets the passphrase.
3141 * @privlevel platform
3142 * @privilege http://tizen.org/privilege/tethering.admin
3143 * @remarks @a passphrase must be released with free() by you.
3144 * @param[in] tethering The handle of tethering
3145 * @param[out] passphrase The passphrase
3146 * @return 0 on success, otherwise negative error value.
3147 * @retval #TETHERING_ERROR_NONE Successful
3148 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3149 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
3150 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3151 * @see tethering_wifi_set_passphrase()
3153 API int tethering_wifi_get_passphrase(tethering_h tethering, char **passphrase)
3155 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3156 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3158 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3159 "parameter(tethering) is NULL\n");
3160 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3161 "parameter(passphrase) is NULL\n");
3163 __tethering_h *th = (__tethering_h *)tethering;
3164 GDBusProxy *proxy = th->client_bus_proxy;
3165 GVariant *parameters;
3166 GError *error = NULL;
3167 unsigned int len = 0;
3168 tethering_error_e ret = TETHERING_ERROR_NONE;
3170 parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_passphrase",
3171 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3174 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3176 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3177 ret = TETHERING_ERROR_PERMISSION_DENIED;
3179 ret = TETHERING_ERROR_OPERATION_FAILED;
3181 g_error_free(error);
3185 if (parameters != NULL) {
3186 g_variant_get(parameters, "(siu)", passphrase, &len, &ret);
3187 g_variant_unref(parameters);
3190 return TETHERING_ERROR_NONE;
3193 API int tethering_wifi_set_channel(tethering_h tethering, int channel)
3195 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3196 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3198 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3199 "parameter(tethering) is NULL\n");
3201 __tethering_h *th = (__tethering_h *)tethering;
3202 th->channel = channel;
3204 return TETHERING_ERROR_NONE;
3207 API int tethering_wifi_get_channel(tethering_h tethering, int *channel)
3209 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3210 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3212 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3213 "parameter(tethering) is NULL\n");
3215 _retvm_if(channel == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3216 "parameter(channel) is NULL\n");
3218 __tethering_h *th = (__tethering_h *)tethering;
3219 *channel = th->channel;
3221 return TETHERING_ERROR_NONE;
3224 API int tethering_wifi_set_mode(tethering_h tethering, tethering_wifi_mode_type_e type)
3226 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3227 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3229 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3230 "parameter(tethering) is NULL\n");
3232 __tethering_h *th = (__tethering_h *)tethering;
3234 th->mode_type = type;
3236 return TETHERING_ERROR_NONE;
3239 API int tethering_wifi_get_mode(tethering_h tethering, tethering_wifi_mode_type_e *type)
3241 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3242 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3244 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3245 "parameter(tethering) is NULL\n");
3246 _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3247 "parameter(type) is NULL\n");
3249 __tethering_h *th = (__tethering_h *)tethering;
3250 *type = th->mode_type;
3252 return TETHERING_ERROR_NONE;
3258 * @brief Reload the settings (SSID / Passphrase / Security type / SSID visibility).
3260 * @privlevel platform
3261 * @privilege http://tizen.org/privilege/tethering.admin
3262 * @remarks Connected devices via Wi-Fi tethering or MobileAP will be disconnected when the settings are reloaded
3263 * @param[in] tethering The handle of tethering
3264 * @param[in] callback The callback function to invoke
3265 * @param[in] user_data The user data to be passed to the callback function
3266 * @return 0 on success, otherwise negative error value.
3267 * @retval #TETHERING_ERROR_NONE Successful
3268 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3269 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3271 API int tethering_wifi_reload_settings(tethering_h tethering, tethering_wifi_settings_reloaded_cb callback, void *user_data)
3274 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3275 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3277 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3278 "parameter(tethering) is NULL\n");
3279 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3280 "parameter(callback) is NULL\n");
3282 __tethering_h *th = (__tethering_h *)tethering;
3283 _softap_settings_t set = {"", "", "", 0, false};
3284 GDBusProxy *proxy = th->client_bus_proxy;
3289 if (th->settings_reloaded_cb) {
3290 ERR("Operation in progress\n");
3291 return TETHERING_ERROR_OPERATION_FAILED;
3294 ret = __prepare_wifi_settings(tethering, &set);
3295 if (ret != TETHERING_ERROR_NONE) {
3296 ERR("softap settings initialization failed\n");
3297 return TETHERING_ERROR_OPERATION_FAILED;
3300 th->settings_reloaded_cb = callback;
3301 th->settings_reloaded_user_data = user_data;
3303 g_dbus_proxy_call(proxy, "reload_wifi_settings",
3304 g_variant_new("(sssiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type),
3305 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
3306 (GAsyncReadyCallback) __settings_reloaded_cb, (gpointer)tethering);
3308 return TETHERING_ERROR_NONE;
3311 API int tethering_wifi_set_mac_filter(tethering_h tethering, bool mac_filter)
3313 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3314 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3316 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3317 "parameter(tethering) is NULL\n");
3319 __tethering_h *th = (__tethering_h *)tethering;
3320 th->mac_filter = mac_filter;
3322 return TETHERING_ERROR_NONE;
3325 API int tethering_wifi_get_mac_filter(tethering_h tethering, bool *mac_filter)
3327 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3328 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3330 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3331 "parameter(mac_filter) is NULL\n");
3332 _retvm_if(mac_filter == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3333 "parameter(mac_filter) is NULL\n");
3335 __tethering_h *th = (__tethering_h *)tethering;
3336 *mac_filter = th->mac_filter;
3338 return TETHERING_ERROR_NONE;
3341 static int __add_mac_to_file(const char *filepath, const char *mac)
3344 char line[MAX_BUF_SIZE] = "\0";
3345 bool mac_exist = false;
3348 fp = fopen(filepath, "a+");
3350 ERR("fopen is failed\n");
3351 return TETHERING_ERROR_OPERATION_FAILED;
3354 while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
3355 if (strncmp(mac, line, 17) == 0) {
3356 DBG("MAC %s already exist in the list\n", mac);
3363 p_mac = strdup(mac);
3364 if (p_mac == NULL) {
3365 ERR("strdup failed\n");
3367 return TETHERING_ERROR_OUT_OF_MEMORY;
3370 fprintf(fp, "%s\n", mac);
3372 if ((strcmp(filepath, ALLOWED_LIST) == 0))
3373 allowed_list = g_slist_append(allowed_list, p_mac);
3374 else if ((strcmp(filepath, BLOCKED_LIST) == 0))
3375 blocked_list = g_slist_append(blocked_list, p_mac);
3382 return TETHERING_ERROR_NONE;
3385 static int __remove_mac_from_file(const char *filepath, const char *mac)
3389 char line[MAX_BUF_SIZE] = "\0";
3391 fp = fopen(filepath, "r");
3393 ERR("fopen is failed\n");
3394 return TETHERING_ERROR_OPERATION_FAILED;
3397 fp1 = fopen(TEMP_LIST, "w+");
3400 ERR("fopen is failed\n");
3401 return TETHERING_ERROR_OPERATION_FAILED;
3404 while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
3405 if (strncmp(mac, line, 17) == 0) {
3406 DBG("MAC %s found in the list\n", mac);
3408 if ((strcmp(filepath, ALLOWED_LIST) == 0)) {
3409 GSList *list = NULL;
3410 for (list = allowed_list; list != NULL; list = list->next) {
3411 char *p_mac = (char *)list->data;
3412 if (strncmp(mac, p_mac, strlen(mac)) == 0)
3413 allowed_list = g_slist_remove(allowed_list, p_mac);
3415 } else if ((strcmp(filepath, BLOCKED_LIST) == 0)) {
3416 GSList *list = NULL;
3417 for (list = blocked_list; list != NULL; list = list->next) {
3418 char *p_mac = (char *)list->data;
3419 if (strncmp(mac, p_mac, strlen(mac)) == 0)
3420 blocked_list = g_slist_remove(blocked_list, p_mac);
3424 fprintf(fp1, "%s", line);
3431 if ((strcmp(filepath, ALLOWED_LIST) == 0)) {
3432 if (rename(TEMP_LIST, ALLOWED_LIST) != 0) {
3433 ERR("rename is failed (%s -> %s)", TEMP_LIST, ALLOWED_LIST);
3434 return TETHERING_ERROR_OPERATION_FAILED;
3436 } else if ((strcmp(filepath, BLOCKED_LIST) == 0)) {
3437 if (rename(TEMP_LIST, BLOCKED_LIST) != 0) {
3438 ERR("rename is failed (%s -> %s)", TEMP_LIST, BLOCKED_LIST);
3439 return TETHERING_ERROR_OPERATION_FAILED;
3443 return TETHERING_ERROR_NONE;
3446 API int tethering_wifi_add_allowed_mac_list(tethering_h tethering, const char *mac)
3448 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3449 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3451 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3452 "parameter(tethering) is NULL\n");
3453 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3454 "parameter(mac) is NULL\n");
3456 return __add_mac_to_file(ALLOWED_LIST, mac);
3459 API int tethering_wifi_remove_allowed_mac_list(tethering_h tethering, const char *mac)
3461 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3462 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3464 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3465 "parameter(tethering) is NULL\n");
3466 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3467 "parameter(mac) is NULL\n");
3469 return __remove_mac_from_file(ALLOWED_LIST, mac);
3472 API int tethering_wifi_get_allowed_mac_list(tethering_h tethering, void **allowed_mac_list)
3474 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3475 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3477 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3478 "parameter(tethering) is NULL\n");
3479 _retvm_if(allowed_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3480 "parameter(allowed_mac_list) is NULL\n");
3482 *allowed_mac_list = g_slist_copy(allowed_list);
3483 return TETHERING_ERROR_NONE;
3486 API int tethering_wifi_add_blocked_mac_list(tethering_h tethering, const char *mac)
3488 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3489 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3491 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3492 "parameter(tethering) is NULL\n");
3493 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3494 "parameter(mac) is NULL\n");
3496 return __add_mac_to_file(BLOCKED_LIST, mac);
3499 API int tethering_wifi_remove_blocked_mac_list(tethering_h tethering, const char *mac)
3501 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3502 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3504 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3505 "parameter(tethering) is NULL\n");
3506 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3507 "parameter(mac) is NULL\n");
3509 return __remove_mac_from_file(BLOCKED_LIST, mac);
3512 API int tethering_wifi_get_blocked_mac_list(tethering_h tethering, void **blocked_mac_list)
3514 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3515 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3517 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3518 "parameter(tethering) is NULL\n");
3519 _retvm_if(blocked_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3520 "parameter(blocked_mac_list) is NULL\n");
3522 *blocked_mac_list = g_slist_copy(blocked_list);
3523 return TETHERING_ERROR_NONE;
3526 API int tethering_wifi_enable_dhcp(tethering_h tethering, bool enable)
3528 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3529 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3531 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3532 "parameter(tethering) is NULL\n");
3534 GVariant *parameters;
3535 GError *error = NULL;
3538 __tethering_h *th = (__tethering_h *)tethering;
3540 GDBusProxy *proxy = th->client_bus_proxy;
3542 parameters = g_dbus_proxy_call_sync(proxy, "enable_dhcp",
3543 g_variant_new("(b)", enable),
3544 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3547 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3548 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3549 result = TETHERING_ERROR_PERMISSION_DENIED;
3551 result = TETHERING_ERROR_OPERATION_FAILED;
3553 g_error_free(error);
3554 th->dhcp_enabled = false;
3559 g_variant_get(parameters, "(u)", &result);
3560 g_variant_unref(parameters);
3563 th->dhcp_enabled = true;
3565 th->dhcp_enabled = false;
3567 return TETHERING_ERROR_NONE;
3570 API int tethering_wifi_set_dhcp_range(tethering_h tethering, char *rangestart, char *rangestop)
3572 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3573 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3575 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3576 "parameter(tethering) is NULL\n");
3577 _retvm_if(rangestart == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3578 "parameter(rangestart) is NULL\n");
3579 _retvm_if(rangestop == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3580 "parameter(rangestop) is NULL\n");
3582 GVariant *parameters;
3583 GError *error = NULL;
3586 __tethering_h *th = (__tethering_h *)tethering;
3588 GDBusProxy *proxy = th->client_bus_proxy;
3590 parameters = g_dbus_proxy_call_sync(proxy, "dhcp_range",
3591 g_variant_new("(ss)", rangestart, rangestop),
3592 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3594 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3596 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3597 result = TETHERING_ERROR_PERMISSION_DENIED;
3599 result = TETHERING_ERROR_OPERATION_FAILED;
3601 g_error_free(error);
3602 th->dhcp_enabled = false;
3607 g_variant_get(parameters, "(u)", &result);
3608 g_variant_unref(parameters);
3610 th->dhcp_enabled = true;
3612 return TETHERING_ERROR_NONE;
3615 API int tethering_wifi_is_dhcp_enabled(tethering_h tethering, bool *dhcp_enabled)
3617 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3618 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3620 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3621 "parameter(tethering) is NULL\n");
3622 _retvm_if(dhcp_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3623 "parameter(dhcp_enabled) is NULL\n");
3625 __tethering_h *th = (__tethering_h *)tethering;
3626 *dhcp_enabled = th->dhcp_enabled;
3628 return TETHERING_ERROR_NONE;
3631 API int tethering_wifi_set_txpower(tethering_h tethering, unsigned int txpower)
3633 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3634 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3636 GError *error = NULL;
3638 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3639 "parameter(tethering) is NULL\n");
3640 _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false,
3641 TETHERING_ERROR_NOT_ENABLED,
3642 "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
3643 __tethering_h *th = (__tethering_h *)tethering;
3645 g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_set_txpower",
3646 g_variant_new("(u)", txpower),
3647 G_DBUS_CALL_FLAGS_NONE,
3648 -1, th->cancellable, &error);
3650 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
3651 g_clear_error(&error);
3652 return TETHERING_ERROR_OPERATION_FAILED;
3654 return TETHERING_ERROR_NONE;
3657 API int tethering_wifi_get_txpower(tethering_h tethering, unsigned int *txpower)
3659 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3660 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3662 GError *error = NULL;
3663 GVariant *result = NULL;
3665 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3666 "parameter(tethering) is NULL\n");
3667 _retvm_if(txpower == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3668 "parameter(txpower) is NULL\n");
3669 _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false,
3670 TETHERING_ERROR_NOT_ENABLED,
3671 "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
3673 __tethering_h *th = (__tethering_h *)tethering;
3675 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_get_txpower",
3677 G_DBUS_CALL_FLAGS_NONE,
3678 -1, th->cancellable, &error);
3680 if (result != NULL) {
3681 g_variant_get(result, "(u)", txpower);
3682 g_variant_unref(result);
3685 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
3686 g_clear_error(&error);
3687 return TETHERING_ERROR_OPERATION_FAILED;
3689 g_clear_error(&error);
3690 return TETHERING_ERROR_NONE;
3693 API int tethering_wifi_set_mtu(tethering_h tethering, unsigned int mtu)
3695 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3696 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3698 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3699 "parameter(tethering) is NULL\n");
3701 GVariant *parameters;
3702 GError *error = NULL;
3705 __tethering_h *th = (__tethering_h *)tethering;
3707 GDBusProxy *proxy = th->client_bus_proxy;
3709 parameters = g_dbus_proxy_call_sync(proxy, "set_mtu",
3710 g_variant_new("(u)", mtu),
3711 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3713 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3715 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3716 result = TETHERING_ERROR_PERMISSION_DENIED;
3718 result = TETHERING_ERROR_OPERATION_FAILED;
3720 g_error_free(error);
3724 g_variant_get(parameters, "(u)", &result);
3726 g_variant_unref(parameters);
3728 return TETHERING_ERROR_NONE;
3731 API int tethering_wifi_change_mac(tethering_h tethering, char *mac)
3733 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3734 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3736 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3737 "parameter(tethering) is NULL\n");
3738 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3739 "parameter(mac) is NULL\n");
3741 GVariant *parameters;
3742 GError *error = NULL;
3745 __tethering_h *th = (__tethering_h *)tethering;
3747 GDBusProxy *proxy = th->client_bus_proxy;
3749 parameters = g_dbus_proxy_call_sync(proxy, "change_mac",
3750 g_variant_new("(s)", mac),
3751 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3753 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3755 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3756 result = TETHERING_ERROR_PERMISSION_DENIED;
3758 result = TETHERING_ERROR_OPERATION_FAILED;
3760 g_error_free(error);
3764 g_variant_get(parameters, "(u)", &result);
3765 g_variant_unref(parameters);
3767 if (result == MOBILE_AP_ERROR_NOT_PERMITTED)
3768 return TETHERING_ERROR_NOT_SUPPORT_API;
3770 return TETHERING_ERROR_NONE;
3773 API int tethering_wifi_set_max_connected_device(tethering_h tethering, int max_device)
3775 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3776 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3778 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3779 "parameter(tethering) is NULL\n");
3781 __tethering_h *th = (__tethering_h *)tethering;
3783 th->wifi_max_connected = max_device;
3785 return TETHERING_ERROR_NONE;
3788 API int tethering_wifi_get_max_connected_device(tethering_h tethering, int *max_device)
3790 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3791 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3793 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3794 "parameter(tethering) is NULL\n");
3795 _retvm_if(max_device == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3796 "parameter(max_device) is NULL\n");
3798 __tethering_h *th = (__tethering_h *)tethering;
3800 *max_device = th->wifi_max_connected;
3801 return TETHERING_ERROR_NONE;
3804 API int tethering_wifi_enable_port_forwarding(tethering_h tethering, bool enable)
3806 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3807 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3809 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3810 "parameter(tethering) is NULL\n");
3812 GVariant *parameters;
3813 GError *error = NULL;
3816 __tethering_h *th = (__tethering_h *)tethering;
3818 GDBusProxy *proxy = th->client_bus_proxy;
3820 parameters = g_dbus_proxy_call_sync(proxy, "enable_port_forwarding",
3821 g_variant_new("(b)", enable),
3822 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3824 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3826 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3827 result = TETHERING_ERROR_PERMISSION_DENIED;
3829 result = TETHERING_ERROR_OPERATION_FAILED;
3831 g_error_free(error);
3835 g_variant_get(parameters, "(u)", &result);
3836 g_variant_unref(parameters);
3838 th->port_forwarding = true;
3840 return TETHERING_ERROR_NONE;
3843 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)
3845 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3846 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3848 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3849 "parameter(tethering) is NULL\n");
3850 _retvm_if(ifname == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3851 "parameter(ifname) is NULL\n");
3852 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3853 "parameter(protocol) is NULL\n");
3854 _retvm_if(org_ip == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3855 "parameter(org_ip) is NULL\n");
3856 _retvm_if(final_ip == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3857 "parameter(final_ip) is NULL\n");
3859 GVariant *parameters;
3860 GError *error = NULL;
3862 char cmd[MAX_BUF_SIZE] = { 0, };
3865 __tethering_h *th = (__tethering_h *)tethering;
3867 GDBusProxy *proxy = th->client_bus_proxy;
3869 parameters = g_dbus_proxy_call_sync(proxy, "add_port_forwarding_rule",
3870 g_variant_new("(sssisi)", ifname, protocol, org_ip, org_port, final_ip, final_port),
3871 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);
3884 g_variant_get(parameters, "(u)", &result);
3885 g_variant_unref(parameters);
3887 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);
3891 ERR("strdup failed\n");
3892 return TETHERING_ERROR_OUT_OF_MEMORY;
3895 port_forwarding = g_slist_append(port_forwarding, list);
3897 return TETHERING_ERROR_NONE;
3900 API int tethering_wifi_reset_port_forwarding_rule(tethering_h tethering)
3902 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3903 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3905 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3906 "parameter(tethering) is NULL\n");
3908 GVariant *parameters;
3909 GError *error = NULL;
3912 __tethering_h *th = (__tethering_h *)tethering;
3914 GDBusProxy *proxy = th->client_bus_proxy;
3916 parameters = g_dbus_proxy_call_sync(proxy, "reset_port_forwarding_rule",
3917 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3919 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3921 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3922 result = TETHERING_ERROR_PERMISSION_DENIED;
3924 result = TETHERING_ERROR_OPERATION_FAILED;
3926 g_error_free(error);
3930 g_variant_get(parameters, "(u)", &result);
3932 g_variant_unref(parameters);
3934 return TETHERING_ERROR_NONE;
3937 API int tethering_wifi_is_port_forwarding_enabled(tethering_h tethering, bool *forwarding_enabled)
3939 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3940 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3942 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3943 "parameter(tethering) is NULL\n");
3944 _retvm_if(forwarding_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3945 "parameter(forwarding_enabled) is NULL\n");
3947 __tethering_h *th = (__tethering_h *)tethering;
3949 *forwarding_enabled = th->port_forwarding;
3951 return TETHERING_ERROR_NONE;
3954 API int tethering_wifi_get_port_forwarding_rule(tethering_h tethering, void **port_forwarding_list)
3956 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3957 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3959 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3960 "parameter(tethering) is NULL\n");
3961 _retvm_if(port_forwarding_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3962 "parameter(port_forwarding_list) is NULL\n");
3964 *port_forwarding_list = g_slist_copy(port_forwarding);
3965 return TETHERING_ERROR_NONE;
3968 API int tethering_wifi_enable_port_filtering(tethering_h tethering, bool enable)
3970 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3971 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3973 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3974 "parameter(tethering) is NULL\n");
3976 GVariant *parameters;
3977 GError *error = NULL;
3980 __tethering_h *th = (__tethering_h *)tethering;
3982 GDBusProxy *proxy = th->client_bus_proxy;
3984 parameters = g_dbus_proxy_call_sync(proxy, "enable_port_filtering",
3985 g_variant_new("(b)", enable),
3986 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3988 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3990 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3991 result = TETHERING_ERROR_PERMISSION_DENIED;
3993 result = TETHERING_ERROR_OPERATION_FAILED;
3995 g_error_free(error);
3999 g_variant_get(parameters, "(u)", &result);
4000 g_variant_unref(parameters);
4002 th->port_filtering = true;
4004 return TETHERING_ERROR_NONE;
4007 API int tethering_wifi_add_port_filtering_rule(tethering_h tethering, int port, char *protocol, bool allow)
4009 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4010 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4012 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4013 "parameter(tethering) is NULL\n");
4014 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4015 "parameter(protocol) is NULL\n");
4017 GVariant *parameters;
4018 GError *error = NULL;
4023 __tethering_h *th = (__tethering_h *)tethering;
4025 GDBusProxy *proxy = th->client_bus_proxy;
4027 parameters = g_dbus_proxy_call_sync(proxy, "add_port_filtering_rule",
4028 g_variant_new("(isb)", port, protocol, allow),
4029 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4031 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4033 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4034 result = TETHERING_ERROR_PERMISSION_DENIED;
4036 result = TETHERING_ERROR_OPERATION_FAILED;
4038 g_error_free(error);
4042 g_variant_get(parameters, "(u)", &result);
4043 g_variant_unref(parameters);
4046 ret = asprintf(&list, "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_ACCEPT);
4048 ret = asprintf(&list, "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_DROP);
4050 if (ret == -1 || list == NULL) {
4051 ERR("asprintf failed\n");
4052 return TETHERING_ERROR_OUT_OF_MEMORY;
4055 DBG("cmd:%s", list);
4057 port_filtering = g_slist_append(port_filtering, list);
4059 return TETHERING_ERROR_NONE;
4062 API int tethering_wifi_add_custom_port_filtering_rule(tethering_h tethering, int port1, int port2, char *protocol, bool allow)
4064 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4065 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4067 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4068 "parameter(tethering) is NULL\n");
4069 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4070 "parameter(protocol) is NULL\n");
4072 GVariant *parameters;
4073 GError *error = NULL;
4078 __tethering_h *th = (__tethering_h *)tethering;
4080 GDBusProxy *proxy = th->client_bus_proxy;
4082 parameters = g_dbus_proxy_call_sync(proxy, "add_custom_port_filtering_rule",
4083 g_variant_new("(iisb)", port1, port2, protocol, allow),
4084 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4086 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4088 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4089 result = TETHERING_ERROR_PERMISSION_DENIED;
4091 result = TETHERING_ERROR_OPERATION_FAILED;
4093 g_error_free(error);
4097 g_variant_get(parameters, "(u)", &result);
4098 g_variant_unref(parameters);
4101 ret = asprintf(&list, "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_ACCEPT);
4103 ret = asprintf(&list, "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_DROP);
4105 if (ret == -1 || list == NULL) {
4106 ERR("asprintf failed\n");
4107 return TETHERING_ERROR_OUT_OF_MEMORY;
4110 DBG("cmd:%s", list);
4112 custom_port_filtering = g_slist_append(custom_port_filtering, list);
4114 return TETHERING_ERROR_NONE;
4117 API int tethering_wifi_get_port_filtering_rule(tethering_h tethering, void **port_filtering_list)
4119 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4120 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4122 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4123 "parameter(tethering) is NULL\n");
4124 _retvm_if(port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4125 "parameter(port_filtering_list) is NULL\n");
4127 *port_filtering_list = g_slist_copy(port_filtering);
4128 return TETHERING_ERROR_NONE;
4131 API int tethering_wifi_get_custom_port_filtering_rule(tethering_h tethering, void **custom_port_filtering_list)
4133 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4134 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4136 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4137 "parameter(tethering) is NULL\n");
4138 _retvm_if(custom_port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4139 "parameter(custom_port_filtering_list) is NULL\n");
4141 *custom_port_filtering_list = g_slist_copy(custom_port_filtering);
4142 return TETHERING_ERROR_NONE;
4145 API int tethering_wifi_is_port_filtering_enabled(tethering_h tethering, bool *filtering_enabled)
4147 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4148 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4150 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4151 "parameter(tethering) is NULL\n");
4152 _retvm_if(filtering_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4153 "parameter(filtering_enabled) is NULL\n");
4155 __tethering_h *th = (__tethering_h *)tethering;
4157 *filtering_enabled = th->port_filtering;
4159 return TETHERING_ERROR_NONE;
4162 API int tethering_wifi_set_vpn_passthrough_rule(tethering_h tethering, tethering_vpn_passthrough_type_e type, bool enable)
4164 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4165 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4167 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4168 "parameter(tethering) is NULL\n");
4170 GVariant *parameters;
4171 GError *error = NULL;
4174 __tethering_h *th = (__tethering_h *)tethering;
4176 GDBusProxy *proxy = th->client_bus_proxy;
4178 parameters = g_dbus_proxy_call_sync(proxy, "set_vpn_passthrough_rule",
4179 g_variant_new("(ib)", type, enable),
4180 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4182 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4184 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4185 result = TETHERING_ERROR_PERMISSION_DENIED;
4187 result = TETHERING_ERROR_OPERATION_FAILED;
4189 g_error_free(error);
4193 g_variant_get(parameters, "(u)", &result);
4195 g_variant_unref(parameters);
4197 return TETHERING_ERROR_NONE;
4200 API int tethering_wifi_push_wps_button(tethering_h tethering)
4202 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4203 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4205 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4206 "parameter(tethering) is NULL");
4207 __tethering_h *th = (__tethering_h *)tethering;
4208 GDBusProxy *proxy = th->client_bus_proxy;
4209 GVariant *parameters = NULL;
4211 GError *error = NULL;
4213 parameters = g_dbus_proxy_call_sync(proxy, "push_wps_button",
4214 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4217 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4219 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4220 ret = TETHERING_ERROR_PERMISSION_DENIED;
4222 ret = TETHERING_ERROR_OPERATION_FAILED;
4224 g_error_free(error);
4228 if (parameters != NULL) {
4229 g_variant_get(parameters, "(u)", &ret);
4230 g_variant_unref(parameters);
4233 return TETHERING_ERROR_NONE;
4236 API int tethering_wifi_set_wps_pin(tethering_h tethering, const char *wps_pin)
4238 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4239 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4241 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4242 "parameter(tethering) is NULL");
4243 _retvm_if(wps_pin == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4244 "parameter(wps_pin) is NULL");
4246 __tethering_h *th = (__tethering_h *)tethering;
4247 GDBusProxy *proxy = th->client_bus_proxy;
4248 GVariant *parameters = NULL;
4250 GError *error = NULL;
4252 parameters = g_dbus_proxy_call_sync(proxy, "set_wps_pin",
4253 g_variant_new("(s)", wps_pin), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4256 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4258 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4259 ret = TETHERING_ERROR_PERMISSION_DENIED;
4261 ret = TETHERING_ERROR_OPERATION_FAILED;
4263 g_error_free(error);
4267 if (parameters != NULL) {
4268 g_variant_get(parameters, "(u)", &ret);
4269 g_variant_unref(parameters);
4272 return TETHERING_ERROR_NONE;