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_strcmp0(ptr, ""))
210 if (!g_utf8_validate(ptr, -1, (const char **)&ptr_tmp))
213 g_strlcpy(ssid, ptr, size);
219 static tethering_error_e __set_visible(const bool visible)
221 if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, visible ? 0 : 1) < 0) {
222 ERR("vconf_set_int is failed\n");
223 return TETHERING_ERROR_OPERATION_FAILED;
226 return TETHERING_ERROR_NONE;
229 static tethering_error_e __get_visible(bool *visible)
231 if (visible == NULL) {
232 ERR("Invalid param\n");
233 return TETHERING_ERROR_INVALID_PARAMETER;
238 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, &hide) < 0) {
239 ERR("vconf_get_int is failed\n");
240 return TETHERING_ERROR_OPERATION_FAILED;
247 return TETHERING_ERROR_NONE;
250 static unsigned int __generate_initial_passphrase(char *passphrase, unsigned int size)
252 if (passphrase == NULL ||
253 size == 0 || size < TETHERING_WIFI_KEY_MIN_LEN + 1)
256 guint32 rand_int = 0;
259 for (index = 0; index < TETHERING_WIFI_KEY_MIN_LEN; index++) {
260 rand_int = g_random_int_range('a', 'z');
261 passphrase[index] = rand_int;
263 passphrase[index] = '\0';
268 static tethering_error_e __get_error(int agent_error)
270 tethering_error_e err = TETHERING_ERROR_NONE;
272 switch (agent_error) {
273 case MOBILE_AP_ERROR_NONE:
274 err = TETHERING_ERROR_NONE;
277 case MOBILE_AP_ERROR_RESOURCE:
278 err = TETHERING_ERROR_OUT_OF_MEMORY;
281 case MOBILE_AP_ERROR_INTERNAL:
282 err = TETHERING_ERROR_OPERATION_FAILED;
285 case MOBILE_AP_ERROR_INVALID_PARAM:
286 err = TETHERING_ERROR_INVALID_PARAMETER;
289 case MOBILE_AP_ERROR_ALREADY_ENABLED:
290 err = TETHERING_ERROR_OPERATION_FAILED;
293 case MOBILE_AP_ERROR_NOT_ENABLED:
294 err = TETHERING_ERROR_NOT_ENABLED;
297 case MOBILE_AP_ERROR_NET_OPEN:
298 err = TETHERING_ERROR_OPERATION_FAILED;
301 case MOBILE_AP_ERROR_NET_CLOSE:
302 err = TETHERING_ERROR_OPERATION_FAILED;
305 case MOBILE_AP_ERROR_DHCP:
306 err = TETHERING_ERROR_OPERATION_FAILED;
309 case MOBILE_AP_ERROR_IN_PROGRESS:
310 err = TETHERING_ERROR_OPERATION_FAILED;
313 case MOBILE_AP_ERROR_NOT_PERMITTED:
314 err = TETHERING_ERROR_NOT_PERMITTED;
317 case MOBILE_AP_ERROR_PERMISSION_DENIED:
318 err = TETHERING_ERROR_PERMISSION_DENIED;
321 ERR("Not defined error : %d\n", agent_error);
322 err = TETHERING_ERROR_OPERATION_FAILED;
329 static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name,
330 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
331 GVariant *parameters, gpointer user_data)
335 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
337 __tethering_h *th = (__tethering_h *)user_data;
339 tethering_type_e type = 0;
340 mobile_ap_type_e ap_type = 0;
341 tethering_connection_state_changed_cb ccb = NULL;
342 __tethering_client_h client;
350 memset(&client, 0, sizeof(__tethering_client_h));
351 g_variant_get(parameters, "(susssu)", &buf, &ap_type, &ip, &mac, &name, ×tamp);
353 if (!g_strcmp0(buf, "DhcpConnected")) {
355 } else if (!g_strcmp0(buf, "DhcpLeaseDeleted")) {
358 ERR("Unknown event [%s]\n", buf);
362 if (ap_type == MOBILE_AP_TYPE_USB)
363 type = TETHERING_TYPE_USB;
364 else if (ap_type == MOBILE_AP_TYPE_WIFI)
365 type = TETHERING_TYPE_WIFI;
366 else if (ap_type == MOBILE_AP_TYPE_BT)
367 type = TETHERING_TYPE_BT;
368 else if (ap_type == MOBILE_AP_TYPE_P2P)
369 type = TETHERING_TYPE_P2P;
371 ERR("Not supported tethering type [%d]\n", ap_type);
375 SINFO("[%s] type %d, ip %s, mac %s, name %s, timestamp %d",
376 buf, ap_type, ip, mac, name, timestamp);
378 ccb = th->changed_cb[type];
381 data = th->changed_user_data[type];
383 client.interface = type;
384 g_strlcpy(client.ip, ip, sizeof(client.ip));
385 g_strlcpy(client.mac, mac, sizeof(client.mac));
387 client.hostname = g_strdup(name);
388 client.tm = (time_t)timestamp;
390 ccb((tethering_client_h)&client, opened, data);
391 g_free(client.hostname);
400 static void __handle_net_closed(GDBusConnection *connection, const gchar *sender_name,
401 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
402 GVariant *parameters, gpointer user_data)
406 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
408 __tethering_h *th = (__tethering_h *)user_data;
409 tethering_type_e type = 0;
410 tethering_disabled_cb dcb = NULL;
412 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_NETWORK_CLOSE;
414 SINFO("Tethering Disabled by network close !");
416 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
417 dcb = th->disabled_cb[type];
420 data = th->disabled_user_data[type];
422 dcb(TETHERING_ERROR_NONE, type, code, data);
428 static void __handle_wifi_tether_on(GDBusConnection *connection, const gchar *sender_name,
429 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
430 GVariant *parameters, gpointer user_data)
434 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
436 __tethering_h *th = (__tethering_h *)user_data;
437 tethering_type_e type = TETHERING_TYPE_WIFI;
438 bool is_requested = false;
439 tethering_enabled_cb ecb = NULL;
442 ecb = th->enabled_cb[type];
445 data = th->enabled_user_data[type];
447 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
451 static void __handle_wifi_tether_off(GDBusConnection *connection, const gchar *sender_name,
452 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
453 GVariant *parameters, gpointer user_data)
457 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
459 __tethering_h *th = (__tethering_h *)user_data;
460 tethering_type_e type = TETHERING_TYPE_WIFI;
461 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
462 tethering_disabled_cb dcb = NULL;
466 dcb = th->disabled_cb[type];
469 data = th->disabled_user_data[type];
470 g_variant_get(parameters, "(s)", &buf);
471 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
472 code = TETHERING_DISABLED_BY_WIFI_ON;
473 else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT))
474 code = TETHERING_DISABLED_BY_TIMEOUT;
477 dcb(TETHERING_ERROR_NONE, type, code, data);
482 static void __handle_usb_tether_on(GDBusConnection *connection, const gchar *sender_name,
483 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
484 GVariant *parameters, gpointer user_data)
488 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
490 __tethering_h *th = (__tethering_h *)user_data;
491 tethering_type_e type = TETHERING_TYPE_USB;
492 bool is_requested = false;
493 tethering_enabled_cb ecb = NULL;
496 ecb = th->enabled_cb[type];
499 data = th->enabled_user_data[type];
501 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
505 static void __handle_usb_tether_off(GDBusConnection *connection, const gchar *sender_name,
506 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
507 GVariant *parameters, gpointer user_data)
511 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
513 __tethering_h *th = (__tethering_h *)user_data;
514 tethering_type_e type = TETHERING_TYPE_USB;
515 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
516 tethering_disabled_cb dcb = NULL;
520 dcb = th->disabled_cb[type];
523 data = th->disabled_user_data[type];
525 g_variant_get(parameters, "(s)", &buf);
526 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
527 code = TETHERING_DISABLED_BY_USB_DISCONNECTION;
529 dcb(TETHERING_ERROR_NONE, type, code, data);
534 static void __handle_bt_tether_on(GDBusConnection *connection, const gchar *sender_name,
535 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
536 GVariant *parameters, gpointer user_data)
540 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
542 __tethering_h *th = (__tethering_h *)user_data;
543 tethering_type_e type = TETHERING_TYPE_BT;
544 bool is_requested = false;
545 tethering_enabled_cb ecb = NULL;
548 ecb = th->enabled_cb[type];
551 data = th->enabled_user_data[type];
553 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
557 static void __handle_bt_tether_off(GDBusConnection *connection, const gchar *sender_name,
558 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
559 GVariant *parameters, gpointer user_data)
563 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
565 __tethering_h *th = (__tethering_h *)user_data;
566 tethering_type_e type = TETHERING_TYPE_BT;
567 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
568 tethering_disabled_cb dcb = NULL;
572 dcb = th->disabled_cb[type];
575 data = th->disabled_user_data[type];
576 g_variant_get(parameters, "(s)", &buf);
577 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
578 code = TETHERING_DISABLED_BY_BT_OFF;
579 else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT))
580 code = TETHERING_DISABLED_BY_TIMEOUT;
582 dcb(TETHERING_ERROR_NONE, type, code, data);
588 static void __handle_no_data_timeout(GDBusConnection *connection, const gchar *sender_name,
589 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
590 GVariant *parameters, gpointer user_data)
594 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
596 __tethering_h *th = (__tethering_h *)user_data;
597 tethering_type_e type = 0;
598 tethering_disabled_cb dcb = NULL;
600 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_TIMEOUT;
602 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
603 dcb = th->disabled_cb[type];
606 data = th->disabled_user_data[type];
608 dcb(TETHERING_ERROR_NONE, type, code, data);
613 static void __handle_low_battery_mode(GDBusConnection *connection, const gchar *sender_name,
614 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
615 GVariant *parameters, gpointer user_data)
619 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
621 __tethering_h *th = (__tethering_h *)user_data;
622 tethering_type_e type = 0;
623 tethering_disabled_cb dcb = NULL;
625 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_LOW_BATTERY;
627 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
628 dcb = th->disabled_cb[type];
631 data = th->disabled_user_data[type];
633 dcb(TETHERING_ERROR_NONE, type, code, data);
638 static void __handle_flight_mode(GDBusConnection *connection, const gchar *sender_name,
639 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
640 GVariant *parameters, gpointer user_data)
644 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
646 __tethering_h *th = (__tethering_h *)user_data;
647 tethering_type_e type = 0;
648 tethering_disabled_cb dcb = NULL;
650 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_FLIGHT_MODE;
652 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
653 dcb = th->disabled_cb[type];
656 data = th->disabled_user_data[type];
658 dcb(TETHERING_ERROR_NONE, type, code, data);
663 static void __handle_security_type_changed(GDBusConnection *connection, const gchar *sender_name,
664 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
665 GVariant *parameters, gpointer user_data)
670 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
671 __tethering_h *th = (__tethering_h *)user_data;
673 tethering_wifi_security_type_changed_cb scb = NULL;
675 tethering_wifi_security_type_e security_type;
678 scb = th->security_type_changed_cb;
682 g_variant_get(parameters, "(s)", &buf);
683 data = th->security_type_user_data;
684 if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_OPEN_STR) == 0)
685 security_type = TETHERING_WIFI_SECURITY_TYPE_NONE;
686 else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR) == 0)
687 security_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK;
688 else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_WPS_STR) == 0)
689 security_type = TETHERING_WIFI_SECURITY_TYPE_WPS;
690 else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_SAE_STR) == 0)
691 security_type = TETHERING_WIFI_SECURITY_TYPE_SAE;
693 SERR("Unknown type : %s\n", buf);
698 scb(security_type, data);
703 static void __handle_ssid_visibility_changed(GDBusConnection *connection, const gchar *sender_name,
704 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
705 GVariant *parameters, gpointer user_data)
709 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
710 __tethering_h *th = (__tethering_h *)user_data;
712 tethering_wifi_ssid_visibility_changed_cb scb = NULL;
714 bool visible = false;
717 scb = th->ssid_visibility_changed_cb;
722 g_variant_get(parameters, "(s)", &buf);
723 data = th->ssid_visibility_user_data;
724 if (g_strcmp0(buf, SIGNAL_MSG_SSID_VISIBLE) == 0)
732 static void __handle_passphrase_changed(GDBusConnection *connection, const gchar *sender_name,
733 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
734 GVariant *parameters, gpointer user_data)
738 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
739 __tethering_h *th = (__tethering_h *)user_data;
741 tethering_wifi_passphrase_changed_cb pcb = NULL;
744 pcb = th->passphrase_changed_cb;
748 data = th->passphrase_user_data;
754 static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
759 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
760 GError *g_error = NULL;
763 tethering_error_e error;
764 __tethering_h *th = (__tethering_h *)user_data;
765 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_WIFI];
766 void *data = th->enabled_user_data[TETHERING_TYPE_WIFI];
768 if (!_tethering_check_handle((tethering_h)user_data))
771 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
773 ERR("DBus error [%s]\n", g_error->message);
774 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
775 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
776 g_error_free(g_error);
777 tethering_enable((tethering_h)th, TETHERING_TYPE_WIFI);
779 } else if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
780 error = TETHERING_ERROR_PERMISSION_DENIED;
782 error = TETHERING_ERROR_OPERATION_FAILED;
783 g_error_free(g_error);
785 g_variant_get(g_var, "(u)", &info);
786 error = __get_error(info);
790 INFO("cfm event : wifi tethering enable info : %d\n", error);
792 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
793 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_ON].name,
794 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
795 sigs[E_SIGNAL_WIFI_TETHER_ON].cb, (gpointer)th, NULL);
797 SINFO("Tethering enabled event ! error(%d)", error);
803 ecb(error, TETHERING_TYPE_WIFI, true, data);
804 g_variant_unref(g_var);
808 static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
812 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
813 GError *g_error = NULL;
816 tethering_error_e error;
818 __tethering_h *th = (__tethering_h *)user_data;
819 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_BT];
820 void *data = th->enabled_user_data[TETHERING_TYPE_BT];
822 if (!_tethering_check_handle((tethering_h)user_data))
825 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
827 ERR("DBus error [%s]\n", g_error->message);
828 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
829 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
830 g_error_free(g_error);
831 tethering_enable((tethering_h)th, TETHERING_TYPE_BT);
835 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
836 error = TETHERING_ERROR_PERMISSION_DENIED;
838 error = TETHERING_ERROR_OPERATION_FAILED;
839 g_error_free(g_error);
841 g_variant_get(g_var, "(u)", &info);
842 g_variant_unref(g_var);
843 error = __get_error(info);
847 sigs[E_SIGNAL_BT_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
848 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_ON].name,
849 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
850 sigs[E_SIGNAL_BT_TETHER_ON].cb, (gpointer)th, NULL);
857 ecb(error, TETHERING_TYPE_BT, true, data);
861 static void __usb_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
866 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
867 __tethering_h *th = (__tethering_h *)user_data;
868 GError *g_error = NULL;
871 tethering_error_e error;
872 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_USB];
873 void *data = th->enabled_user_data[TETHERING_TYPE_USB];
875 if (!_tethering_check_handle((tethering_h)user_data))
878 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
880 ERR("DBus error [%s]\n", g_error->message);
881 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
882 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
883 g_error_free(g_error);
884 tethering_enable((tethering_h)th, TETHERING_TYPE_USB);
888 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
889 error = TETHERING_ERROR_PERMISSION_DENIED;
891 error = TETHERING_ERROR_OPERATION_FAILED;
892 g_error_free(g_error);
894 g_variant_get(g_var, "(u)", &info);
895 g_variant_unref(g_var);
896 error = __get_error(info);
900 sigs[E_SIGNAL_USB_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
901 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_ON].name,
902 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
903 sigs[E_SIGNAL_USB_TETHER_ON].cb, (gpointer)th, NULL);
910 ecb(error, TETHERING_TYPE_USB, true, data);
914 static void __p2p_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
919 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
920 __tethering_h *th = (__tethering_h *)user_data;
921 GError *g_error = NULL;
924 tethering_error_e error;
925 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_P2P];
926 void *data = th->enabled_user_data[TETHERING_TYPE_P2P];
928 if (!_tethering_check_handle((tethering_h)user_data))
931 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
933 ERR("DBus error [%s]\n", g_error->message);
934 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
935 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
936 g_error_free(g_error);
937 tethering_enable((tethering_h)th, TETHERING_TYPE_P2P);
941 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
942 error = TETHERING_ERROR_PERMISSION_DENIED;
944 error = TETHERING_ERROR_OPERATION_FAILED;
945 g_error_free(g_error);
947 g_variant_get(g_var, "(u)", &info);
948 g_variant_unref(g_var);
949 error = __get_error(info);
958 ecb(error, TETHERING_TYPE_P2P, true, data);
962 static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res,
967 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
968 GError *g_error = NULL;
970 guint info, event_type;
971 tethering_error_e error;
972 tethering_type_e type;
973 tethering_h tethering = (tethering_h)user_data;
974 __tethering_h *th = (__tethering_h *)tethering;
975 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_REQUEST;
976 tethering_disabled_cb dcb = NULL;
979 if (!_tethering_check_handle((tethering_h)user_data))
982 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
984 ERR("DBus error [%s]\n", g_error->message);
985 g_error_free(g_error);
988 g_variant_get(g_var, "(uu)", &event_type, &info);
989 INFO("cfm event : %d info : %d\n", event_type, info);
990 g_variant_unref(g_var);
991 error = __get_error(info);
992 INFO("cfm event : %d info : %d\n", event_type, error);
993 switch (event_type) {
994 case MOBILE_AP_DISABLE_WIFI_TETHERING_CFM:
995 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
996 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_OFF].name,
997 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
998 sigs[E_SIGNAL_WIFI_TETHER_OFF].cb, (gpointer)th, NULL);
1000 type = TETHERING_TYPE_WIFI;
1001 dcb = th->disabled_cb[type];
1002 data = th->disabled_user_data[type];
1004 dcb(error, type, code, data);
1007 case MOBILE_AP_DISABLE_BT_TETHERING_CFM:
1008 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1009 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_OFF].name,
1010 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1011 sigs[E_SIGNAL_BT_TETHER_OFF].cb, (gpointer)th, NULL);
1013 type = TETHERING_TYPE_BT;
1014 dcb = th->disabled_cb[type];
1015 data = th->disabled_user_data[type];
1017 dcb(error, type, code, data);
1020 case MOBILE_AP_DISABLE_USB_TETHERING_CFM:
1021 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1022 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
1023 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1024 sigs[E_SIGNAL_USB_TETHER_OFF].cb, (gpointer)th, NULL);
1026 type = TETHERING_TYPE_USB;
1027 dcb = th->disabled_cb[type];
1028 data = th->disabled_user_data[type];
1030 dcb(error, type, code, data);
1033 case MOBILE_AP_DISABLE_P2P_TETHERING_CFM:
1034 type = TETHERING_TYPE_P2P;
1035 dcb = th->disabled_cb[type];
1036 data = th->disabled_user_data[type];
1038 dcb(error, type, code, data);
1041 case MOBILE_AP_DISABLE_CFM:
1043 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1044 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_OFF].name,
1045 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1046 sigs[E_SIGNAL_WIFI_TETHER_OFF].cb, (gpointer)th, NULL);
1047 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1048 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_OFF].name,
1049 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1050 sigs[E_SIGNAL_BT_TETHER_OFF].cb, (gpointer)th, NULL);
1051 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1052 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
1053 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1054 sigs[E_SIGNAL_USB_TETHER_OFF].cb, (gpointer)th, NULL);
1056 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
1057 dcb = th->disabled_cb[type];
1060 data = th->disabled_user_data[type];
1062 dcb(error, type, code, data);
1067 ERR("Invalid event\n");
1073 static void __get_data_usage_cb(GObject *source_object, GAsyncResult *res,
1078 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1080 GError *g_error = NULL;
1083 guint64 tx_bytes, rx_bytes;
1084 __tethering_h *th = (__tethering_h *)user_data;
1085 tethering_error_e tethering_error = TETHERING_ERROR_NONE;
1088 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1090 ERR("DBus fail [%s]\n", g_error->message);
1091 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1092 tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1094 tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1098 if (th->data_usage_cb == NULL) {
1099 ERR("There is no data_usage_cb\n");
1103 th->data_usage_cb(tethering_error, 0LL, 0LL, th->data_usage_user_data);
1105 g_variant_get(g_var, "(utt)", &event_type, &tx_bytes, &rx_bytes);
1106 th->data_usage_cb(TETHERING_ERROR_NONE,
1107 rx_bytes, tx_bytes, th->data_usage_user_data);
1108 g_variant_unref(g_var);
1110 th->data_usage_cb = NULL;
1111 th->data_usage_user_data = NULL;
1116 static void __settings_reloaded_cb(GObject *source_object, GAsyncResult *res,
1121 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1122 GError *g_error = NULL;
1125 __tethering_h *th = (__tethering_h *)user_data;
1126 tethering_error_e tethering_error = TETHERING_ERROR_NONE;
1128 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1130 ERR("DBus fail [%s]\n", g_error->message);
1131 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1132 tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1134 tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1135 g_error_free(g_error);
1137 g_variant_get(g_var, "(u)", &info);
1138 if (tethering_error == TETHERING_ERROR_NONE)
1139 tethering_error = __get_error(info);
1140 g_variant_unref(g_var);
1143 if (th->settings_reloaded_cb == NULL) {
1144 DBG("There is no settings_reloaded_cb\n-\n");
1148 th->settings_reloaded_cb(tethering_error,
1149 th->settings_reloaded_user_data);
1151 th->settings_reloaded_cb = NULL;
1152 th->settings_reloaded_user_data = NULL;
1156 static void __connect_signals(tethering_h tethering)
1159 _retm_if(tethering == NULL, "parameter(tethering) is NULL\n");
1161 __tethering_h *th = (__tethering_h *)tethering;
1162 GDBusConnection *connection = th->client_bus;
1165 for (i = E_SIGNAL_NET_CLOSED; i < E_SIGNAL_MAX; i++) {
1166 sigs[i].sig_id = g_dbus_connection_signal_subscribe(connection,
1167 NULL, TETHERING_SERVICE_INTERFACE, sigs[i].name,
1168 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1169 sigs[i].cb, tethering, NULL);
1174 static void __disconnect_signals(tethering_h tethering)
1178 _retm_if(tethering == NULL, "parameter(tethering) is NULL\n");
1180 __tethering_h *th = (__tethering_h *)tethering;
1181 GDBusConnection *connection = th->client_bus;
1185 for (i = E_SIGNAL_NET_CLOSED; i < E_SIGNAL_MAX; i++)
1186 g_dbus_connection_signal_unsubscribe(connection, sigs[i].sig_id);
1192 static bool __get_intf_name(tethering_type_e type, char *buf, unsigned int len)
1194 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1197 case TETHERING_TYPE_USB:
1198 g_strlcpy(buf, TETHERING_USB_IF, len);
1200 case TETHERING_TYPE_WIFI:
1201 g_strlcpy(buf, TETHERING_WIFI_IF, len);
1203 case TETHERING_TYPE_BT:
1204 g_strlcpy(buf, TETHERING_BT_IF, len);
1206 case TETHERING_TYPE_P2P:
1207 g_strlcpy(buf, TETHERING_P2P_IF, len);
1210 ERR("Not supported type : %d\n", type);
1216 static bool __get_gateway_addr(tethering_type_e type, char *buf, unsigned int len)
1218 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1221 case TETHERING_TYPE_USB:
1222 g_strlcpy(buf, TETHERING_USB_GATEWAY, len);
1224 case TETHERING_TYPE_WIFI:
1225 g_strlcpy(buf, TETHERING_WIFI_GATEWAY, len);
1227 case TETHERING_TYPE_BT:
1228 g_strlcpy(buf, TETHERING_BT_GATEWAY, len);
1230 case TETHERING_TYPE_P2P:
1231 g_strlcpy(buf, TETHERING_P2P_GATEWAY, len);
1234 ERR("Not supported type : %d\n", type);
1240 static int __get_common_ssid(char *ssid, unsigned int size)
1243 ERR("ssid is null\n");
1244 return TETHERING_ERROR_INVALID_PARAMETER;
1248 char *ptr_tmp = NULL;
1250 ptr = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
1252 ERR("vconf_get_str is failed and set default ssid");
1253 g_strlcpy(ssid, TETHERING_DEFAULT_SSID, size);
1255 g_strlcpy(ssid, ptr, size);
1259 if (!g_utf8_validate(ssid, -1, (const char **)&ptr_tmp))
1262 return TETHERING_ERROR_NONE;
1265 static bool __get_wifi_mode_type(tethering_wifi_mode_type_e type, char **buf)
1267 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1270 case TETHERING_WIFI_MODE_TYPE_B:
1271 *buf = g_strdup("b");
1273 case TETHERING_WIFI_MODE_TYPE_G:
1274 *buf = g_strdup("g");
1276 case TETHERING_WIFI_MODE_TYPE_A:
1277 *buf = g_strdup("a");
1279 case TETHERING_WIFI_MODE_TYPE_AD:
1280 *buf = g_strdup("ad");
1283 ERR("Not supported type : %d\n", type);
1289 static int __prepare_wifi_settings(tethering_h tethering, _softap_settings_t *set)
1293 __tethering_h *th = (__tethering_h *)tethering;
1294 tethering_error_e ret = TETHERING_ERROR_NONE;
1297 if (th == NULL || set == NULL) {
1298 ERR("null parameter\n-\n");
1299 return TETHERING_ERROR_INVALID_PARAMETER;
1302 if (th->ssid == NULL)
1303 __get_common_ssid(set->ssid, sizeof(set->ssid));
1305 g_strlcpy(set->ssid, th->ssid, sizeof(set->ssid));
1307 ret = __get_security_type(&set->sec_type);
1308 if (ret != TETHERING_ERROR_NONE)
1309 set->sec_type = th->sec_type;
1311 ret = __get_visible(&set->visibility);
1312 if (ret != TETHERING_ERROR_NONE)
1313 set->visibility = th->visibility;
1315 set->mac_filter = th->mac_filter;
1316 set->max_connected = th->wifi_max_connected;
1317 set->channel = th->channel;
1318 set->txpower = th->txpower;
1320 __get_wifi_mode_type(th->mode_type, &ptr);
1322 g_strlcpy(set->mode, "", sizeof(set->mode));
1324 g_strlcpy(set->mode, ptr, sizeof(set->mode));
1328 if (set->sec_type == TETHERING_WIFI_SECURITY_TYPE_NONE) {
1329 g_strlcpy(set->key, "", sizeof(set->key));
1331 GDBusProxy *proxy = th->client_bus_proxy;
1332 GVariant *parameters;
1333 GError *error = NULL;
1334 char *passphrase = NULL;
1335 unsigned int len = 0;
1337 parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_passphrase",
1338 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1341 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
1343 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
1344 ret = TETHERING_ERROR_PERMISSION_DENIED;
1346 ret = TETHERING_ERROR_OPERATION_FAILED;
1348 g_error_free(error);
1352 if (parameters != NULL) {
1353 g_variant_get(parameters, "(siu)", &passphrase, &len, &ret);
1354 g_strlcpy(set->key, passphrase, sizeof(set->key) - 1);
1356 g_variant_unref(parameters);
1360 INFO("ssid: %s security: %d mode: %s channel: %d visibility: %s\n",
1361 set->ssid, set->sec_type, set->mode, set->channel,
1362 (set->visibility) ? "true" : "false");
1364 return TETHERING_ERROR_NONE;
1367 static bool __check_precondition(tethering_type_e type)
1369 int dnet_status = 0;
1370 int cellular_state = 0;
1372 /* data network through cellular */
1373 vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &cellular_state);
1374 if (cellular_state == VCONFKEY_NETWORK_CELLULAR_ON) {
1375 INFO("Data Network can be connected later");
1379 /* data network status */
1380 vconf_get_int(VCONFKEY_NETWORK_STATUS, &dnet_status);
1381 if ((dnet_status == VCONFKEY_NETWORK_WIFI
1382 && type != TETHERING_TYPE_WIFI)
1383 || dnet_status == VCONFKEY_NETWORK_ETHERNET)
1386 ERR("Network is not available!");
1392 * @brief Creates the handle of tethering.
1394 * @privlevel platform
1395 * @privilege http://tizen.org/privilege/tethering.admin
1396 * @remarks The @a tethering must be released tethering_destroy() by you.
1397 * @param[out] tethering A handle of a new mobile ap handle on success
1398 * @return 0 on success, otherwise a negative error value.
1399 * @retval #TETHERING_ERROR_NONE Successful
1400 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1401 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1402 * @retval #TETHERING_ERROR_NOT_SUPPORT_API API is not supported
1403 * @see tethering_destroy()
1405 API int tethering_create(tethering_h *tethering)
1407 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1408 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1409 "parameter(tethering) is NULL\n");
1412 __tethering_h *th = NULL;
1413 GError *error = NULL;
1414 char ssid[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
1416 th = (__tethering_h *)malloc(sizeof(__tethering_h));
1418 _retvm_if(th == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
1419 "malloc is failed\n");
1420 memset(th, 0x00, sizeof(__tethering_h));
1421 th->sec_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK;
1422 th->visibility = true;
1423 th->mac_filter = false;
1424 th->channel = TETHERING_WIFI_CHANNEL;
1425 th->mode_type = TETHERING_WIFI_MODE_TYPE_G;
1426 th->wifi_max_connected = TETHERING_WIFI_MAX_STA;
1427 th->txpower = TETHERING_WIFI_MAX_TXPOWER;
1429 if (__generate_initial_passphrase(th->passphrase,
1430 sizeof(th->passphrase)) == 0) {
1431 ERR("random passphrase generation failed\n");
1433 return TETHERING_ERROR_OPERATION_FAILED;
1436 if (__get_common_ssid(ssid, sizeof(ssid)) != TETHERING_ERROR_NONE) {
1437 ERR("common ssid get failed\n");
1439 return TETHERING_ERROR_OPERATION_FAILED;
1442 SINFO("ssid: %s, key: %s, channel: %d, mode: %d, txpower: %d, security: %d max_device: %d\n",
1443 ssid, th->passphrase, th->channel, th->mode_type, th->txpower, th->sec_type,
1444 th->wifi_max_connected);
1446 #if !GLIB_CHECK_VERSION(2, 36, 0)
1449 GCancellable *cancellable = g_cancellable_new();
1450 th->client_bus = g_bus_get_sync(DBUS_BUS_SYSTEM, cancellable, &error);
1452 ERR("Couldn't connect to the System bus[%s]", error->message);
1453 g_error_free(error);
1454 g_cancellable_cancel(cancellable);
1455 g_object_unref(cancellable);
1457 return TETHERING_ERROR_OPERATION_FAILED;
1459 th->cancellable = cancellable;
1461 th->client_bus_proxy = g_dbus_proxy_new_sync(th->client_bus, G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION,
1462 NULL, TETHERING_SERVICE_NAME, TETHERING_SERVICE_OBJECT_PATH,
1463 TETHERING_SERVICE_INTERFACE, th->cancellable, &error);
1464 if (!th->client_bus_proxy) {
1466 ERR("Couldn't create the proxy object because of %s\n", error->message);
1467 g_cancellable_cancel(th->cancellable);
1468 g_object_unref(th->cancellable);
1469 g_object_unref(th->client_bus);
1471 return TETHERING_ERROR_OPERATION_FAILED;
1474 __connect_signals((tethering_h)th);
1476 *tethering = (tethering_h)th;
1477 _tethering_add_handle(th);
1478 INFO("Tethering Handle : %p\n", th);
1480 return TETHERING_ERROR_NONE;
1485 * @brief Destroys the handle of tethering.
1487 * @privlevel platform
1488 * @privilege http://tizen.org/privilege/tethering.admin
1489 * @param[in] tethering The handle of tethering
1490 * @return 0 on success, otherwise a negative error value.
1491 * @retval #TETHERING_ERROR_NONE Successful
1492 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1493 * @see tethering_create()
1495 API int tethering_destroy(tethering_h tethering)
1498 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1499 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1500 "parameter(tethering) is NULL\n");
1502 __tethering_h *th = (__tethering_h *)tethering;
1504 INFO("Tethering Handle : %p\n", th);
1506 __disconnect_signals(tethering);
1507 _tethering_remove_handle(th);
1512 g_object_unref(th->cancellable);
1513 g_object_unref(th->client_bus_proxy);
1514 g_object_unref(th->client_bus);
1515 memset(th, 0x00, sizeof(__tethering_h));
1520 return TETHERING_ERROR_NONE;
1525 * @brief Enables the tethering, asynchronously.
1527 * @privlevel platform
1528 * @privilege http://tizen.org/privilege/tethering.admin
1529 * @param[in] tethering The handle of tethering
1530 * @param[in] type The type of tethering
1531 * @return 0 on success, otherwise negative error value.
1532 * @retval #TETHERING_ERROR_NONE Successful
1533 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1534 * @post tethering_enabled_cb() will be invoked.
1535 * @see tethering_is_enabled()
1536 * @see tethering_disable()
1538 API int tethering_enable(tethering_h tethering, tethering_type_e type)
1540 INFO("+ type : %d\n", type);
1541 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1542 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1543 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1544 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1546 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1547 "parameter(tethering) is NULL\n");
1549 tethering_error_e ret = TETHERING_ERROR_NONE;
1550 __tethering_h *th = (__tethering_h *)tethering;
1551 GDBusProxy *proxy = th->client_bus_proxy;
1552 GDBusConnection *connection = th->client_bus;
1554 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
1556 if (__check_precondition(type) == FALSE) {
1558 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1559 return TETHERING_ERROR_OPERATION_FAILED;
1563 case TETHERING_TYPE_USB:
1564 g_dbus_connection_signal_unsubscribe(connection,
1565 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1567 g_dbus_proxy_call(proxy, "enable_usb_tethering",
1568 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1569 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1570 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1573 case TETHERING_TYPE_WIFI: {
1574 _softap_settings_t set = {"", "", "", 0, false};
1576 ret = __prepare_wifi_settings(tethering, &set);
1577 if (ret != TETHERING_ERROR_NONE) {
1578 ERR("softap settings initialization failed\n");
1580 return TETHERING_ERROR_OPERATION_FAILED;
1582 g_dbus_connection_signal_unsubscribe(connection,
1583 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1585 SINFO("ssid %s, key %s, channel %d, mode %s, txpower %d, security %d max_device %d\n",
1586 set.ssid, set.key, set.channel, set.mode, set.txpower, set.sec_type,
1589 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1590 g_variant_new("(sssiiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, set.txpower, TETHERING_ADDRESS_FAMILY_IPV4),
1591 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1592 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1596 case TETHERING_TYPE_BT:
1597 g_dbus_connection_signal_unsubscribe(connection,
1598 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1600 g_dbus_proxy_call(proxy, "enable_bt_tethering",
1601 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1602 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1603 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1607 case TETHERING_TYPE_P2P: {
1608 _softap_settings_t p2p_set = {"", "", "", 0, false};
1609 ret = __prepare_wifi_settings(tethering, &p2p_set);
1610 if (ret != TETHERING_ERROR_NONE) {
1611 ERR("p2p settings initialization failed\n");
1612 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1614 return TETHERING_ERROR_OPERATION_FAILED;
1617 g_dbus_proxy_call(proxy, "enable_p2p_tethering",
1618 g_variant_new("(ssi)", p2p_set.ssid, p2p_set.key, p2p_set.channel),
1619 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1620 (GAsyncReadyCallback) __p2p_enabled_cfm_cb, (gpointer)tethering);
1624 case TETHERING_TYPE_ALL: {
1625 _softap_settings_t set = {"", "", "", 0, false};
1627 ret = __prepare_wifi_settings(tethering, &set);
1628 if (ret != TETHERING_ERROR_NONE) {
1629 ERR("softap settings initialization failed\n");
1630 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1631 return TETHERING_ERROR_OPERATION_FAILED;
1634 /* TETHERING_TYPE_USB */
1635 g_dbus_connection_signal_unsubscribe(connection,
1636 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1638 g_dbus_proxy_call(proxy, "enable_usb_tethering",
1639 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1640 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1641 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1643 /* TETHERING_TYPE_WIFI */
1644 g_dbus_connection_signal_unsubscribe(connection,
1645 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1647 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1648 g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode,
1649 set.channel, set.visibility, set.mac_filter, set.max_connected,
1650 set.sec_type, TETHERING_ADDRESS_FAMILY_IPV4),
1651 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1652 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1654 /* TETHERING_TYPE_BT */
1655 g_dbus_connection_signal_unsubscribe(connection,
1656 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1658 g_dbus_proxy_call(proxy, "enable_bt_tethering",
1659 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1660 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1661 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1665 ERR("Unknown type : %d\n", type);
1667 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1670 return TETHERING_ERROR_INVALID_PARAMETER;
1673 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1675 return TETHERING_ERROR_NONE;
1678 API int tethering_ipv6_enable(tethering_h tethering, tethering_type_e type)
1680 DBG("+ type : %d\n", type);
1681 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1682 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1683 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1684 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1686 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1687 "parameter(tethering) is NULL\n");
1689 __tethering_h *th = (__tethering_h *)tethering;
1690 GDBusProxy *proxy = th->client_bus_proxy;
1691 GDBusConnection *connection = th->client_bus;
1694 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
1696 if (__check_precondition(type) == FALSE) {
1698 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1699 return TETHERING_ERROR_OPERATION_FAILED;
1703 case TETHERING_TYPE_USB: {
1704 g_dbus_connection_signal_unsubscribe(connection,
1705 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1707 g_dbus_proxy_call(proxy, "enable_usb_tethering",
1708 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1709 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1710 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1714 case TETHERING_TYPE_WIFI: {
1715 _softap_settings_t set = {"", "", "", 0, false, false, 0, 0};
1717 ret = __prepare_wifi_settings(tethering, &set);
1718 if (ret != TETHERING_ERROR_NONE) {
1719 ERR("softap settings initialization failed\n");
1721 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1722 return TETHERING_ERROR_OPERATION_FAILED;
1724 g_dbus_connection_signal_unsubscribe(connection,
1725 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1727 SINFO("ssid %s, key %s, channel %d, mode %s, txpower %d, security %d max_device %d\n",
1728 set.ssid, set.key, set.channel, set.mode, set.txpower, set.sec_type,
1731 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1732 g_variant_new("(sssiiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, set.txpower, TETHERING_ADDRESS_FAMILY_IPV6),
1733 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1734 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1738 case TETHERING_TYPE_BT: {
1739 g_dbus_connection_signal_unsubscribe(connection,
1740 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1742 g_dbus_proxy_call(proxy, "enable_bt_tethering",
1743 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1744 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1745 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1751 ERR("Unknown type : %d\n", type);
1753 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1756 return TETHERING_ERROR_INVALID_PARAMETER;
1760 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1762 return TETHERING_ERROR_NONE;
1765 API int tethering_ipv6_disable(tethering_h tethering, tethering_type_e type)
1767 DBG("+ type : %d\n", type);
1768 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1769 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1770 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1771 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1773 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1774 "parameter(tethering) is NULL\n");
1776 __tethering_h *th = (__tethering_h *)tethering;
1777 GDBusProxy *proxy = th->client_bus_proxy;
1778 GDBusConnection *connection = th->client_bus;
1781 case TETHERING_TYPE_USB:
1782 g_dbus_connection_signal_unsubscribe(connection,
1783 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1785 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1786 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1787 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1788 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1791 case TETHERING_TYPE_WIFI:
1792 DBG("Disable wifi tethering..");
1793 g_dbus_connection_signal_unsubscribe(connection,
1794 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1796 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1797 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1798 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1799 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1802 case TETHERING_TYPE_BT:
1803 g_dbus_connection_signal_unsubscribe(connection,
1804 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1806 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1807 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1808 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1809 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1813 ERR("Not supported tethering type [%d]\n", type);
1815 return TETHERING_ERROR_INVALID_PARAMETER;
1818 return TETHERING_ERROR_NONE;
1822 * @brief Disables the tethering, asynchronously.
1824 * @privlevel platform
1825 * @privilege http://tizen.org/privilege/tethering.admin
1826 * @param[in] tethering The handle of tethering
1827 * @param[in] type The type of tethering
1828 * @return 0 on success, otherwise negative error value.
1829 * @retval #TETHERING_ERROR_NONE Successful
1830 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1831 * @post tethering_disabled_cb() will be invoked.
1832 * @see tethering_is_enabled()
1833 * @see tethering_enable()
1835 API int tethering_disable(tethering_h tethering, tethering_type_e type)
1837 INFO("+ type : %d\n", type);
1838 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1839 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1840 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1841 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1843 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1844 "parameter(tethering) is NULL\n");
1846 __tethering_h *th = (__tethering_h *)tethering;
1847 GDBusProxy *proxy = th->client_bus_proxy;
1848 GDBusConnection *connection = th->client_bus;
1851 case TETHERING_TYPE_USB:
1852 g_dbus_connection_signal_unsubscribe(connection,
1853 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1855 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1856 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1857 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1858 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1862 case TETHERING_TYPE_WIFI:
1864 g_dbus_connection_signal_unsubscribe(connection,
1865 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1867 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1868 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1869 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1870 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1873 case TETHERING_TYPE_BT:
1875 g_dbus_connection_signal_unsubscribe(connection,
1876 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1878 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1879 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1880 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1881 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1884 case TETHERING_TYPE_P2P:
1885 g_dbus_proxy_call(proxy, "disable_p2p_tethering",
1886 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1887 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1890 case TETHERING_TYPE_ALL:
1891 g_dbus_connection_signal_unsubscribe(connection,
1892 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1894 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1895 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1896 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1897 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1899 g_dbus_connection_signal_unsubscribe(connection,
1900 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1902 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1903 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1904 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1905 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1907 g_dbus_connection_signal_unsubscribe(connection,
1908 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1910 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1911 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1912 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1913 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1917 ERR("Not supported tethering type [%d]\n", type);
1919 return TETHERING_ERROR_INVALID_PARAMETER;
1922 return TETHERING_ERROR_NONE;
1927 * @brief Checks whetehr the tethering is enabled or not.
1929 * @privlevel platform
1930 * @privilege http://tizen.org/privilege/tethering.admin
1931 * @param[in] tethering The handle of tethering
1932 * @param[in] type The type of tethering
1933 * @return @c true if tethering is enabled, \n @c false if tethering is disabled.
1935 API bool tethering_is_enabled(tethering_h tethering, tethering_type_e type)
1937 INFO("+ type : %d\n", type);
1939 int vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_NONE;
1941 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1943 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &is_on) != 0)
1947 case TETHERING_TYPE_USB:
1948 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_USB;
1951 case TETHERING_TYPE_WIFI:
1952 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI;
1955 case TETHERING_TYPE_BT:
1956 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_BT;
1959 case TETHERING_TYPE_P2P:
1960 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_P2P;
1964 ERR("Not supported type : %d\n", type);
1967 INFO("- enabled: %s\n", (is_on & vconf_type) ? "true" : "false");
1968 return is_on & vconf_type ? true : false;
1973 * @brief Gets the MAC address of local device as "FC:A1:3E:D6:B1:B1".
1975 * @privlevel platform
1976 * @privilege http://tizen.org/privilege/tethering.admin
1977 * @remarks @a mac_address must be released with free() by you.
1978 * @param[in] tethering The handle of tethering
1979 * @param[in] type The type of tethering
1980 * @param[out] mac_address The MAC address
1981 * @return 0 on success, otherwise a negative error value.
1982 * @retval #TETHERING_ERROR_NONE Successful
1983 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1984 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1985 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
1986 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
1987 * @pre tethering must be enabled.
1988 * @see tethering_is_enabled()
1989 * @see tethering_enable()
1991 API int tethering_get_mac_address(tethering_h tethering, tethering_type_e type, char **mac_address)
1993 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1994 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1995 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1996 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1998 _retvm_if(tethering_is_enabled(tethering, type) == false,
1999 TETHERING_ERROR_NOT_ENABLED,
2000 "tethering type[%d] is not enabled\n", type);
2001 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2002 "parameter(tethering) is NULL\n");
2003 _retvm_if(mac_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2004 "parameter(mac_address) is NULL\n");
2008 char *macbuf = NULL;
2010 _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
2011 TETHERING_ERROR_OPERATION_FAILED,
2012 "getting interface name is failed\n");
2014 s = socket(AF_INET, SOCK_DGRAM, 0);
2015 _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
2016 "getting socket is failed\n");
2017 if (ioctl(s, SIOCGIFHWADDR, &ifr) < 0) {
2018 ERR("getting mac is failed\n");
2020 return TETHERING_ERROR_OPERATION_FAILED;
2024 macbuf = (char *)malloc(TETHERING_STR_INFO_LEN);
2025 _retvm_if(macbuf == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2026 "Not enough memory\n");
2027 snprintf(macbuf, TETHERING_STR_INFO_LEN, "%02X:%02X:%02X:%02X:%02X:%02X",
2028 (unsigned char)ifr.ifr_hwaddr.sa_data[0],
2029 (unsigned char)ifr.ifr_hwaddr.sa_data[1],
2030 (unsigned char)ifr.ifr_hwaddr.sa_data[2],
2031 (unsigned char)ifr.ifr_hwaddr.sa_data[3],
2032 (unsigned char)ifr.ifr_hwaddr.sa_data[4],
2033 (unsigned char)ifr.ifr_hwaddr.sa_data[5]);
2035 *mac_address = macbuf;
2037 return TETHERING_ERROR_NONE;
2042 * @brief Gets the name of network interface. For example, usb0.
2044 * @privlevel platform
2045 * @privilege http://tizen.org/privilege/tethering.admin
2046 * @remarks @a interface_name must be released with free() by you.
2047 * @param[in] tethering The handle of tethering
2048 * @param[in] type The type of tethering
2049 * @param[out] interface_name The name of network interface
2050 * @return 0 on success, otherwise negative error value.
2051 * @retval #TETHERING_ERROR_NONE Successful
2052 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2053 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2054 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2055 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2056 * @pre tethering must be enabled.
2057 * @see tethering_is_enabled()
2058 * @see tethering_enable()
2060 API int tethering_get_network_interface_name(tethering_h tethering, tethering_type_e type, char **interface_name)
2062 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2063 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2064 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2065 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2067 _retvm_if(tethering_is_enabled(tethering, type) == false,
2068 TETHERING_ERROR_NOT_ENABLED,
2069 "tethering type[%d] is not enabled\n", type);
2070 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2071 "parameter(tethering) is NULL\n");
2072 _retvm_if(interface_name == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2073 "parameter(interface_name) is NULL\n");
2075 char intf[TETHERING_STR_INFO_LEN] = {0, };
2077 _retvm_if(!__get_intf_name(type, intf, sizeof(intf)),
2078 TETHERING_ERROR_OPERATION_FAILED,
2079 "getting interface name is failed\n");
2080 *interface_name = strdup(intf);
2081 _retvm_if(*interface_name == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2082 "Not enough memory\n");
2084 return TETHERING_ERROR_NONE;
2089 * @brief Gets the local IP address.
2091 * @privlevel platform
2092 * @privilege http://tizen.org/privilege/tethering.admin
2093 * @remarks @a ip_address must be released with free() by you.
2094 * @param[in] tethering The handle of tethering
2095 * @param[in] type The type of tethering
2096 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2097 * @param[out] ip_address The local IP address
2098 * @return 0 on success, otherwise negative error value.
2099 * @retval #TETHERING_ERROR_NONE Successful
2100 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2101 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2102 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2103 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2104 * @pre tethering must be enabled.
2105 * @see tethering_is_enabled()
2106 * @see tethering_enable()
2108 API int tethering_get_ip_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **ip_address)
2110 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2111 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2112 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2113 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2115 _retvm_if(tethering_is_enabled(tethering, type) == false,
2116 TETHERING_ERROR_NOT_ENABLED,
2117 "tethering type[%d] is not enabled\n", type);
2118 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2119 "parameter(tethering) is NULL\n");
2120 _retvm_if(ip_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2121 "parameter(ip_address) is NULL\n");
2127 _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
2128 TETHERING_ERROR_OPERATION_FAILED,
2129 "getting interface name is failed\n");
2131 s = socket(AF_INET, SOCK_DGRAM, 0);
2132 _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
2133 "getting socket is failed\n");
2134 if (ioctl(s, SIOCGIFADDR, &ifr) < 0) {
2135 ERR("ioctl is failed\n");
2137 return TETHERING_ERROR_OPERATION_FAILED;
2141 ipbuf = inet_ntoa(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr);
2142 *ip_address = strdup(ipbuf);
2143 _retvm_if(*ip_address == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2144 "Not enough memory\n");
2146 return TETHERING_ERROR_NONE;
2151 * @brief Gets the Gateway address.
2153 * @privlevel platform
2154 * @privilege http://tizen.org/privilege/tethering.admin
2155 * @remarks @a gateway_address must be released with free() by you.
2156 * @param[in] tethering The handle of tethering
2157 * @param[in] type The type of tethering
2158 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2159 * @param[out] gateway_address The local IP address
2160 * @return 0 on success, otherwise negative error value.
2161 * @retval #TETHERING_ERROR_NONE Successful
2162 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2163 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2164 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2165 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2166 * @pre tethering must be enabled.
2167 * @see tethering_is_enabled()
2168 * @see tethering_enable()
2170 API int tethering_get_gateway_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **gateway_address)
2172 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2173 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2174 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2175 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2177 _retvm_if(tethering_is_enabled(tethering, type) == false,
2178 TETHERING_ERROR_NOT_ENABLED,
2179 "tethering type[%d] is not enabled\n", type);
2180 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2181 "parameter(tethering) is NULL\n");
2182 _retvm_if(gateway_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2183 "parameter(gateway_address) is NULL\n");
2185 char gateway_buf[TETHERING_STR_INFO_LEN] = {0, };
2187 _retvm_if(!__get_gateway_addr(type, gateway_buf, sizeof(gateway_buf)),
2188 TETHERING_ERROR_OPERATION_FAILED,
2189 "getting gateway address is failed\n");
2191 *gateway_address = strdup(gateway_buf);
2193 return TETHERING_ERROR_NONE;
2198 * @brief Gets the Subnet Mask.
2200 * @privlevel platform
2201 * @privilege http://tizen.org/privilege/tethering.admin
2202 * @remarks @a subnet_mask must be released with free() by you.
2203 * @param[in] tethering The handle of tethering
2204 * @param[in] type The type of tethering
2205 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2206 * @param[out] subnet_mask The local IP address
2207 * @return 0 on success, otherwise negative error value.
2208 * @retval #TETHERING_ERROR_NONE Successful
2209 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2210 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2211 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2212 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2213 * @pre tethering must be enabled.
2214 * @see tethering_is_enabled()
2215 * @see tethering_enable()
2217 API int tethering_get_subnet_mask(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **subnet_mask)
2219 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2220 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2221 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2222 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2224 _retvm_if(tethering_is_enabled(tethering, type) == false,
2225 TETHERING_ERROR_NOT_ENABLED,
2226 "tethering is not enabled\n");
2227 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2228 "parameter(tethering) is NULL\n");
2229 _retvm_if(subnet_mask == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2230 "parameter(subnet_mask) is NULL\n");
2232 *subnet_mask = strdup(TETHERING_SUBNET_MASK);
2233 _retvm_if(*subnet_mask == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2234 "Not enough memory\n");
2236 return TETHERING_ERROR_NONE;
2241 * @brief Gets the data usage.
2243 * @privlevel platform
2244 * @privilege http://tizen.org/privilege/tethering.admin
2245 * @param[in] tethering The handle of tethering
2246 * @param[out] usage The data usage
2247 * @return 0 on success, otherwise negative error value.
2248 * @retval #TETHERING_ERROR_NONE Successful
2249 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2250 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2251 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2252 * @pre tethering must be enabled.
2253 * @see tethering_is_enabled()
2254 * @see tethering_enable()
2256 API int tethering_get_data_usage(tethering_h tethering, tethering_data_usage_cb callback, void *user_data)
2258 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2260 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2261 "parameter(tethering) is NULL\n");
2262 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2263 "parameter(callback) is NULL\n");
2264 _retvm_if(__any_tethering_is_enabled(tethering) == false,
2265 TETHERING_ERROR_NOT_ENABLED,
2266 "tethering is not enabled\n");
2268 __tethering_h *th = (__tethering_h *)tethering;
2269 GDBusProxy *proxy = th->client_bus_proxy;
2271 th->data_usage_cb = callback;
2272 th->data_usage_user_data = user_data;
2274 g_dbus_proxy_call(proxy, "get_data_packet_usage",
2275 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2276 (GAsyncReadyCallback) __get_data_usage_cb, (gpointer)tethering);
2278 return TETHERING_ERROR_NONE;
2283 * @brief Gets the client which is connected by tethering "type".
2285 * @privlevel platform
2286 * @privilege http://tizen.org/privilege/tethering.admin
2287 * @param[in] tethering The handle of tethering
2288 * @param[in] type The type of tethering
2289 * @param[in] callback The callback function to invoke
2290 * @param[in] user_data The user data to be passed to the callback function
2291 * @retval #TETHERING_ERROR_NONE Successful
2292 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2293 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2294 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2295 * @pre tethering must be enabled.
2296 * @see tethering_is_enabled()
2297 * @see tethering_enable()
2299 API int tethering_foreach_connected_clients(tethering_h tethering, tethering_type_e type, tethering_connected_client_cb callback, void *user_data)
2301 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2302 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2303 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2304 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2306 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2307 "parameter(tethering) is NULL\n");
2308 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2309 "parameter(callback) is NULL\n");
2310 _retvm_if(__any_tethering_is_enabled(tethering) == false,
2311 TETHERING_ERROR_NOT_ENABLED,
2312 "tethering is not enabled\n");
2314 mobile_ap_type_e interface;
2315 __tethering_h *th = (__tethering_h *)tethering;
2316 __tethering_client_h client = {0, };
2319 gchar *hostname = NULL;
2320 guint timestamp = 0;
2321 GError *error = NULL;
2322 GVariant *result = NULL;
2323 GVariantIter *outer_iter = NULL;
2324 GVariantIter *inner_iter = NULL;
2325 GVariant *station = NULL;
2326 GVariant *value = NULL;
2329 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "get_station_info",
2330 NULL, G_DBUS_CALL_FLAGS_NONE,
2331 -1, th->cancellable, &error);
2334 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
2335 g_error_free(error);
2336 return TETHERING_ERROR_OPERATION_FAILED;
2339 g_variant_get(result, "(a(a{sv}))", &outer_iter);
2340 while (g_variant_iter_loop(outer_iter, "(@a{sv})", &station)) {
2341 g_variant_get(station, "a{sv}", &inner_iter);
2342 while (g_variant_iter_loop(inner_iter, "{sv}", &key, &value)) {
2343 if (g_strcmp0(key, "Type") == 0) {
2344 interface = g_variant_get_int32(value);
2345 if (interface == MOBILE_AP_TYPE_USB)
2346 client.interface = TETHERING_TYPE_USB;
2347 else if (interface == MOBILE_AP_TYPE_WIFI)
2348 client.interface = TETHERING_TYPE_WIFI;
2349 else if (interface == MOBILE_AP_TYPE_BT)
2350 client.interface = TETHERING_TYPE_BT;
2351 else if (interface == MOBILE_AP_TYPE_P2P)
2352 client.interface = TETHERING_TYPE_P2P;
2354 ERR("Invalid interface\n");
2356 g_variant_unref(value);
2359 DBG("interface is %d\n", client.interface);
2360 if (client.interface != type && (TETHERING_TYPE_ALL != type)) {
2362 g_variant_unref(value);
2365 } else if (g_strcmp0(key, "IP") == 0) {
2366 g_variant_get(value, "s", &ip);
2367 SDBG("ip is %s\n", ip);
2368 g_strlcpy(client.ip, ip, sizeof(client.ip));
2369 } else if (g_strcmp0(key, "MAC") == 0) {
2370 g_variant_get(value, "s", &mac);
2371 SDBG("mac is %s\n", mac);
2372 g_strlcpy(client.mac, mac, sizeof(client.mac));
2373 } else if (g_strcmp0(key, "Name") == 0) {
2374 g_variant_get(value, "s", &hostname);
2375 SDBG("hsotname is %s\n", hostname);
2377 client.hostname = g_strdup(hostname);
2378 } else if (g_strcmp0(key, "Time") == 0) {
2379 timestamp = g_variant_get_int32(value);
2380 DBG("timestamp is %d\n", timestamp);
2381 client.tm = (time_t)timestamp;
2383 ERR("Key %s not required\n", key);
2394 g_variant_iter_free(inner_iter);
2395 if (callback((tethering_client_h)&client, user_data) == false) {
2396 DBG("iteration is stopped\n");
2397 g_free(client.hostname);
2398 client.hostname = NULL;
2399 g_variant_iter_free(outer_iter);
2400 g_variant_unref(result);
2402 return TETHERING_ERROR_OPERATION_FAILED;
2404 g_free(client.hostname);
2405 client.hostname = NULL;
2407 g_variant_iter_free(outer_iter);
2408 g_variant_unref(result);
2410 return TETHERING_ERROR_NONE;
2415 * @brief Registers the callback function called when tethering is enabled.
2417 * @privlevel platform
2418 * @privilege http://tizen.org/privilege/tethering.admin
2419 * @param[in] tethering The handle of tethering
2420 * @param[in] type The type of tethering
2421 * @param[in] callback The callback function to invoke
2422 * @param[in] user_data The user data to be passed to the callback function
2423 * @retval #TETHERING_ERROR_NONE Successful
2424 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2425 * @see tethering_unset_enabled_cb()
2427 API int tethering_set_enabled_cb(tethering_h tethering, tethering_type_e type, tethering_enabled_cb callback, void *user_data)
2429 INFO("+ type: %d\n", type);
2430 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2431 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2432 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2433 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2435 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2436 "parameter(tethering) is NULL\n");
2437 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2438 "parameter(callback) is NULL\n");
2440 __tethering_h *th = (__tethering_h *)tethering;
2441 tethering_type_e ti;
2443 if (type != TETHERING_TYPE_ALL) {
2444 th->enabled_cb[type] = callback;
2445 th->enabled_user_data[type] = user_data;
2447 return TETHERING_ERROR_NONE;
2450 /* TETHERING_TYPE_ALL */
2451 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2452 th->enabled_cb[ti] = callback;
2453 th->enabled_user_data[ti] = user_data;
2457 return TETHERING_ERROR_NONE;
2462 * @brief Unregisters the callback function called when tethering is disabled.
2464 * @privlevel platform
2465 * @privilege http://tizen.org/privilege/tethering.admin
2466 * @param[in] tethering The handle of tethering
2467 * @param[in] type The type of tethering
2468 * @retval #TETHERING_ERROR_NONE Successful
2469 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2470 * @see tethering_set_enabled_cb()
2472 API int tethering_unset_enabled_cb(tethering_h tethering, tethering_type_e type)
2474 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2475 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2476 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2477 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2479 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2480 "parameter(tethering) is NULL\n");
2482 __tethering_h *th = (__tethering_h *)tethering;
2483 tethering_type_e ti;
2485 if (type != TETHERING_TYPE_ALL) {
2486 th->enabled_cb[type] = NULL;
2487 th->enabled_user_data[type] = NULL;
2489 return TETHERING_ERROR_NONE;
2492 /* TETHERING_TYPE_ALL */
2493 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2494 th->enabled_cb[ti] = NULL;
2495 th->enabled_user_data[ti] = NULL;
2498 return TETHERING_ERROR_NONE;
2503 * @brief Registers the callback function called when tethering is disabled.
2505 * @privlevel platform
2506 * @privilege http://tizen.org/privilege/tethering.admin
2507 * @param[in] tethering The handle of tethering
2508 * @param[in] type The type of tethering
2509 * @param[in] callback The callback function to invoke
2510 * @param[in] user_data The user data to be passed to the callback function
2511 * @retval #TETHERING_ERROR_NONE Successful
2512 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2513 * @see tethering_unset_disabled_cb()
2515 API int tethering_set_disabled_cb(tethering_h tethering, tethering_type_e type, tethering_disabled_cb callback, void *user_data)
2517 INFO("+ type: %d\n", type);
2518 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2519 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2520 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2521 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2523 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2524 "parameter(tethering) is NULL\n");
2525 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2526 "parameter(callback) is NULL\n");
2528 __tethering_h *th = (__tethering_h *)tethering;
2529 tethering_type_e ti;
2531 if (type != TETHERING_TYPE_ALL) {
2532 th->disabled_cb[type] = callback;
2533 th->disabled_user_data[type] = user_data;
2535 return TETHERING_ERROR_NONE;
2538 /* TETHERING_TYPE_ALL */
2539 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2540 th->disabled_cb[ti] = callback;
2541 th->disabled_user_data[ti] = user_data;
2544 return TETHERING_ERROR_NONE;
2549 * @brief Unregisters the callback function called when tethering is disabled.
2551 * @privlevel platform
2552 * @privilege http://tizen.org/privilege/tethering.admin
2553 * @param[in] tethering The handle of tethering
2554 * @param[in] type The type of tethering
2555 * @retval #TETHERING_ERROR_NONE Successful
2556 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2557 * @see tethering_set_disabled_cb()
2559 API int tethering_unset_disabled_cb(tethering_h tethering, tethering_type_e type)
2561 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2562 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2563 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2564 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2566 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2567 "parameter(tethering) is NULL\n");
2569 __tethering_h *th = (__tethering_h *)tethering;
2570 tethering_type_e ti;
2572 if (type != TETHERING_TYPE_ALL) {
2573 th->disabled_cb[type] = NULL;
2574 th->disabled_user_data[type] = NULL;
2576 return TETHERING_ERROR_NONE;
2579 /* TETHERING_TYPE_ALL */
2580 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2581 th->disabled_cb[ti] = NULL;
2582 th->disabled_user_data[ti] = NULL;
2585 return TETHERING_ERROR_NONE;
2590 * @brief Registers the callback function called when the state of connection is changed.
2592 * @privlevel platform
2593 * @privilege http://tizen.org/privilege/tethering.admin
2594 * @param[in] tethering The handle of tethering
2595 * @param[in] type The type of tethering
2596 * @param[in] callback The callback function to invoke
2597 * @param[in] user_data The user data to be passed to the callback function
2598 * @retval #TETHERING_ERROR_NONE Successful
2599 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2600 * @see tethering_unset_connection_state_changed_cb_cb()
2602 API int tethering_set_connection_state_changed_cb(tethering_h tethering, tethering_type_e type, tethering_connection_state_changed_cb callback, void *user_data)
2604 INFO("+ type: %d\n", type);
2605 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2606 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2607 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2608 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2610 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2611 "parameter(tethering) is NULL\n");
2612 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2613 "parameter(callback) is NULL\n");
2615 __tethering_h *th = (__tethering_h *)tethering;
2616 tethering_type_e ti;
2618 if (type != TETHERING_TYPE_ALL) {
2619 th->changed_cb[type] = callback;
2620 th->changed_user_data[type] = user_data;
2622 return TETHERING_ERROR_NONE;
2625 /* TETHERING_TYPE_ALL */
2626 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2627 th->changed_cb[ti] = callback;
2628 th->changed_user_data[ti] = user_data;
2631 return TETHERING_ERROR_NONE;
2636 * @brief Unregisters the callback function called when the state of connection is changed.
2638 * @privlevel platform
2639 * @privilege http://tizen.org/privilege/tethering.admin
2640 * @param[in] tethering The handle of tethering
2641 * @param[in] type The type of tethering
2642 * @retval #TETHERING_ERROR_NONE Successful
2643 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2644 * @see tethering_set_connection_state_changed_cb()
2646 API int tethering_unset_connection_state_changed_cb(tethering_h tethering, tethering_type_e type)
2648 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2649 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2650 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2651 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2653 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2654 "parameter(tethering) is NULL\n");
2656 __tethering_h *th = (__tethering_h *)tethering;
2657 tethering_type_e ti;
2659 if (type != TETHERING_TYPE_ALL) {
2660 th->changed_cb[type] = NULL;
2661 th->changed_user_data[type] = NULL;
2663 return TETHERING_ERROR_NONE;
2666 /* TETHERING_TYPE_ALL */
2667 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2668 th->changed_cb[ti] = NULL;
2669 th->changed_user_data[ti] = NULL;
2672 return TETHERING_ERROR_NONE;
2677 * @brief Registers the callback function called when the security type of Wi-Fi tethering is changed.
2679 * @privlevel platform
2680 * @privilege http://tizen.org/privilege/tethering.admin
2681 * @param[in] tethering The handle of tethering
2682 * @param[in] callback The callback function to invoke
2683 * @param[in] user_data The user data to be passed to the callback function
2684 * @retval #TETHERING_ERROR_NONE Successful
2685 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2686 * @see tethering_wifi_unset_security_type_changed_cb()
2688 API int tethering_wifi_set_security_type_changed_cb(tethering_h tethering, tethering_wifi_security_type_changed_cb callback, void *user_data)
2690 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2691 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2693 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2694 "parameter(tethering) is NULL\n");
2695 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2696 "parameter(callback) is NULL\n");
2698 __tethering_h *th = (__tethering_h *)tethering;
2700 th->security_type_changed_cb = callback;
2701 th->security_type_user_data = user_data;
2703 return TETHERING_ERROR_NONE;
2709 * @brief Unregisters the callback function called when the security type of Wi-Fi tethering is changed.
2711 * @privlevel platform
2712 * @privilege http://tizen.org/privilege/tethering.admin
2713 * @param[in] tethering The handle of tethering
2714 * @param[in] type The type of tethering
2715 * @retval #TETHERING_ERROR_NONE Successful
2716 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2717 * @see tethering_wifi_set_security_type_changed_cb()
2719 API int tethering_wifi_unset_security_type_changed_cb(tethering_h tethering)
2721 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2722 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2724 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2725 "parameter(tethering) is NULL\n");
2727 __tethering_h *th = (__tethering_h *)tethering;
2729 th->security_type_changed_cb = NULL;
2730 th->security_type_user_data = NULL;
2732 return TETHERING_ERROR_NONE;
2737 * @brief Registers the callback function called when the visibility of SSID is changed.
2739 * @privlevel platform
2740 * @privilege http://tizen.org/privilege/tethering.admin
2741 * @param[in] tethering The handle of tethering
2742 * @param[in] callback The callback function to invoke
2743 * @param[in] user_data The user data to be passed to the callback function
2744 * @retval #TETHERING_ERROR_NONE Successful
2745 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2746 * @see tethering_wifi_unset_ssid_visibility_changed_cb_cb()
2748 API int tethering_wifi_set_ssid_visibility_changed_cb(tethering_h tethering, tethering_wifi_ssid_visibility_changed_cb callback, void *user_data)
2750 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2751 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2753 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2754 "parameter(tethering) is NULL\n");
2755 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2756 "parameter(callback) is NULL\n");
2758 __tethering_h *th = (__tethering_h *)tethering;
2760 th->ssid_visibility_changed_cb = callback;
2761 th->ssid_visibility_user_data = user_data;
2763 return TETHERING_ERROR_NONE;
2768 * @brief Unregisters the callback function called when the visibility of SSID is changed.
2770 * @privlevel platform
2771 * @privilege http://tizen.org/privilege/tethering.admin
2772 * @param[in] tethering The handle of tethering
2773 * @retval #TETHERING_ERROR_NONE Successful
2774 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2775 * @see tethering_wifi_set_ssid_visibility_changed_cb()
2777 API int tethering_wifi_unset_ssid_visibility_changed_cb(tethering_h tethering)
2779 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2780 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2782 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2783 "parameter(tethering) is NULL\n");
2785 __tethering_h *th = (__tethering_h *)tethering;
2787 th->ssid_visibility_changed_cb = NULL;
2788 th->ssid_visibility_user_data = NULL;
2790 return TETHERING_ERROR_NONE;
2795 * @brief Registers the callback function called when the passphrase of Wi-Fi tethering is changed.
2797 * @privlevel platform
2798 * @privilege http://tizen.org/privilege/tethering.admin
2799 * @param[in] tethering The handle of tethering
2800 * @param[in] callback The callback function to invoke
2801 * @param[in] user_data The user data to be passed to the callback function
2802 * @retval #TETHERING_ERROR_NONE Successful
2803 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2804 * @see tethering_wifi_unset_passphrase_changed_cb()
2806 API int tethering_wifi_set_passphrase_changed_cb(tethering_h tethering, tethering_wifi_passphrase_changed_cb callback, void *user_data)
2808 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2809 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2811 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2812 "parameter(tethering) is NULL\n");
2813 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2814 "parameter(callback) is NULL\n");
2816 __tethering_h *th = (__tethering_h *)tethering;
2818 th->passphrase_changed_cb = callback;
2819 th->passphrase_user_data = user_data;
2821 return TETHERING_ERROR_NONE;
2826 * @brief Unregisters the callback function called when the passphrase of Wi-Fi tethering is changed.
2828 * @privlevel platform
2829 * @privilege http://tizen.org/privilege/tethering.admin
2830 * @param[in] tethering The handle of tethering
2831 * @retval #TETHERING_ERROR_NONE Successful
2832 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2833 * @see tethering_wifi_set_passphrase_changed_cb()
2835 API int tethering_wifi_unset_passphrase_changed_cb(tethering_h tethering)
2837 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2838 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2840 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2841 "parameter(tethering) is NULL\n");
2843 __tethering_h *th = (__tethering_h *)tethering;
2845 th->passphrase_changed_cb = NULL;
2846 th->passphrase_user_data = NULL;
2848 return TETHERING_ERROR_NONE;
2853 * @brief Sets the security type of Wi-Fi tethering.
2855 * @privlevel platform
2856 * @privilege http://tizen.org/privilege/tethering.admin
2857 * @remarks This change is applied next time Wi-Fi tethering is enabled
2858 * @param[in] tethering The handle of tethering
2859 * @param[in] type The security type
2860 * @return 0 on success, otherwise negative error value.
2861 * @retval #TETHERING_ERROR_NONE Successful
2862 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2863 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2864 * @see tethering_wifi_get_security_type()
2866 API int tethering_wifi_set_security_type(tethering_h tethering, tethering_wifi_security_type_e type)
2868 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2869 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2871 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2872 "parameter(tethering) is NULL\n");
2874 __tethering_h *th = (__tethering_h *)tethering;
2875 tethering_error_e ret = TETHERING_ERROR_NONE;
2876 char *sec_str = NULL;
2878 ret = __set_security_type(type);
2879 if (ret == TETHERING_ERROR_NONE) {
2881 case TETHERING_WIFI_SECURITY_TYPE_NONE:
2882 sec_str = TETHERING_WIFI_SECURITY_TYPE_OPEN_STR;
2884 case TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK:
2885 sec_str = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR;
2887 case TETHERING_WIFI_SECURITY_TYPE_WPS:
2888 sec_str = TETHERING_WIFI_SECURITY_TYPE_WPS_STR;
2890 case TETHERING_WIFI_SECURITY_TYPE_SAE:
2891 sec_str = TETHERING_WIFI_SECURITY_TYPE_SAE_STR;
2895 __send_dbus_signal(th->client_bus,
2896 SIGNAL_NAME_SECURITY_TYPE_CHANGED, sec_str);
2903 * @brief Gets the security type of Wi-Fi tethering.
2905 * @privlevel platform
2906 * @privilege http://tizen.org/privilege/tethering.admin
2907 * @param[in] tethering The handle of tethering
2908 * @param[out] type The security type
2909 * @return 0 on success, otherwise negative error value.
2910 * @retval #TETHERING_ERROR_NONE Successful
2911 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2912 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2913 * @see tethering_wifi_set_security_type()
2915 API int tethering_wifi_get_security_type(tethering_h tethering, tethering_wifi_security_type_e *type)
2917 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2918 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2920 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2921 "parameter(tethering) is NULL\n");
2922 _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2923 "parameter(type) is NULL\n");
2925 return __get_security_type(type);
2930 * @brief Sets the SSID (service set identifier).
2932 * @privlevel platform
2933 * @privilege http://tizen.org/privilege/tethering.admin
2934 * @details If SSID is not set, Device name is used as SSID
2935 * @remarks This change is applied next time Wi-Fi tethering is enabled with same @a tethering handle
2936 * @param[in] tethering The handle of tethering
2937 * @param[out] ssid The SSID
2938 * @return 0 on success, otherwise negative error value.
2939 * @retval #TETHERING_ERROR_NONE Successful
2940 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2941 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2943 API int tethering_wifi_set_ssid(tethering_h tethering, const char *ssid)
2945 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2946 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2948 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2949 "parameter(tethering) is NULL\n");
2950 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2951 "parameter(ssid) is NULL\n");
2953 __tethering_h *th = (__tethering_h *)tethering;
2954 char *p_ssid = NULL;
2957 ssid_len = strlen(ssid);
2958 if (ssid_len > TETHERING_WIFI_SSID_MAX_LEN) {
2959 ERR("parameter(ssid) is too long");
2960 return TETHERING_ERROR_INVALID_PARAMETER;
2963 p_ssid = strdup(ssid);
2964 _retvm_if(p_ssid == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2965 "strdup is failed\n");
2971 return TETHERING_ERROR_NONE;
2976 * @brief Gets the SSID (service set identifier).
2978 * @privlevel platform
2979 * @privilege http://tizen.org/privilege/tethering.admin
2980 * @remarks @a ssid must be released with free() by you.
2981 * @param[in] tethering The handle of tethering
2982 * @param[out] ssid The SSID
2983 * @return 0 on success, otherwise negative error value.
2984 * @retval #TETHERING_ERROR_NONE Successful
2985 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2986 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2987 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2989 API int tethering_wifi_get_ssid(tethering_h tethering, char **ssid)
2991 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2992 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2994 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2995 "parameter(tethering) is NULL\n");
2996 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2997 "parameter(ssid) is NULL\n");
3000 __tethering_h *th = (__tethering_h *)tethering;
3001 char val[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
3003 if (!tethering_is_enabled(NULL, TETHERING_TYPE_WIFI)) {
3004 if (th->ssid != NULL) {
3005 DBG("Private SSID is set\n");
3006 *ssid = strdup(th->ssid);
3008 if (__get_ssid_from_vconf(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
3009 val, sizeof(val)) == false) {
3010 return TETHERING_ERROR_OPERATION_FAILED;
3012 *ssid = strdup(val);
3015 if (__get_ssid_from_vconf(VCONFKEY_MOBILE_HOTSPOT_SSID,
3016 val, sizeof(val)) == false) {
3017 return TETHERING_ERROR_OPERATION_FAILED;
3019 *ssid = strdup(val);
3022 if (*ssid == NULL) {
3023 ERR("strdup is failed\n");
3024 return TETHERING_ERROR_OUT_OF_MEMORY;
3027 return TETHERING_ERROR_NONE;
3032 * @brief Sets the visibility of SSID(service set identifier).
3034 * @privlevel platform
3035 * @privilege http://tizen.org/privilege/tethering.admin
3036 * @details If you set the visibility invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
3037 * @remarks This change is applied next time Wi-Fi tethering is enabled
3038 * @param[in] tethering The handle of tethering
3039 * @param[in] visible The visibility of SSID: (@c true = visible, @c false = invisible)
3040 * @return 0 on success, otherwise negative error value.
3041 * @retval #TETHERING_ERROR_NONE Successful
3042 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3043 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3044 * @see tethering_wifi_get_ssid_visibility()
3046 API int tethering_wifi_set_ssid_visibility(tethering_h tethering, bool visible)
3048 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3049 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3051 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3052 "parameter(tethering) is NULL\n");
3054 __tethering_h *th = (__tethering_h *)tethering;
3055 tethering_error_e ret = TETHERING_ERROR_NONE;
3057 ret = __set_visible(visible);
3058 if (ret == TETHERING_ERROR_NONE) {
3059 __send_dbus_signal(th->client_bus,
3060 SIGNAL_NAME_SSID_VISIBILITY_CHANGED,
3061 visible ? SIGNAL_MSG_SSID_VISIBLE :
3062 SIGNAL_MSG_SSID_HIDE);
3069 * @brief Gets the visibility of SSID(service set identifier).
3071 * @privlevel platform
3072 * @privilege http://tizen.org/privilege/tethering.admin
3073 * @details If the visibility is set invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
3074 * @param[in] tethering The handle of tethering
3075 * @param[out] visible The visibility of SSID: (@c true = visible, @c false = invisible)
3076 * @return 0 on success, otherwise negative error value.
3077 * @retval #TETHERING_ERROR_NONE Successful
3078 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3079 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3080 * @see tethering_wifi_set_ssid_visibility()
3082 API int tethering_wifi_get_ssid_visibility(tethering_h tethering, bool *visible)
3084 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3085 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3087 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3088 "parameter(tethering) is NULL\n");
3089 _retvm_if(visible == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3090 "parameter(visible) is NULL\n");
3092 return __get_visible(visible);
3097 * @brief Sets the passphrase.
3099 * @privlevel platform
3100 * @privilege http://tizen.org/privilege/tethering.admin
3101 * @remarks This change is applied next time Wi-Fi tethering is enabled
3102 * @param[in] tethering The handle of tethering
3103 * @param[in] passphrase The passphrase
3104 * @return 0 on success, otherwise negative error value.
3105 * @retval #TETHERING_ERROR_NONE Successful
3106 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3107 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3108 * @see tethering_wifi_get_passphrase()
3110 API int tethering_wifi_set_passphrase(tethering_h tethering, const char *passphrase)
3112 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3113 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3115 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3116 "parameter(tethering) is NULL\n");
3117 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3118 "parameter(passphrase) is NULL\n");
3120 __tethering_h *th = (__tethering_h *)tethering;
3121 GDBusProxy *proxy = th->client_bus_proxy;
3122 GVariant *parameters;
3123 GError *error = NULL;
3124 int passphrase_len = 0;
3128 passphrase_len = strlen(passphrase);
3129 if (passphrase_len < TETHERING_WIFI_KEY_MIN_LEN ||
3130 passphrase_len > TETHERING_WIFI_KEY_MAX_LEN) {
3131 ERR("parameter(passphrase) is too short or long\n");
3132 return TETHERING_ERROR_INVALID_PARAMETER;
3135 parameters = g_dbus_proxy_call_sync(proxy, "set_wifi_tethering_passphrase",
3136 g_variant_new("(s)", passphrase), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3139 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3141 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3142 ret = TETHERING_ERROR_PERMISSION_DENIED;
3144 ret = TETHERING_ERROR_OPERATION_FAILED;
3146 g_error_free(error);
3150 g_variant_get(parameters, "(u)", &ret);
3151 g_variant_unref(parameters);
3153 if (ret == TETHERING_ERROR_NONE) {
3154 __send_dbus_signal(th->client_bus,
3155 SIGNAL_NAME_PASSPHRASE_CHANGED, NULL);
3164 * @brief Gets the passphrase.
3166 * @privlevel platform
3167 * @privilege http://tizen.org/privilege/tethering.admin
3168 * @remarks @a passphrase must be released with free() by you.
3169 * @param[in] tethering The handle of tethering
3170 * @param[out] passphrase The passphrase
3171 * @return 0 on success, otherwise negative error value.
3172 * @retval #TETHERING_ERROR_NONE Successful
3173 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3174 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
3175 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3176 * @see tethering_wifi_set_passphrase()
3178 API int tethering_wifi_get_passphrase(tethering_h tethering, char **passphrase)
3180 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3181 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3183 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3184 "parameter(tethering) is NULL\n");
3185 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3186 "parameter(passphrase) is NULL\n");
3188 __tethering_h *th = (__tethering_h *)tethering;
3189 GDBusProxy *proxy = th->client_bus_proxy;
3190 GVariant *parameters;
3191 GError *error = NULL;
3192 unsigned int len = 0;
3193 tethering_error_e ret = TETHERING_ERROR_NONE;
3195 parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_passphrase",
3196 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3199 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3201 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3202 ret = TETHERING_ERROR_PERMISSION_DENIED;
3204 ret = TETHERING_ERROR_OPERATION_FAILED;
3206 g_error_free(error);
3210 if (parameters != NULL) {
3211 g_variant_get(parameters, "(siu)", passphrase, &len, &ret);
3212 g_variant_unref(parameters);
3215 return TETHERING_ERROR_NONE;
3218 API int tethering_wifi_set_channel(tethering_h tethering, int channel)
3220 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3221 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3223 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3224 "parameter(tethering) is NULL\n");
3226 __tethering_h *th = (__tethering_h *)tethering;
3227 th->channel = channel;
3229 return TETHERING_ERROR_NONE;
3232 API int tethering_wifi_get_channel(tethering_h tethering, int *channel)
3234 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3235 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3237 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3238 "parameter(tethering) is NULL\n");
3240 _retvm_if(channel == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3241 "parameter(channel) is NULL\n");
3243 __tethering_h *th = (__tethering_h *)tethering;
3244 *channel = th->channel;
3246 return TETHERING_ERROR_NONE;
3249 API int tethering_wifi_set_mode(tethering_h tethering, tethering_wifi_mode_type_e type)
3251 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3252 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3254 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3255 "parameter(tethering) is NULL\n");
3257 __tethering_h *th = (__tethering_h *)tethering;
3259 th->mode_type = type;
3261 return TETHERING_ERROR_NONE;
3264 API int tethering_wifi_get_mode(tethering_h tethering, tethering_wifi_mode_type_e *type)
3266 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3267 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3269 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3270 "parameter(tethering) is NULL\n");
3271 _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3272 "parameter(type) is NULL\n");
3274 __tethering_h *th = (__tethering_h *)tethering;
3275 *type = th->mode_type;
3277 return TETHERING_ERROR_NONE;
3283 * @brief Reload the settings (SSID / Passphrase / Security type / SSID visibility).
3285 * @privlevel platform
3286 * @privilege http://tizen.org/privilege/tethering.admin
3287 * @remarks Connected devices via Wi-Fi tethering or MobileAP will be disconnected when the settings are reloaded
3288 * @param[in] tethering The handle of tethering
3289 * @param[in] callback The callback function to invoke
3290 * @param[in] user_data The user data to be passed to the callback function
3291 * @return 0 on success, otherwise negative error value.
3292 * @retval #TETHERING_ERROR_NONE Successful
3293 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3294 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3296 API int tethering_wifi_reload_settings(tethering_h tethering, tethering_wifi_settings_reloaded_cb callback, void *user_data)
3299 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3300 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3302 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3303 "parameter(tethering) is NULL\n");
3304 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3305 "parameter(callback) is NULL\n");
3307 __tethering_h *th = (__tethering_h *)tethering;
3308 _softap_settings_t set = {"", "", "", 0, false};
3309 GDBusProxy *proxy = th->client_bus_proxy;
3314 if (th->settings_reloaded_cb) {
3315 ERR("Operation in progress\n");
3316 return TETHERING_ERROR_OPERATION_FAILED;
3319 ret = __prepare_wifi_settings(tethering, &set);
3320 if (ret != TETHERING_ERROR_NONE) {
3321 ERR("softap settings initialization failed\n");
3322 return TETHERING_ERROR_OPERATION_FAILED;
3325 th->settings_reloaded_cb = callback;
3326 th->settings_reloaded_user_data = user_data;
3328 SINFO("ssid %s, key %s, channel %d, mode %s, txpower %d, security %d max_device %d\n",
3329 set.ssid, set.key, set.channel, set.mode, set.txpower, set.sec_type,
3332 g_dbus_proxy_call(proxy, "reload_wifi_settings",
3333 g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, set.txpower),
3334 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
3335 (GAsyncReadyCallback) __settings_reloaded_cb, (gpointer)tethering);
3337 return TETHERING_ERROR_NONE;
3340 API int tethering_wifi_set_mac_filter(tethering_h tethering, bool mac_filter)
3342 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3343 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3345 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3346 "parameter(tethering) is NULL\n");
3348 __tethering_h *th = (__tethering_h *)tethering;
3349 th->mac_filter = mac_filter;
3351 return TETHERING_ERROR_NONE;
3354 API int tethering_wifi_get_mac_filter(tethering_h tethering, bool *mac_filter)
3356 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3357 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3359 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3360 "parameter(mac_filter) is NULL\n");
3361 _retvm_if(mac_filter == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3362 "parameter(mac_filter) is NULL\n");
3364 __tethering_h *th = (__tethering_h *)tethering;
3365 *mac_filter = th->mac_filter;
3367 return TETHERING_ERROR_NONE;
3370 static int __add_mac_to_file(const char *filepath, const char *mac)
3373 char line[MAX_BUF_SIZE] = "\0";
3374 bool mac_exist = false;
3377 fp = fopen(filepath, "a+");
3379 ERR("fopen is failed\n");
3380 return TETHERING_ERROR_OPERATION_FAILED;
3383 while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
3384 if (strncmp(mac, line, 17) == 0) {
3385 DBG("MAC %s already exist in the list\n", mac);
3392 p_mac = strdup(mac);
3393 if (p_mac == NULL) {
3394 ERR("strdup failed\n");
3396 return TETHERING_ERROR_OUT_OF_MEMORY;
3399 fprintf(fp, "%s\n", mac);
3401 if ((strcmp(filepath, ALLOWED_LIST) == 0))
3402 allowed_list = g_slist_append(allowed_list, p_mac);
3403 else if ((strcmp(filepath, BLOCKED_LIST) == 0))
3404 blocked_list = g_slist_append(blocked_list, p_mac);
3411 return TETHERING_ERROR_NONE;
3414 static int __remove_mac_from_file(const char *filepath, const char *mac)
3418 char line[MAX_BUF_SIZE] = "\0";
3420 fp = fopen(filepath, "r");
3422 ERR("fopen is failed\n");
3423 return TETHERING_ERROR_OPERATION_FAILED;
3426 fp1 = fopen(TEMP_LIST, "w+");
3429 ERR("fopen is failed\n");
3430 return TETHERING_ERROR_OPERATION_FAILED;
3433 while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
3434 if (strncmp(mac, line, 17) == 0) {
3435 DBG("MAC %s found in the list\n", mac);
3437 if ((strcmp(filepath, ALLOWED_LIST) == 0)) {
3438 GSList *list = NULL;
3439 for (list = allowed_list; list != NULL; list = list->next) {
3440 char *p_mac = (char *)list->data;
3441 if (strncmp(mac, p_mac, strlen(mac)) == 0)
3442 allowed_list = g_slist_remove(allowed_list, p_mac);
3444 } else if ((strcmp(filepath, BLOCKED_LIST) == 0)) {
3445 GSList *list = NULL;
3446 for (list = blocked_list; list != NULL; list = list->next) {
3447 char *p_mac = (char *)list->data;
3448 if (strncmp(mac, p_mac, strlen(mac)) == 0)
3449 blocked_list = g_slist_remove(blocked_list, p_mac);
3453 fprintf(fp1, "%s", line);
3460 if ((strcmp(filepath, ALLOWED_LIST) == 0)) {
3461 if (rename(TEMP_LIST, ALLOWED_LIST) != 0) {
3462 ERR("rename is failed (%s -> %s)", TEMP_LIST, ALLOWED_LIST);
3463 return TETHERING_ERROR_OPERATION_FAILED;
3465 } else if ((strcmp(filepath, BLOCKED_LIST) == 0)) {
3466 if (rename(TEMP_LIST, BLOCKED_LIST) != 0) {
3467 ERR("rename is failed (%s -> %s)", TEMP_LIST, BLOCKED_LIST);
3468 return TETHERING_ERROR_OPERATION_FAILED;
3472 return TETHERING_ERROR_NONE;
3475 API int tethering_wifi_add_allowed_mac_list(tethering_h tethering, const char *mac)
3477 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3478 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3480 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3481 "parameter(tethering) is NULL\n");
3482 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3483 "parameter(mac) is NULL\n");
3485 return __add_mac_to_file(ALLOWED_LIST, mac);
3488 API int tethering_wifi_remove_allowed_mac_list(tethering_h tethering, const char *mac)
3490 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3491 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3493 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3494 "parameter(tethering) is NULL\n");
3495 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3496 "parameter(mac) is NULL\n");
3498 return __remove_mac_from_file(ALLOWED_LIST, mac);
3501 API int tethering_wifi_get_allowed_mac_list(tethering_h tethering, void **allowed_mac_list)
3503 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3504 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3506 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3507 "parameter(tethering) is NULL\n");
3508 _retvm_if(allowed_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3509 "parameter(allowed_mac_list) is NULL\n");
3511 *allowed_mac_list = g_slist_copy(allowed_list);
3512 return TETHERING_ERROR_NONE;
3515 API int tethering_wifi_add_blocked_mac_list(tethering_h tethering, const char *mac)
3517 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3518 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3520 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3521 "parameter(tethering) is NULL\n");
3522 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3523 "parameter(mac) is NULL\n");
3525 return __add_mac_to_file(BLOCKED_LIST, mac);
3528 API int tethering_wifi_remove_blocked_mac_list(tethering_h tethering, const char *mac)
3530 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3531 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3533 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3534 "parameter(tethering) is NULL\n");
3535 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3536 "parameter(mac) is NULL\n");
3538 return __remove_mac_from_file(BLOCKED_LIST, mac);
3541 API int tethering_wifi_get_blocked_mac_list(tethering_h tethering, void **blocked_mac_list)
3543 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3544 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3546 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3547 "parameter(tethering) is NULL\n");
3548 _retvm_if(blocked_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3549 "parameter(blocked_mac_list) is NULL\n");
3551 *blocked_mac_list = g_slist_copy(blocked_list);
3552 return TETHERING_ERROR_NONE;
3555 API int tethering_wifi_enable_dhcp(tethering_h tethering, bool enable)
3557 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3558 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3560 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3561 "parameter(tethering) is NULL\n");
3563 GVariant *parameters;
3564 GError *error = NULL;
3567 __tethering_h *th = (__tethering_h *)tethering;
3569 GDBusProxy *proxy = th->client_bus_proxy;
3571 parameters = g_dbus_proxy_call_sync(proxy, "enable_dhcp",
3572 g_variant_new("(b)", enable),
3573 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3576 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3577 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3578 result = TETHERING_ERROR_PERMISSION_DENIED;
3580 result = TETHERING_ERROR_OPERATION_FAILED;
3582 g_error_free(error);
3583 th->dhcp_enabled = false;
3588 g_variant_get(parameters, "(u)", &result);
3589 g_variant_unref(parameters);
3592 th->dhcp_enabled = true;
3594 th->dhcp_enabled = false;
3596 return TETHERING_ERROR_NONE;
3599 API int tethering_wifi_set_dhcp_range(tethering_h tethering, char *rangestart, char *rangestop)
3601 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3602 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3604 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3605 "parameter(tethering) is NULL\n");
3606 _retvm_if(rangestart == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3607 "parameter(rangestart) is NULL\n");
3608 _retvm_if(rangestop == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3609 "parameter(rangestop) is NULL\n");
3611 GVariant *parameters;
3612 GError *error = NULL;
3615 __tethering_h *th = (__tethering_h *)tethering;
3617 GDBusProxy *proxy = th->client_bus_proxy;
3619 parameters = g_dbus_proxy_call_sync(proxy, "dhcp_range",
3620 g_variant_new("(ss)", rangestart, rangestop),
3621 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3623 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3625 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3626 result = TETHERING_ERROR_PERMISSION_DENIED;
3628 result = TETHERING_ERROR_OPERATION_FAILED;
3630 g_error_free(error);
3631 th->dhcp_enabled = false;
3636 g_variant_get(parameters, "(u)", &result);
3637 g_variant_unref(parameters);
3639 th->dhcp_enabled = true;
3641 return TETHERING_ERROR_NONE;
3644 API int tethering_wifi_is_dhcp_enabled(tethering_h tethering, bool *dhcp_enabled)
3646 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3647 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3649 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3650 "parameter(tethering) is NULL\n");
3651 _retvm_if(dhcp_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3652 "parameter(dhcp_enabled) is NULL\n");
3654 __tethering_h *th = (__tethering_h *)tethering;
3655 *dhcp_enabled = th->dhcp_enabled;
3657 return TETHERING_ERROR_NONE;
3660 API int tethering_wifi_set_txpower(tethering_h tethering, unsigned int txpower)
3662 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3663 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3665 GError *error = NULL;
3667 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3668 "parameter(tethering) 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);
3672 __tethering_h *th = (__tethering_h *)tethering;
3673 th->txpower = txpower;
3675 g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_set_txpower",
3676 g_variant_new("(u)", txpower),
3677 G_DBUS_CALL_FLAGS_NONE,
3678 -1, th->cancellable, &error);
3680 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
3681 g_clear_error(&error);
3682 return TETHERING_ERROR_OPERATION_FAILED;
3684 return TETHERING_ERROR_NONE;
3687 API int tethering_wifi_get_txpower(tethering_h tethering, unsigned int *txpower)
3689 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3690 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3692 GError *error = NULL;
3693 GVariant *result = NULL;
3695 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3696 "parameter(tethering) is NULL\n");
3697 _retvm_if(txpower == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3698 "parameter(txpower) is NULL\n");
3699 _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false,
3700 TETHERING_ERROR_NOT_ENABLED,
3701 "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
3703 __tethering_h *th = (__tethering_h *)tethering;
3705 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_get_txpower",
3707 G_DBUS_CALL_FLAGS_NONE,
3708 -1, th->cancellable, &error);
3710 if (result != NULL) {
3711 g_variant_get(result, "(u)", txpower);
3712 g_variant_unref(result);
3715 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
3716 g_clear_error(&error);
3717 return TETHERING_ERROR_OPERATION_FAILED;
3719 g_clear_error(&error);
3720 return TETHERING_ERROR_NONE;
3723 API int tethering_wifi_set_mtu(tethering_h tethering, unsigned int mtu)
3725 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3726 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3728 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3729 "parameter(tethering) is NULL\n");
3731 GVariant *parameters;
3732 GError *error = NULL;
3735 __tethering_h *th = (__tethering_h *)tethering;
3737 GDBusProxy *proxy = th->client_bus_proxy;
3739 parameters = g_dbus_proxy_call_sync(proxy, "set_mtu",
3740 g_variant_new("(u)", mtu),
3741 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3743 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3745 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3746 result = TETHERING_ERROR_PERMISSION_DENIED;
3748 result = TETHERING_ERROR_OPERATION_FAILED;
3750 g_error_free(error);
3754 g_variant_get(parameters, "(u)", &result);
3756 g_variant_unref(parameters);
3758 return TETHERING_ERROR_NONE;
3761 API int tethering_wifi_change_mac(tethering_h tethering, char *mac)
3763 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3764 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3766 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3767 "parameter(tethering) is NULL\n");
3768 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3769 "parameter(mac) is NULL\n");
3771 GVariant *parameters;
3772 GError *error = NULL;
3775 __tethering_h *th = (__tethering_h *)tethering;
3777 GDBusProxy *proxy = th->client_bus_proxy;
3779 parameters = g_dbus_proxy_call_sync(proxy, "change_mac",
3780 g_variant_new("(s)", mac),
3781 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3783 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3785 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3786 result = TETHERING_ERROR_PERMISSION_DENIED;
3788 result = TETHERING_ERROR_OPERATION_FAILED;
3790 g_error_free(error);
3794 g_variant_get(parameters, "(u)", &result);
3795 g_variant_unref(parameters);
3797 if (result == MOBILE_AP_ERROR_NOT_PERMITTED)
3798 return TETHERING_ERROR_NOT_SUPPORT_API;
3800 return TETHERING_ERROR_NONE;
3803 API int tethering_wifi_set_max_connected_device(tethering_h tethering, int max_device)
3805 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3806 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3808 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3809 "parameter(tethering) is NULL\n");
3811 __tethering_h *th = (__tethering_h *)tethering;
3813 th->wifi_max_connected = max_device;
3815 return TETHERING_ERROR_NONE;
3818 API int tethering_wifi_get_max_connected_device(tethering_h tethering, int *max_device)
3820 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3821 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3823 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3824 "parameter(tethering) is NULL\n");
3825 _retvm_if(max_device == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3826 "parameter(max_device) is NULL\n");
3828 __tethering_h *th = (__tethering_h *)tethering;
3830 *max_device = th->wifi_max_connected;
3831 return TETHERING_ERROR_NONE;
3834 API int tethering_wifi_enable_port_forwarding(tethering_h tethering, bool enable)
3836 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3837 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3839 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3840 "parameter(tethering) is NULL\n");
3842 GVariant *parameters;
3843 GError *error = NULL;
3846 __tethering_h *th = (__tethering_h *)tethering;
3848 GDBusProxy *proxy = th->client_bus_proxy;
3850 parameters = g_dbus_proxy_call_sync(proxy, "enable_port_forwarding",
3851 g_variant_new("(b)", enable),
3852 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3854 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3856 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3857 result = TETHERING_ERROR_PERMISSION_DENIED;
3859 result = TETHERING_ERROR_OPERATION_FAILED;
3861 g_error_free(error);
3865 g_variant_get(parameters, "(u)", &result);
3866 g_variant_unref(parameters);
3868 th->port_forwarding = true;
3870 return TETHERING_ERROR_NONE;
3873 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)
3875 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3876 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3878 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3879 "parameter(tethering) is NULL\n");
3880 _retvm_if(ifname == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3881 "parameter(ifname) is NULL\n");
3882 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3883 "parameter(protocol) is NULL\n");
3884 _retvm_if(org_ip == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3885 "parameter(org_ip) is NULL\n");
3886 _retvm_if(final_ip == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3887 "parameter(final_ip) is NULL\n");
3889 GVariant *parameters;
3890 GError *error = NULL;
3892 char cmd[MAX_BUF_SIZE] = { 0, };
3895 __tethering_h *th = (__tethering_h *)tethering;
3897 GDBusProxy *proxy = th->client_bus_proxy;
3899 parameters = g_dbus_proxy_call_sync(proxy, "add_port_forwarding_rule",
3900 g_variant_new("(sssisi)", ifname, protocol, org_ip, org_port, final_ip, final_port),
3901 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3903 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3905 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3906 result = TETHERING_ERROR_PERMISSION_DENIED;
3908 result = TETHERING_ERROR_OPERATION_FAILED;
3910 g_error_free(error);
3914 g_variant_get(parameters, "(u)", &result);
3915 g_variant_unref(parameters);
3917 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);
3921 ERR("strdup failed\n");
3922 return TETHERING_ERROR_OUT_OF_MEMORY;
3925 port_forwarding = g_slist_append(port_forwarding, list);
3927 return TETHERING_ERROR_NONE;
3930 API int tethering_wifi_reset_port_forwarding_rule(tethering_h tethering)
3932 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3933 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3935 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3936 "parameter(tethering) is NULL\n");
3938 GVariant *parameters;
3939 GError *error = NULL;
3942 __tethering_h *th = (__tethering_h *)tethering;
3944 GDBusProxy *proxy = th->client_bus_proxy;
3946 parameters = g_dbus_proxy_call_sync(proxy, "reset_port_forwarding_rule",
3947 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3949 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3951 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3952 result = TETHERING_ERROR_PERMISSION_DENIED;
3954 result = TETHERING_ERROR_OPERATION_FAILED;
3956 g_error_free(error);
3960 g_variant_get(parameters, "(u)", &result);
3962 g_variant_unref(parameters);
3964 return TETHERING_ERROR_NONE;
3967 API int tethering_wifi_is_port_forwarding_enabled(tethering_h tethering, bool *forwarding_enabled)
3969 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3970 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3972 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3973 "parameter(tethering) is NULL\n");
3974 _retvm_if(forwarding_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3975 "parameter(forwarding_enabled) is NULL\n");
3977 __tethering_h *th = (__tethering_h *)tethering;
3979 *forwarding_enabled = th->port_forwarding;
3981 return TETHERING_ERROR_NONE;
3984 API int tethering_wifi_get_port_forwarding_rule(tethering_h tethering, void **port_forwarding_list)
3986 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3987 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3989 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3990 "parameter(tethering) is NULL\n");
3991 _retvm_if(port_forwarding_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3992 "parameter(port_forwarding_list) is NULL\n");
3994 *port_forwarding_list = g_slist_copy(port_forwarding);
3995 return TETHERING_ERROR_NONE;
3998 API int tethering_wifi_enable_port_filtering(tethering_h tethering, bool enable)
4000 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4001 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4003 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4004 "parameter(tethering) is NULL\n");
4006 GVariant *parameters;
4007 GError *error = NULL;
4010 __tethering_h *th = (__tethering_h *)tethering;
4012 GDBusProxy *proxy = th->client_bus_proxy;
4014 parameters = g_dbus_proxy_call_sync(proxy, "enable_port_filtering",
4015 g_variant_new("(b)", enable),
4016 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4018 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4020 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4021 result = TETHERING_ERROR_PERMISSION_DENIED;
4023 result = TETHERING_ERROR_OPERATION_FAILED;
4025 g_error_free(error);
4029 g_variant_get(parameters, "(u)", &result);
4030 g_variant_unref(parameters);
4032 th->port_filtering = true;
4034 return TETHERING_ERROR_NONE;
4037 API int tethering_wifi_add_port_filtering_rule(tethering_h tethering, int port, char *protocol, bool allow)
4039 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4040 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4042 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4043 "parameter(tethering) is NULL\n");
4044 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4045 "parameter(protocol) is NULL\n");
4047 GVariant *parameters;
4048 GError *error = NULL;
4053 __tethering_h *th = (__tethering_h *)tethering;
4055 GDBusProxy *proxy = th->client_bus_proxy;
4057 parameters = g_dbus_proxy_call_sync(proxy, "add_port_filtering_rule",
4058 g_variant_new("(isb)", port, protocol, allow),
4059 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4061 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4063 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4064 result = TETHERING_ERROR_PERMISSION_DENIED;
4066 result = TETHERING_ERROR_OPERATION_FAILED;
4068 g_error_free(error);
4072 g_variant_get(parameters, "(u)", &result);
4073 g_variant_unref(parameters);
4076 ret = asprintf(&list, "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_ACCEPT);
4078 ret = asprintf(&list, "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_DROP);
4080 if (ret == -1 || list == NULL) {
4081 ERR("asprintf failed\n");
4082 return TETHERING_ERROR_OUT_OF_MEMORY;
4085 DBG("cmd:%s", list);
4087 port_filtering = g_slist_append(port_filtering, list);
4089 return TETHERING_ERROR_NONE;
4092 API int tethering_wifi_add_custom_port_filtering_rule(tethering_h tethering, int port1, int port2, char *protocol, bool allow)
4094 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4095 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4097 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4098 "parameter(tethering) is NULL\n");
4099 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4100 "parameter(protocol) is NULL\n");
4102 GVariant *parameters;
4103 GError *error = NULL;
4108 __tethering_h *th = (__tethering_h *)tethering;
4110 GDBusProxy *proxy = th->client_bus_proxy;
4112 parameters = g_dbus_proxy_call_sync(proxy, "add_custom_port_filtering_rule",
4113 g_variant_new("(iisb)", port1, port2, protocol, allow),
4114 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4116 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4118 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4119 result = TETHERING_ERROR_PERMISSION_DENIED;
4121 result = TETHERING_ERROR_OPERATION_FAILED;
4123 g_error_free(error);
4127 g_variant_get(parameters, "(u)", &result);
4128 g_variant_unref(parameters);
4131 ret = asprintf(&list, "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_ACCEPT);
4133 ret = asprintf(&list, "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_DROP);
4135 if (ret == -1 || list == NULL) {
4136 ERR("asprintf failed\n");
4137 return TETHERING_ERROR_OUT_OF_MEMORY;
4140 DBG("cmd:%s", list);
4142 custom_port_filtering = g_slist_append(custom_port_filtering, list);
4144 return TETHERING_ERROR_NONE;
4147 API int tethering_wifi_get_port_filtering_rule(tethering_h tethering, void **port_filtering_list)
4149 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4150 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4152 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4153 "parameter(tethering) is NULL\n");
4154 _retvm_if(port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4155 "parameter(port_filtering_list) is NULL\n");
4157 *port_filtering_list = g_slist_copy(port_filtering);
4158 return TETHERING_ERROR_NONE;
4161 API int tethering_wifi_get_custom_port_filtering_rule(tethering_h tethering, void **custom_port_filtering_list)
4163 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4164 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4166 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4167 "parameter(tethering) is NULL\n");
4168 _retvm_if(custom_port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4169 "parameter(custom_port_filtering_list) is NULL\n");
4171 *custom_port_filtering_list = g_slist_copy(custom_port_filtering);
4172 return TETHERING_ERROR_NONE;
4175 API int tethering_wifi_is_port_filtering_enabled(tethering_h tethering, bool *filtering_enabled)
4177 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4178 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4180 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4181 "parameter(tethering) is NULL\n");
4182 _retvm_if(filtering_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4183 "parameter(filtering_enabled) is NULL\n");
4185 __tethering_h *th = (__tethering_h *)tethering;
4187 *filtering_enabled = th->port_filtering;
4189 return TETHERING_ERROR_NONE;
4192 API int tethering_wifi_set_vpn_passthrough_rule(tethering_h tethering, tethering_vpn_passthrough_type_e type, bool enable)
4194 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4195 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4197 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4198 "parameter(tethering) is NULL\n");
4200 GVariant *parameters;
4201 GError *error = NULL;
4204 __tethering_h *th = (__tethering_h *)tethering;
4206 GDBusProxy *proxy = th->client_bus_proxy;
4208 parameters = g_dbus_proxy_call_sync(proxy, "set_vpn_passthrough_rule",
4209 g_variant_new("(ib)", type, enable),
4210 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4212 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4214 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4215 result = TETHERING_ERROR_PERMISSION_DENIED;
4217 result = TETHERING_ERROR_OPERATION_FAILED;
4219 g_error_free(error);
4223 g_variant_get(parameters, "(u)", &result);
4225 g_variant_unref(parameters);
4227 return TETHERING_ERROR_NONE;
4230 API int tethering_wifi_push_wps_button(tethering_h tethering)
4232 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4233 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4235 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4236 "parameter(tethering) is NULL");
4237 __tethering_h *th = (__tethering_h *)tethering;
4238 GDBusProxy *proxy = th->client_bus_proxy;
4239 GVariant *parameters = NULL;
4241 GError *error = NULL;
4243 parameters = g_dbus_proxy_call_sync(proxy, "push_wps_button",
4244 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4247 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4249 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4250 ret = TETHERING_ERROR_PERMISSION_DENIED;
4252 ret = TETHERING_ERROR_OPERATION_FAILED;
4254 g_error_free(error);
4258 if (parameters != NULL) {
4259 g_variant_get(parameters, "(u)", &ret);
4260 g_variant_unref(parameters);
4263 return TETHERING_ERROR_NONE;
4266 API int tethering_wifi_set_wps_pin(tethering_h tethering, const char *wps_pin)
4268 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4269 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4271 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4272 "parameter(tethering) is NULL");
4273 _retvm_if(wps_pin == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4274 "parameter(wps_pin) is NULL");
4276 __tethering_h *th = (__tethering_h *)tethering;
4277 GDBusProxy *proxy = th->client_bus_proxy;
4278 GVariant *parameters = NULL;
4280 GError *error = NULL;
4282 parameters = g_dbus_proxy_call_sync(proxy, "set_wps_pin",
4283 g_variant_new("(s)", wps_pin), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4286 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4288 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4289 ret = TETHERING_ERROR_PERMISSION_DENIED;
4291 ret = TETHERING_ERROR_OPERATION_FAILED;
4293 g_error_free(error);
4297 if (parameters != NULL) {
4298 g_variant_get(parameters, "(u)", &ret);
4299 g_variant_unref(parameters);
4302 return TETHERING_ERROR_NONE;