2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
20 #include <sys/ioctl.h>
21 #include <sys/socket.h>
22 #include <netinet/in.h>
24 #include <arpa/inet.h>
26 #include <dbus/dbus.h>
29 #include <openssl/evp.h>
30 #include <openssl/sha.h>
31 #include <ckmc/ckmc-manager.h>
32 #include "tethering_private.h"
34 static void __handle_wifi_tether_on(GDBusConnection *connection, const gchar *sender_name,
35 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
36 GVariant *parameters, gpointer user_data);
38 static void __handle_wifi_tether_off(GDBusConnection *connection, const gchar *sender_name,
39 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
40 GVariant *parameters, gpointer user_data);
42 static void __handle_usb_tether_on(GDBusConnection *connection, const gchar *sender_name,
43 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
44 GVariant *parameters, gpointer user_data);
46 static void __handle_usb_tether_off(GDBusConnection *connection, const gchar *sender_name,
47 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
48 GVariant *parameters, gpointer user_data);
50 static void __handle_bt_tether_on(GDBusConnection *connection, const gchar *sender_name,
51 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
52 GVariant *parameters, gpointer user_data);
54 static void __handle_bt_tether_off(GDBusConnection *connection, const gchar *sender_name,
55 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
56 GVariant *parameters, gpointer user_data);
58 static void __handle_wifi_ap_on(GDBusConnection *connection, const gchar *sender_name,
59 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
60 GVariant *parameters, gpointer user_data);
62 static void __handle_wifi_ap_off(GDBusConnection *connection, const gchar *sender_name,
63 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
64 GVariant *parameters, gpointer user_data);
66 static void __handle_net_closed(GDBusConnection *connection, const gchar *sender_name,
67 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
68 GVariant *parameters, gpointer user_data);
70 static void __handle_no_data_timeout(GDBusConnection *connection, const gchar *sender_name,
71 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
72 GVariant *parameters, gpointer user_data);
74 static void __handle_low_battery_mode(GDBusConnection *connection, const gchar *sender_name,
75 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
76 GVariant *parameters, gpointer user_data);
78 static void __handle_flight_mode(GDBusConnection *connection, const gchar *sender_name,
79 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
80 GVariant *parameters, gpointer user_data);
82 static void __handle_security_type_changed(GDBusConnection *connection, const gchar *sender_name,
83 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
84 GVariant *parameters, gpointer user_data);
86 static void __handle_ssid_visibility_changed(GDBusConnection *connection, const gchar *sender_name,
87 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
88 GVariant *parameters, gpointer user_data);
90 static void __handle_passphrase_changed(GDBusConnection *connection, const gchar *sender_name,
91 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
92 GVariant *parameters, gpointer user_data);
94 static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name,
95 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
96 GVariant *parameters, gpointer user_data);
98 static void __get_key_manager_alias(char* alias, size_t buff_len);
100 static __tethering_sig_t sigs[] = {
101 {0, SIGNAL_NAME_NET_CLOSED, __handle_net_closed},
102 {0, SIGNAL_NAME_WIFI_TETHER_ON, __handle_wifi_tether_on},
103 {0, SIGNAL_NAME_WIFI_TETHER_OFF, __handle_wifi_tether_off},
104 {0, SIGNAL_NAME_USB_TETHER_ON, __handle_usb_tether_on},
105 {0, SIGNAL_NAME_USB_TETHER_OFF, __handle_usb_tether_off},
106 {0, SIGNAL_NAME_BT_TETHER_ON, __handle_bt_tether_on},
107 {0, SIGNAL_NAME_BT_TETHER_OFF, __handle_bt_tether_off},
108 {0, SIGNAL_NAME_WIFI_AP_ON, __handle_wifi_ap_on},
109 {0, SIGNAL_NAME_WIFI_AP_OFF, __handle_wifi_ap_off},
110 {0, SIGNAL_NAME_NO_DATA_TIMEOUT, __handle_no_data_timeout},
111 {0, SIGNAL_NAME_LOW_BATTERY_MODE, __handle_low_battery_mode},
112 {0, SIGNAL_NAME_FLIGHT_MODE, __handle_flight_mode},
113 {0, SIGNAL_NAME_SECURITY_TYPE_CHANGED, __handle_security_type_changed},
114 {0, SIGNAL_NAME_SSID_VISIBILITY_CHANGED, __handle_ssid_visibility_changed},
115 {0, SIGNAL_NAME_PASSPHRASE_CHANGED, __handle_passphrase_changed},
116 {0, SIGNAL_NAME_DHCP_STATUS, __handle_dhcp},
119 static int retry = 0;
121 static void __send_dbus_signal(GDBusConnection *conn, const char *signal_name, const char *arg)
123 if (conn == NULL || signal_name == NULL)
126 GVariant *message = NULL;
127 GError *error = NULL;
130 message = g_variant_new("(s)", arg);
132 g_dbus_connection_emit_signal(conn, NULL, TETHERING_SERVICE_OBJECT_PATH,
133 TETHERING_SERVICE_INTERFACE, signal_name, message, &error);
135 ERR("g_dbus_connection_emit_signal is failed because %s\n", error->message);
138 g_variant_unref(message);
141 static bool __any_tethering_is_enabled(tethering_h tethering)
143 if (tethering_is_enabled(tethering, TETHERING_TYPE_USB) ||
144 tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) ||
145 tethering_is_enabled(tethering, TETHERING_TYPE_BT) ||
146 tethering_is_enabled(tethering, TETHERING_TYPE_RESERVED))
152 static tethering_error_e __set_security_type(const tethering_wifi_security_type_e security_type)
154 if (security_type != TETHERING_WIFI_SECURITY_TYPE_NONE &&
155 security_type != TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK) {
156 ERR("Invalid param\n");
157 return TETHERING_ERROR_INVALID_PARAMETER;
160 if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY, security_type) < 0) {
161 ERR("vconf_set_int is failed\n");
162 return TETHERING_ERROR_OPERATION_FAILED;
165 return TETHERING_ERROR_NONE;
168 static tethering_error_e __get_security_type(tethering_wifi_security_type_e *security_type)
170 if (security_type == NULL) {
171 ERR("Invalid param\n");
172 return TETHERING_ERROR_INVALID_PARAMETER;
175 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY,
176 (int *)security_type) < 0) {
177 ERR("vconf_get_int is failed\n");
178 return TETHERING_ERROR_OPERATION_FAILED;
181 return TETHERING_ERROR_NONE;
184 static bool __get_ssid_from_vconf(const char *path, char *ssid, unsigned int size)
186 if (path == NULL || ssid == NULL || size == 0)
190 char *ptr_tmp = NULL;
192 ptr = vconf_get_str(path);
196 if (!g_utf8_validate(ptr, -1, (const char **)&ptr_tmp))
199 g_strlcpy(ssid, ptr, size);
205 static tethering_error_e __set_visible(const bool visible)
207 if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, visible ? 0 : 1) < 0) {
208 ERR("vconf_set_int is failed\n");
209 return TETHERING_ERROR_OPERATION_FAILED;
212 return TETHERING_ERROR_NONE;
215 static tethering_error_e __get_visible(bool *visible)
217 if (visible == NULL) {
218 ERR("Invalid param\n");
219 return TETHERING_ERROR_INVALID_PARAMETER;
224 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, &hide) < 0) {
225 ERR("vconf_get_int is failed\n");
226 return TETHERING_ERROR_OPERATION_FAILED;
233 return TETHERING_ERROR_NONE;
236 static unsigned int __generate_initial_passphrase(char *passphrase, unsigned int size)
238 if (passphrase == NULL ||
239 size == 0 || size < TETHERING_WIFI_KEY_MIN_LEN + 1)
242 guint32 rand_int = 0;
245 for (index = 0; index < TETHERING_WIFI_KEY_MIN_LEN; index++) {
246 rand_int = g_random_int_range('a', 'z');
247 passphrase[index] = rand_int;
249 passphrase[index] = '\0';
254 static tethering_error_e __set_passphrase(const char *passphrase, const unsigned int size)
256 if (passphrase == NULL || size == 0)
257 return TETHERING_ERROR_INVALID_PARAMETER;
260 char alias[MAX_ALIAS_LEN] = {0, };
261 ckmc_raw_buffer_s ckmc_buf;
262 ckmc_policy_s ckmc_policy;
264 ckmc_policy.password = NULL;
265 ckmc_policy.extractable = true;
267 ckmc_buf.data = (unsigned char *) passphrase;
268 ckmc_buf.size = strlen(passphrase);
270 __get_key_manager_alias(alias, sizeof(alias));
271 ret = ckmc_save_data(alias, ckmc_buf, ckmc_policy);
272 if (ret != CKMC_ERROR_NONE) {
273 ERR("Fail to save the passphrase : %d\n", ret);
274 return TETHERING_ERROR_OPERATION_FAILED;
277 return TETHERING_ERROR_NONE;
280 static void __get_key_manager_alias(char* alias, size_t buff_len)
282 snprintf(alias, buff_len, "%s%s%s", ckmc_owner_id_system,
283 ckmc_owner_id_separator,
284 TETHERING_WIFI_PASSPHRASE_STORE_KEY);
287 static tethering_error_e __get_passphrase(char *passphrase,
288 unsigned int passphrase_size, unsigned int *passphrase_len)
290 if (passphrase == NULL || passphrase_size == 0) {
291 ERR("Invalid parameter\n");
292 return TETHERING_ERROR_INVALID_PARAMETER;
296 char tmp[TETHERING_WIFI_KEY_MAX_LEN + 1] = {0, };
297 char alias[MAX_ALIAS_LEN] = {0, };
298 ckmc_raw_buffer_s *ckmc_buf;
300 __get_key_manager_alias(alias, sizeof(alias));
301 ret = ckmc_get_data(alias, NULL, &ckmc_buf);
303 DBG("Create new password\n");
304 ret = __generate_initial_passphrase(tmp, sizeof(tmp));
307 ERR("generate_initial_passphrase failed : %d\n", *passphrase_len);
308 return TETHERING_ERROR_OPERATION_FAILED;
310 *passphrase_len = ret;
311 g_strlcpy(passphrase, tmp, (*passphrase_len)+1);
313 if (__set_passphrase(passphrase, *passphrase_len) != TETHERING_ERROR_NONE) {
314 DBG("set_passphrase is failed : %s, %d", passphrase, *passphrase_len);
315 return TETHERING_ERROR_OPERATION_FAILED;
319 *passphrase_len = ckmc_buf->size;
320 g_strlcpy(passphrase, (char *)ckmc_buf->data, (*passphrase_len) + 1);
325 return TETHERING_ERROR_NONE;
328 static tethering_error_e __get_error(int agent_error)
330 tethering_error_e err = TETHERING_ERROR_NONE;
332 switch (agent_error) {
333 case MOBILE_AP_ERROR_NONE:
334 err = TETHERING_ERROR_NONE;
337 case MOBILE_AP_ERROR_RESOURCE:
338 err = TETHERING_ERROR_OUT_OF_MEMORY;
341 case MOBILE_AP_ERROR_INTERNAL:
342 err = TETHERING_ERROR_OPERATION_FAILED;
345 case MOBILE_AP_ERROR_INVALID_PARAM:
346 err = TETHERING_ERROR_INVALID_PARAMETER;
349 case MOBILE_AP_ERROR_ALREADY_ENABLED:
350 err = TETHERING_ERROR_OPERATION_FAILED;
353 case MOBILE_AP_ERROR_NOT_ENABLED:
354 err = TETHERING_ERROR_NOT_ENABLED;
357 case MOBILE_AP_ERROR_NET_OPEN:
358 err = TETHERING_ERROR_OPERATION_FAILED;
361 case MOBILE_AP_ERROR_NET_CLOSE:
362 err = TETHERING_ERROR_OPERATION_FAILED;
365 case MOBILE_AP_ERROR_DHCP:
366 err = TETHERING_ERROR_OPERATION_FAILED;
369 case MOBILE_AP_ERROR_IN_PROGRESS:
370 err = TETHERING_ERROR_OPERATION_FAILED;
373 case MOBILE_AP_ERROR_NOT_PERMITTED:
374 err = TETHERING_ERROR_NOT_PERMITTED;
377 case MOBILE_AP_ERROR_PERMISSION_DENIED:
378 err = TETHERING_ERROR_PERMISSION_DENIED;
382 ERR("Not defined error : %d\n", agent_error);
383 err = TETHERING_ERROR_OPERATION_FAILED;
390 static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name,
391 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
392 GVariant *parameters, gpointer user_data)
396 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
398 __tethering_h *th = (__tethering_h *)user_data;
400 tethering_type_e type = 0;
401 mobile_ap_type_e ap_type = 0;
402 tethering_connection_state_changed_cb ccb = NULL;
403 __tethering_client_h client;
411 memset(&client, 0, sizeof(__tethering_client_h));
412 g_variant_get(parameters, "(susssu)", &buf, &ap_type, &ip, &mac, &name, ×tamp);
414 if (!g_strcmp0(buf, "DhcpConnected")) {
416 } else if (!g_strcmp0(buf, "DhcpLeaseDeleted")) {
419 ERR("Unknown event [%s]\n", buf);
423 if (ap_type == MOBILE_AP_TYPE_USB)
424 type = TETHERING_TYPE_USB;
425 else if (ap_type == MOBILE_AP_TYPE_WIFI)
426 type = TETHERING_TYPE_WIFI;
427 else if (ap_type == MOBILE_AP_TYPE_BT)
428 type = TETHERING_TYPE_BT;
429 else if (ap_type == MOBILE_AP_TYPE_WIFI_AP) {
430 type = TETHERING_TYPE_RESERVED;
432 ERR("Not supported tethering type [%d]\n", ap_type);
436 ccb = th->changed_cb[type];
439 data = th->changed_user_data[type];
441 client.interface = type;
442 g_strlcpy(client.ip, ip, sizeof(client.ip));
443 g_strlcpy(client.mac, mac, sizeof(client.mac));
445 client.hostname = g_strdup(name);
446 client.tm = (time_t)timestamp;
448 ccb((tethering_client_h)&client, opened, data);
449 g_free(client.hostname);
458 static void __handle_net_closed(GDBusConnection *connection, const gchar *sender_name,
459 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
460 GVariant *parameters, gpointer user_data)
464 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
466 __tethering_h *th = (__tethering_h *)user_data;
467 tethering_type_e type = 0;
468 tethering_disabled_cb dcb = NULL;
470 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_NETWORK_CLOSE;
472 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
473 dcb = th->disabled_cb[type];
476 data = th->disabled_user_data[type];
478 dcb(TETHERING_ERROR_NONE, type, code, data);
484 static void __handle_wifi_tether_on(GDBusConnection *connection, const gchar *sender_name,
485 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
486 GVariant *parameters, gpointer user_data)
490 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
492 __tethering_h *th = (__tethering_h *)user_data;
493 tethering_type_e type = TETHERING_TYPE_WIFI;
494 bool is_requested = false;
495 tethering_enabled_cb ecb = NULL;
498 ecb = th->enabled_cb[type];
501 data = th->enabled_user_data[type];
503 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
507 static void __handle_wifi_tether_off(GDBusConnection *connection, const gchar *sender_name,
508 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
509 GVariant *parameters, gpointer user_data)
513 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
515 __tethering_h *th = (__tethering_h *)user_data;
516 tethering_type_e type = TETHERING_TYPE_WIFI;
517 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
518 tethering_disabled_cb dcb = NULL;
522 dcb = th->disabled_cb[type];
525 data = th->disabled_user_data[type];
526 g_variant_get(parameters, "(s)", &buf);
527 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
528 code = TETHERING_DISABLED_BY_WIFI_ON;
529 else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT))
530 code = TETHERING_DISABLED_BY_TIMEOUT;
533 dcb(TETHERING_ERROR_NONE, type, code, data);
538 static void __handle_usb_tether_on(GDBusConnection *connection, const gchar *sender_name,
539 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
540 GVariant *parameters, gpointer user_data)
544 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
546 __tethering_h *th = (__tethering_h *)user_data;
547 tethering_type_e type = TETHERING_TYPE_USB;
548 bool is_requested = false;
549 tethering_enabled_cb ecb = NULL;
552 ecb = th->enabled_cb[type];
555 data = th->enabled_user_data[type];
557 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
561 static void __handle_usb_tether_off(GDBusConnection *connection, const gchar *sender_name,
562 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
563 GVariant *parameters, gpointer user_data)
567 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
569 __tethering_h *th = (__tethering_h *)user_data;
570 tethering_type_e type = TETHERING_TYPE_USB;
571 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
572 tethering_disabled_cb dcb = NULL;
576 dcb = th->disabled_cb[type];
579 data = th->disabled_user_data[type];
581 g_variant_get(parameters, "(s)", &buf);
582 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
583 code = TETHERING_DISABLED_BY_USB_DISCONNECTION;
585 dcb(TETHERING_ERROR_NONE, type, code, data);
590 static void __handle_bt_tether_on(GDBusConnection *connection, const gchar *sender_name,
591 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
592 GVariant *parameters, gpointer user_data)
596 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
598 __tethering_h *th = (__tethering_h *)user_data;
599 tethering_type_e type = TETHERING_TYPE_BT;
600 bool is_requested = false;
601 tethering_enabled_cb ecb = NULL;
604 ecb = th->enabled_cb[type];
607 data = th->enabled_user_data[type];
609 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
613 static void __handle_bt_tether_off(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 = TETHERING_TYPE_BT;
623 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
624 tethering_disabled_cb dcb = NULL;
628 dcb = th->disabled_cb[type];
631 data = th->disabled_user_data[type];
632 g_variant_get(parameters, "(s)", &buf);
633 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
634 code = TETHERING_DISABLED_BY_BT_OFF;
635 else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT))
636 code = TETHERING_DISABLED_BY_TIMEOUT;
638 dcb(TETHERING_ERROR_NONE, type, code, data);
644 static void __handle_wifi_ap_on(GDBusConnection *connection, const gchar *sender_name,
645 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
646 GVariant *parameters, gpointer user_data)
650 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
652 __tethering_h *th = (__tethering_h *)user_data;
653 tethering_type_e type = TETHERING_TYPE_RESERVED;
654 bool is_requested = false;
655 tethering_enabled_cb ecb = NULL;
658 ecb = th->enabled_cb[type];
661 data = th->enabled_user_data[type];
663 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
667 static void __handle_wifi_ap_off(GDBusConnection *connection, const gchar *sender_name,
668 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
669 GVariant *parameters, gpointer user_data)
673 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
675 __tethering_h *th = (__tethering_h *)user_data;
676 tethering_type_e type = TETHERING_TYPE_RESERVED;
677 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
678 tethering_disabled_cb dcb = NULL;
682 dcb = th->disabled_cb[type];
685 data = th->disabled_user_data[type];
686 g_variant_get(parameters, "(s)", &buf);
687 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
688 code = TETHERING_DISABLED_BY_WIFI_ON;
689 else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT))
690 code = TETHERING_DISABLED_BY_TIMEOUT;
693 dcb(TETHERING_ERROR_NONE, type, code, data);
698 static void __handle_no_data_timeout(GDBusConnection *connection, const gchar *sender_name,
699 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
700 GVariant *parameters, gpointer user_data)
704 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
706 __tethering_h *th = (__tethering_h *)user_data;
707 tethering_type_e type = 0;
708 tethering_disabled_cb dcb = NULL;
710 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_TIMEOUT;
712 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
713 dcb = th->disabled_cb[type];
716 data = th->disabled_user_data[type];
718 dcb(TETHERING_ERROR_NONE, type, code, data);
723 static void __handle_low_battery_mode(GDBusConnection *connection, const gchar *sender_name,
724 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
725 GVariant *parameters, gpointer user_data)
729 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
731 __tethering_h *th = (__tethering_h *)user_data;
732 tethering_type_e type = 0;
733 tethering_disabled_cb dcb = NULL;
735 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_LOW_BATTERY;
737 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_RESERVED; type++) {
738 dcb = th->disabled_cb[type];
741 data = th->disabled_user_data[type];
743 dcb(TETHERING_ERROR_NONE, type, code, data);
748 static void __handle_flight_mode(GDBusConnection *connection, const gchar *sender_name,
749 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
750 GVariant *parameters, gpointer user_data)
754 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
756 __tethering_h *th = (__tethering_h *)user_data;
757 tethering_type_e type = 0;
758 tethering_disabled_cb dcb = NULL;
760 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_FLIGHT_MODE;
762 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_RESERVED; type++) {
763 dcb = th->disabled_cb[type];
766 data = th->disabled_user_data[type];
768 dcb(TETHERING_ERROR_NONE, type, code, data);
773 static void __handle_security_type_changed(GDBusConnection *connection, const gchar *sender_name,
774 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
775 GVariant *parameters, gpointer user_data)
780 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
781 __tethering_h *th = (__tethering_h *)user_data;
783 tethering_wifi_security_type_changed_cb scb = NULL;
785 tethering_wifi_security_type_e security_type;
788 scb = th->security_type_changed_cb;
792 g_variant_get(parameters, "(s)", &buf);
793 data = th->security_type_user_data;
794 if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_OPEN_STR) == 0)
795 security_type = TETHERING_WIFI_SECURITY_TYPE_NONE;
796 else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR) == 0)
797 security_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK;
799 SERR("Unknown type : %s\n", buf);
804 scb(security_type, data);
809 static void __handle_ssid_visibility_changed(GDBusConnection *connection, const gchar *sender_name,
810 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
811 GVariant *parameters, gpointer user_data)
815 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
816 __tethering_h *th = (__tethering_h *)user_data;
818 tethering_wifi_ssid_visibility_changed_cb scb = NULL;
820 bool visible = false;
823 scb = th->ssid_visibility_changed_cb;
828 g_variant_get(parameters, "(s)", &buf);
829 data = th->ssid_visibility_user_data;
830 if (g_strcmp0(buf, SIGNAL_MSG_SSID_VISIBLE) == 0)
838 static void __handle_passphrase_changed(GDBusConnection *connection, const gchar *sender_name,
839 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
840 GVariant *parameters, gpointer user_data)
844 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
845 __tethering_h *th = (__tethering_h *)user_data;
847 tethering_wifi_passphrase_changed_cb pcb = NULL;
850 pcb = th->passphrase_changed_cb;
854 data = th->passphrase_user_data;
860 static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
865 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
866 GError *g_error = NULL;
869 tethering_error_e error;
870 __tethering_h *th = (__tethering_h *)user_data;
871 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_WIFI];
872 void *data = th->enabled_user_data[TETHERING_TYPE_WIFI];
874 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
876 ERR("DBus error [%s]\n", g_error->message);
877 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
878 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
879 g_error_free(g_error);
880 tethering_enable((tethering_h)th, TETHERING_TYPE_WIFI);
882 } else if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
883 error = TETHERING_ERROR_PERMISSION_DENIED;
885 error = TETHERING_ERROR_OPERATION_FAILED;
886 g_error_free(g_error);
888 g_variant_get(g_var, "(u)", &info);
889 error = __get_error(info);
893 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
894 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_ON].name,
895 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
896 sigs[E_SIGNAL_WIFI_TETHER_ON].cb, (gpointer)th, NULL);
902 ecb(error, TETHERING_TYPE_WIFI, true, data);
903 g_variant_unref(g_var);
907 static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
911 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
912 GError *g_error = NULL;
915 tethering_error_e error;
917 __tethering_h *th = (__tethering_h *)user_data;
918 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_BT];
919 void *data = th->enabled_user_data[TETHERING_TYPE_BT];
921 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
923 ERR("DBus error [%s]\n", g_error->message);
924 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
925 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
926 g_error_free(g_error);
927 tethering_enable((tethering_h)th, TETHERING_TYPE_BT);
931 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
932 error = TETHERING_ERROR_PERMISSION_DENIED;
934 error = TETHERING_ERROR_OPERATION_FAILED;
935 g_error_free(g_error);
937 g_variant_get(g_var, "(u)", &info);
938 g_variant_unref(g_var);
939 error = __get_error(info);
943 sigs[E_SIGNAL_BT_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
944 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_ON].name,
945 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
946 sigs[E_SIGNAL_BT_TETHER_ON].cb, (gpointer)th, NULL);
953 ecb(error, TETHERING_TYPE_BT, true, data);
957 static void __usb_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
962 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
963 __tethering_h *th = (__tethering_h *)user_data;
964 GError *g_error = NULL;
967 tethering_error_e error;
968 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_USB];
969 void *data = th->enabled_user_data[TETHERING_TYPE_USB];
971 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
973 ERR("DBus error [%s]\n", g_error->message);
974 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
975 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
976 g_error_free(g_error);
977 tethering_enable((tethering_h)th, TETHERING_TYPE_USB);
981 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
982 error = TETHERING_ERROR_PERMISSION_DENIED;
984 error = TETHERING_ERROR_OPERATION_FAILED;
985 g_error_free(g_error);
987 g_variant_get(g_var, "(u)", &info);
988 g_variant_unref(g_var);
989 error = __get_error(info);
993 sigs[E_SIGNAL_USB_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
994 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_ON].name,
995 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
996 sigs[E_SIGNAL_USB_TETHER_ON].cb, (gpointer)th, NULL);
1003 ecb(error, TETHERING_TYPE_USB, true, data);
1007 static void __wifi_ap_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
1012 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1013 __tethering_h *th = (__tethering_h *)user_data;
1014 GError *g_error = NULL;
1017 tethering_error_e error;
1018 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_RESERVED];
1019 void *data = th->enabled_user_data[TETHERING_TYPE_RESERVED];
1021 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1023 ERR("DBus error [%s]\n", g_error->message);
1024 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
1025 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
1026 g_error_free(g_error);
1027 tethering_enable((tethering_h)th, TETHERING_TYPE_RESERVED);
1031 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1032 error = TETHERING_ERROR_PERMISSION_DENIED;
1034 error = TETHERING_ERROR_OPERATION_FAILED;
1035 g_error_free(g_error);
1037 g_variant_get(g_var, "(u)", &info);
1038 g_variant_unref(g_var);
1039 error = __get_error(info);
1043 sigs[E_SIGNAL_WIFI_AP_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1044 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_AP_ON].name,
1045 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1046 sigs[E_SIGNAL_WIFI_AP_ON].cb, (gpointer)th, NULL);
1053 ecb(error, TETHERING_TYPE_RESERVED, true, data);
1057 static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res,
1062 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1063 GError *g_error = NULL;
1065 guint info, event_type;
1066 tethering_error_e error;
1067 tethering_type_e type;
1068 tethering_h tethering = (tethering_h)user_data;
1069 __tethering_h *th = (__tethering_h *)tethering;
1070 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_REQUEST;
1071 tethering_disabled_cb dcb = NULL;
1074 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1076 ERR("DBus error [%s]\n", g_error->message);
1077 g_error_free(g_error);
1080 g_variant_get(g_var, "(uu)", &event_type, &info);
1081 DBG("cfm event : %d info : %d\n", event_type, info);
1082 g_variant_unref(g_var);
1083 error = __get_error(info);
1084 DBG("cfm event : %d info : %d\n", event_type, error);
1085 switch (event_type) {
1086 case MOBILE_AP_DISABLE_WIFI_TETHERING_CFM:
1087 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1088 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_OFF].name,
1089 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1090 sigs[E_SIGNAL_WIFI_TETHER_OFF].cb, (gpointer)th, NULL);
1092 type = TETHERING_TYPE_WIFI;
1093 dcb = th->disabled_cb[type];
1094 data = th->disabled_user_data[type];
1096 dcb(error, type, code, data);
1099 case MOBILE_AP_DISABLE_BT_TETHERING_CFM:
1100 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1101 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_OFF].name,
1102 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1103 sigs[E_SIGNAL_BT_TETHER_OFF].cb, (gpointer)th, NULL);
1105 type = TETHERING_TYPE_BT;
1106 dcb = th->disabled_cb[type];
1107 data = th->disabled_user_data[type];
1109 dcb(error, type, code, data);
1112 case MOBILE_AP_DISABLE_USB_TETHERING_CFM:
1113 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1114 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
1115 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1116 sigs[E_SIGNAL_USB_TETHER_OFF].cb, (gpointer)th, NULL);
1118 type = TETHERING_TYPE_USB;
1119 dcb = th->disabled_cb[type];
1120 data = th->disabled_user_data[type];
1122 dcb(error, type, code, data);
1125 case MOBILE_AP_DISABLE_WIFI_AP_CFM:
1126 sigs[E_SIGNAL_WIFI_AP_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1127 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_AP_OFF].name,
1128 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1129 sigs[E_SIGNAL_WIFI_AP_OFF].cb, (gpointer)th, NULL);
1131 type = TETHERING_TYPE_RESERVED;
1132 dcb = th->disabled_cb[type];
1133 data = th->disabled_user_data[type];
1135 dcb(error, type, code, data);
1138 case MOBILE_AP_DISABLE_CFM:
1140 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1141 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_OFF].name,
1142 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1143 sigs[E_SIGNAL_WIFI_TETHER_OFF].cb, (gpointer)th, NULL);
1144 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1145 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_OFF].name,
1146 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1147 sigs[E_SIGNAL_BT_TETHER_OFF].cb, (gpointer)th, NULL);
1148 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1149 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
1150 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1151 sigs[E_SIGNAL_USB_TETHER_OFF].cb, (gpointer)th, NULL);
1153 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
1154 dcb = th->disabled_cb[type];
1157 data = th->disabled_user_data[type];
1159 dcb(error, type, code, data);
1164 ERR("Invalid event\n");
1170 static void __get_data_usage_cb(GObject *source_object, GAsyncResult *res,
1175 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1177 GError *g_error = NULL;
1180 guint64 tx_bytes, rx_bytes;
1181 __tethering_h *th = (__tethering_h *)user_data;
1182 tethering_error_e tethering_error = TETHERING_ERROR_NONE;
1185 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1187 ERR("DBus fail [%s]\n", g_error->message);
1188 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1189 tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1191 tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1195 if (th->data_usage_cb == NULL) {
1196 ERR("There is no data_usage_cb\n");
1200 th->data_usage_cb(tethering_error, 0LL, 0LL, th->data_usage_user_data);
1202 g_variant_get(g_var, "(utt)", &event_type, &tx_bytes, &rx_bytes);
1203 th->data_usage_cb(TETHERING_ERROR_NONE,
1204 rx_bytes, tx_bytes, th->data_usage_user_data);
1205 g_variant_unref(g_var);
1207 th->data_usage_cb = NULL;
1208 th->data_usage_user_data = NULL;
1213 static void __settings_reloaded_cb(GObject *source_object, GAsyncResult *res,
1218 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1219 GError *g_error = NULL;
1222 __tethering_h *th = (__tethering_h *)user_data;
1223 tethering_error_e tethering_error;
1225 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1227 ERR("DBus fail [%s]\n", g_error->message);
1228 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1229 tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1231 tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1232 g_error_free(g_error);
1234 if (th->settings_reloaded_cb == NULL) {
1235 DBG("There is no settings_reloaded_cb\n-\n");
1238 g_variant_get(g_var, "(u)", &info);
1239 tethering_error = __get_error(info);
1240 g_variant_unref(g_var);
1242 th->settings_reloaded_cb(tethering_error,
1243 th->settings_reloaded_user_data);
1245 th->settings_reloaded_cb = NULL;
1246 th->settings_reloaded_user_data = NULL;
1250 static void __ap_settings_reloaded_cb(GObject *source_object, GAsyncResult *res,
1255 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1256 GError *g_error = NULL;
1259 __tethering_h *th = (__tethering_h *)user_data;
1260 tethering_error_e tethering_error;
1262 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1264 ERR("DBus fail [%s]\n", g_error->message);
1265 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1266 tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1268 tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1269 g_error_free(g_error);
1271 if (th->ap_settings_reloaded_cb == NULL) {
1272 DBG("There is no settings_reloaded_cb\n-\n");
1275 g_variant_get(g_var, "(u)", &info);
1276 tethering_error = __get_error(info);
1277 g_variant_unref(g_var);
1279 th->ap_settings_reloaded_cb(tethering_error,
1280 th->ap_settings_reloaded_user_data);
1282 th->ap_settings_reloaded_cb = NULL;
1283 th->ap_settings_reloaded_user_data = NULL;
1287 static void __connect_signals(tethering_h tethering)
1290 _retm_if(tethering == NULL, "parameter(tethering) is NULL\n");
1292 __tethering_h *th = (__tethering_h *)tethering;
1293 GDBusConnection *connection = th->client_bus;
1296 for (i = E_SIGNAL_NET_CLOSED; i < E_SIGNAL_MAX; i++) {
1297 sigs[i].sig_id = g_dbus_connection_signal_subscribe(connection,
1298 NULL, TETHERING_SERVICE_INTERFACE, sigs[i].name,
1299 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1300 sigs[i].cb, tethering, NULL);
1305 static void __disconnect_signals(tethering_h tethering)
1309 _retm_if(tethering == NULL, "parameter(tethering) is NULL\n");
1311 __tethering_h *th = (__tethering_h *)tethering;
1312 GDBusConnection *connection = th->client_bus;
1316 for (i = E_SIGNAL_NET_CLOSED; i < E_SIGNAL_MAX; i++)
1317 g_dbus_connection_signal_unsubscribe(connection, sigs[i].sig_id);
1323 static bool __get_intf_name(tethering_type_e type, char *buf, unsigned int len)
1325 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1328 case TETHERING_TYPE_USB:
1329 g_strlcpy(buf, TETHERING_USB_IF, len);
1332 case TETHERING_TYPE_WIFI:
1333 g_strlcpy(buf, TETHERING_WIFI_IF, len);
1336 case TETHERING_TYPE_BT:
1337 g_strlcpy(buf, TETHERING_BT_IF, len);
1340 case TETHERING_TYPE_RESERVED:
1341 g_strlcpy(buf, TETHERING_WIFI_IF, len);
1345 ERR("Not supported type : %d\n", type);
1351 static bool __get_gateway_addr(tethering_type_e type, char *buf, unsigned int len)
1353 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1356 case TETHERING_TYPE_USB:
1357 g_strlcpy(buf, TETHERING_USB_GATEWAY, len);
1360 case TETHERING_TYPE_WIFI:
1361 g_strlcpy(buf, TETHERING_WIFI_GATEWAY, len);
1364 case TETHERING_TYPE_BT:
1365 g_strlcpy(buf, TETHERING_BT_GATEWAY, len);
1368 case TETHERING_TYPE_RESERVED:
1369 g_strlcpy(buf, TETHERING_WIFI_GATEWAY, len);
1373 ERR("Not supported type : %d\n", type);
1379 static int __get_common_ssid(char *ssid, unsigned int size)
1382 ERR("ssid is null\n");
1383 return TETHERING_ERROR_INVALID_PARAMETER;
1387 char *ptr_tmp = NULL;
1389 ptr = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
1391 ERR("vconf_get_str is failed\n");
1393 return TETHERING_ERROR_OPERATION_FAILED;
1396 g_strlcpy(ssid, ptr, size);
1399 if (!g_utf8_validate(ssid, -1, (const char **)&ptr_tmp))
1402 return TETHERING_ERROR_NONE;
1405 static int __prepare_wifi_settings(tethering_h tethering, _softap_settings_t *set)
1409 __tethering_h *th = (__tethering_h *)tethering;
1410 tethering_error_e ret = TETHERING_ERROR_NONE;
1412 if (th == NULL || set == NULL) {
1413 ERR("null parameter\n-\n");
1414 return TETHERING_ERROR_INVALID_PARAMETER;
1417 if (th->ssid == NULL)
1418 __get_common_ssid(set->ssid, sizeof(set->ssid));
1420 g_strlcpy(set->ssid, th->ssid, sizeof(set->ssid));
1422 ret = __get_security_type(&set->sec_type);
1423 if (ret != TETHERING_ERROR_NONE)
1424 set->sec_type = th->sec_type;
1426 ret = __get_visible(&set->visibility);
1427 if (ret != TETHERING_ERROR_NONE)
1428 set->visibility = th->visibility;
1430 if (set->sec_type == TETHERING_WIFI_SECURITY_TYPE_NONE) {
1431 g_strlcpy(set->key, "", sizeof(set->key));
1433 char pass[TETHERING_WIFI_KEY_MAX_LEN + 1] = {0, };
1434 unsigned int len = 0;
1436 ret = __get_passphrase(pass, sizeof(pass), &len);
1437 if (ret != TETHERING_ERROR_NONE) {
1438 ERR("getting passphrase failed\n");
1439 return TETHERING_ERROR_OPERATION_FAILED;
1441 g_strlcpy(set->key, pass, sizeof(set->key));
1444 return TETHERING_ERROR_NONE;
1447 static int __prepare_wifi_ap_settings(tethering_h tethering, _softap_settings_t *set)
1451 __tethering_h *th = (__tethering_h *)tethering;
1453 if (th == NULL || set == NULL) {
1454 ERR("null parameter\n");
1455 return TETHERING_ERROR_INVALID_PARAMETER;
1458 g_strlcpy(set->ssid, th->ap_ssid, sizeof(set->ssid));
1459 set->sec_type = th->sec_type;
1460 set->visibility = th->visibility;
1462 if (set->sec_type == TETHERING_WIFI_SECURITY_TYPE_NONE)
1463 g_strlcpy(set->key, "", sizeof(set->key));
1465 g_strlcpy(set->key, th->passphrase, sizeof(set->key));
1468 return TETHERING_ERROR_NONE;
1471 static bool __check_precondition(tethering_type_e type)
1474 int cellular_state = 0;
1477 /* data network through cellular */
1478 vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &cellular_state);
1479 if (cellular_state == VCONFKEY_NETWORK_CELLULAR_ON) {
1480 ERR("Data Network can be connected later");
1484 vconf_get_int(VCONFKEY_DNET_STATE, &dnet_state);
1485 if (dnet_state > VCONFKEY_DNET_OFF) {
1486 ERR("Data Network is connected");
1490 /* data network through wifi */
1491 if (type != TETHERING_TYPE_WIFI) {
1492 vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state);
1493 if (wifi_state > VCONFKEY_WIFI_UNCONNECTED) {
1494 ERR("Wi-Fi is connected!");
1499 ERR("Network is not available!");
1505 * @brief Creates the handle of tethering.
1507 * @privlevel platform
1508 * @privilege http://tizen.org/privilege/tethering.admin
1509 * @remarks The @a tethering must be released tethering_destroy() by you.
1510 * @param[out] tethering A handle of a new mobile ap handle on success
1511 * @return 0 on success, otherwise a negative error value.
1512 * @retval #TETHERING_ERROR_NONE Successful
1513 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1514 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1515 * @retval #TETHERING_ERROR_NOT_SUPPORT_API API is not supported
1516 * @see tethering_destroy()
1518 API int tethering_create(tethering_h *tethering)
1520 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1521 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1522 "parameter(tethering) is NULL\n");
1525 __tethering_h *th = NULL;
1526 GError *error = NULL;
1527 char ssid[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
1529 th = (__tethering_h *)malloc(sizeof(__tethering_h));
1531 _retvm_if(th == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
1532 "malloc is failed\n");
1533 memset(th, 0x00, sizeof(__tethering_h));
1534 th->sec_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK;
1535 th->visibility = true;
1537 if (__generate_initial_passphrase(th->passphrase,
1538 sizeof(th->passphrase)) == 0) {
1539 ERR("random passphrase generation failed\n");
1541 return TETHERING_ERROR_OPERATION_FAILED;
1544 if (__get_common_ssid(ssid, sizeof(ssid)) != TETHERING_ERROR_NONE) {
1545 ERR("common ssid get failed\n");
1547 return TETHERING_ERROR_OPERATION_FAILED;
1550 th->ap_ssid = g_strdup(ssid);
1551 if (th->ap_ssid == NULL) {
1552 ERR("g_strdup failed\n");
1554 return TETHERING_ERROR_OPERATION_FAILED;
1557 #if !GLIB_CHECK_VERSION(2, 36, 0)
1560 GCancellable *cancellable = g_cancellable_new();
1561 th->client_bus = g_bus_get_sync(DBUS_BUS_SYSTEM, cancellable, &error);
1563 ERR("Couldn't connect to the System bus[%s]", error->message);
1564 g_error_free(error);
1565 g_cancellable_cancel(cancellable);
1566 g_object_unref(cancellable);
1567 g_free(th->ap_ssid);
1569 return TETHERING_ERROR_OPERATION_FAILED;
1571 th->cancellable = cancellable;
1573 th->client_bus_proxy = g_dbus_proxy_new_sync(th->client_bus, G_DBUS_PROXY_FLAGS_NONE,
1574 NULL, TETHERING_SERVICE_NAME, TETHERING_SERVICE_OBJECT_PATH,
1575 TETHERING_SERVICE_INTERFACE, th->cancellable, &error);
1576 if (!th->client_bus_proxy) {
1577 ERR("Couldn't create the proxy object because of %s\n", error->message);
1578 g_cancellable_cancel(th->cancellable);
1579 g_object_unref(th->cancellable);
1580 g_object_unref(th->client_bus);
1581 g_free(th->ap_ssid);
1583 return TETHERING_ERROR_OPERATION_FAILED;
1586 __connect_signals((tethering_h)th);
1588 *tethering = (tethering_h)th;
1589 DBG("Tethering Handle : 0x%X\n", th);
1591 return TETHERING_ERROR_NONE;
1596 * @brief Destroys the handle of tethering.
1598 * @privlevel platform
1599 * @privilege http://tizen.org/privilege/tethering.admin
1600 * @param[in] tethering The handle of tethering
1601 * @return 0 on success, otherwise a negative error value.
1602 * @retval #TETHERING_ERROR_NONE Successful
1603 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1604 * @see tethering_create()
1606 API int tethering_destroy(tethering_h tethering)
1609 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1610 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1611 "parameter(tethering) is NULL\n");
1613 __tethering_h *th = (__tethering_h *)tethering;
1615 DBG("Tethering Handle : 0x%X\n", th);
1616 __disconnect_signals(tethering);
1623 g_object_unref(th->cancellable);
1624 g_object_unref(th->client_bus_proxy);
1625 g_object_unref(th->client_bus);
1626 memset(th, 0x00, sizeof(__tethering_h));
1630 return TETHERING_ERROR_NONE;
1635 * @brief Enables the tethering, asynchronously.
1637 * @privlevel platform
1638 * @privilege http://tizen.org/privilege/tethering.admin
1639 * @param[in] tethering The handle of tethering
1640 * @param[in] type The type of tethering
1641 * @return 0 on success, otherwise negative error value.
1642 * @retval #TETHERING_ERROR_NONE Successful
1643 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1644 * @post tethering_enabled_cb() will be invoked.
1645 * @see tethering_is_enabled()
1646 * @see tethering_disable()
1648 API int tethering_enable(tethering_h tethering, tethering_type_e type)
1650 DBG("+ type : %d\n", type);
1651 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1652 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1653 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1654 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1656 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1657 "parameter(tethering) is NULL\n");
1659 tethering_error_e ret = TETHERING_ERROR_NONE;
1660 __tethering_h *th = (__tethering_h *)tethering;
1661 GDBusProxy *proxy = th->client_bus_proxy;
1662 GDBusConnection *connection = th->client_bus;
1664 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
1666 if (type != TETHERING_TYPE_RESERVED
1667 && __check_precondition(type) == FALSE) {
1669 return TETHERING_ERROR_OPERATION_FAILED;
1673 case TETHERING_TYPE_USB:
1674 g_dbus_connection_signal_unsubscribe(connection,
1675 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1677 g_dbus_proxy_call(proxy, "enable_usb_tethering", NULL,
1678 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1679 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1682 case TETHERING_TYPE_WIFI: {
1683 _softap_settings_t set = {"", "", 0, false};
1685 ret = __prepare_wifi_settings(tethering, &set);
1686 if (ret != TETHERING_ERROR_NONE) {
1687 ERR("softap settings initialization failed\n");
1689 return TETHERING_ERROR_OPERATION_FAILED;
1691 g_dbus_connection_signal_unsubscribe(connection,
1692 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1694 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1695 g_variant_new("(ssii)", set.ssid, set.key, set.visibility, set.sec_type),
1696 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1697 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1701 case TETHERING_TYPE_BT:
1702 g_dbus_connection_signal_unsubscribe(connection,
1703 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1705 g_dbus_proxy_call(proxy, "enable_bt_tethering", NULL,
1706 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1707 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1711 case TETHERING_TYPE_RESERVED: {
1712 _softap_settings_t set = {"", "", 0, false};
1714 ret = __prepare_wifi_ap_settings(tethering, &set);
1715 if (ret != TETHERING_ERROR_NONE) {
1716 ERR("softap settings initialization failed\n");
1717 return TETHERING_ERROR_OPERATION_FAILED;
1720 g_dbus_connection_signal_unsubscribe(connection,
1721 sigs[E_SIGNAL_WIFI_AP_ON].sig_id);
1723 g_dbus_proxy_call(proxy, "enable_wifi_ap",
1724 g_variant_new("(ssii)", set.ssid, set.key, set.visibility, set.sec_type),
1725 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable, (GAsyncReadyCallback) __wifi_ap_enabled_cfm_cb, (gpointer)tethering);
1728 case TETHERING_TYPE_ALL: {
1729 _softap_settings_t set = {"", "", 0, false};
1731 ret = __prepare_wifi_settings(tethering, &set);
1732 if (ret != TETHERING_ERROR_NONE) {
1733 ERR("softap settings initialization failed\n");
1734 return TETHERING_ERROR_OPERATION_FAILED;
1737 /* TETHERING_TYPE_USB */
1738 g_dbus_connection_signal_unsubscribe(connection,
1739 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1741 g_dbus_proxy_call(proxy, "enable_usb_tethering", NULL,
1742 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1743 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1745 /* TETHERING_TYPE_WIFI */
1746 g_dbus_connection_signal_unsubscribe(connection,
1747 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1749 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1750 g_variant_new("(ssii)", set.ssid, set.key, set.visibility, set.sec_type),
1751 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1752 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1754 /* TETHERING_TYPE_BT */
1755 g_dbus_connection_signal_unsubscribe(connection,
1756 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1758 g_dbus_proxy_call(proxy, "enable_usb_tethering", NULL,
1759 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1760 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1764 ERR("Unknown type : %d\n", type);
1766 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1769 return TETHERING_ERROR_INVALID_PARAMETER;
1772 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1774 return TETHERING_ERROR_NONE;
1779 * @brief Disables the tethering, asynchronously.
1781 * @privlevel platform
1782 * @privilege http://tizen.org/privilege/tethering.admin
1783 * @param[in] tethering The handle of tethering
1784 * @param[in] type The type of tethering
1785 * @return 0 on success, otherwise negative error value.
1786 * @retval #TETHERING_ERROR_NONE Successful
1787 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1788 * @post tethering_disabled_cb() will be invoked.
1789 * @see tethering_is_enabled()
1790 * @see tethering_enable()
1792 API int tethering_disable(tethering_h tethering, tethering_type_e type)
1794 DBG("+ type : %d\n", type);
1795 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
1796 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
1797 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
1799 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1800 "parameter(tethering) is NULL\n");
1802 __tethering_h *th = (__tethering_h *)tethering;
1803 GDBusProxy *proxy = th->client_bus_proxy;
1804 GDBusConnection *connection = th->client_bus;
1807 case TETHERING_TYPE_USB:
1808 g_dbus_connection_signal_unsubscribe(connection,
1809 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1811 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1812 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1813 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1817 case TETHERING_TYPE_WIFI:
1819 g_dbus_connection_signal_unsubscribe(connection,
1820 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1822 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1823 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1824 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1827 case TETHERING_TYPE_BT:
1829 g_dbus_connection_signal_unsubscribe(connection,
1830 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1832 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1833 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1834 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1837 case TETHERING_TYPE_RESERVED:
1838 g_dbus_connection_signal_unsubscribe(connection,
1839 sigs[E_SIGNAL_WIFI_AP_OFF].sig_id);
1841 g_dbus_proxy_call(proxy, "disable_wifi_ap",
1842 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1843 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1846 case TETHERING_TYPE_ALL:
1847 g_dbus_connection_signal_unsubscribe(connection,
1848 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1850 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1851 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1852 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1854 g_dbus_connection_signal_unsubscribe(connection,
1855 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1857 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1858 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1859 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1861 g_dbus_connection_signal_unsubscribe(connection,
1862 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1864 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1865 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1866 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1870 ERR("Not supported tethering type [%d]\n", type);
1872 return TETHERING_ERROR_INVALID_PARAMETER;
1875 return TETHERING_ERROR_NONE;
1880 * @brief Checks whetehr the tethering is enabled or not.
1882 * @privlevel platform
1883 * @privilege http://tizen.org/privilege/tethering.admin
1884 * @param[in] tethering The handle of tethering
1885 * @param[in] type The type of tethering
1886 * @return @c true if tethering is enabled, \n @c false if tethering is disabled.
1888 API bool tethering_is_enabled(tethering_h tethering, tethering_type_e type)
1891 int vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_NONE;
1893 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1895 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &is_on) != 0)
1899 case TETHERING_TYPE_USB:
1900 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_USB;
1903 case TETHERING_TYPE_WIFI:
1904 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI;
1907 case TETHERING_TYPE_BT:
1908 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_BT;
1911 case TETHERING_TYPE_RESERVED:
1912 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI_AP;
1916 ERR("Not supported type : %d\n", type);
1919 return is_on & vconf_type ? true : false;
1924 * @brief Gets the MAC address of local device as "FC:A1:3E:D6:B1:B1".
1926 * @privlevel platform
1927 * @privilege http://tizen.org/privilege/tethering.admin
1928 * @remarks @a mac_address must be released with free() by you.
1929 * @param[in] tethering The handle of tethering
1930 * @param[in] type The type of tethering
1931 * @param[out] mac_address The MAC address
1932 * @return 0 on success, otherwise a negative error value.
1933 * @retval #TETHERING_ERROR_NONE Successful
1934 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1935 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1936 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
1937 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
1938 * @pre tethering must be enabled.
1939 * @see tethering_is_enabled()
1940 * @see tethering_enable()
1942 API int tethering_get_mac_address(tethering_h tethering, tethering_type_e type, char **mac_address)
1944 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
1945 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
1946 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
1948 _retvm_if(tethering_is_enabled(tethering, type) == false,
1949 TETHERING_ERROR_NOT_ENABLED,
1950 "tethering type[%d] is not enabled\n", type);
1951 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1952 "parameter(tethering) is NULL\n");
1953 _retvm_if(mac_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1954 "parameter(mac_address) is NULL\n");
1958 char *macbuf = NULL;
1960 _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
1961 TETHERING_ERROR_OPERATION_FAILED,
1962 "getting interface name is failed\n");
1964 s = socket(AF_INET, SOCK_DGRAM, 0);
1965 _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
1966 "getting socket is failed\n");
1967 if (ioctl(s, SIOCGIFHWADDR, &ifr) < 0) {
1968 ERR("getting mac is failed\n");
1970 return TETHERING_ERROR_OPERATION_FAILED;
1974 macbuf = (char *)malloc(TETHERING_STR_INFO_LEN);
1975 _retvm_if(macbuf == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
1976 "Not enough memory\n");
1977 snprintf(macbuf, TETHERING_STR_INFO_LEN, "%02X:%02X:%02X:%02X:%02X:%02X",
1978 (unsigned char)ifr.ifr_hwaddr.sa_data[0],
1979 (unsigned char)ifr.ifr_hwaddr.sa_data[1],
1980 (unsigned char)ifr.ifr_hwaddr.sa_data[2],
1981 (unsigned char)ifr.ifr_hwaddr.sa_data[3],
1982 (unsigned char)ifr.ifr_hwaddr.sa_data[4],
1983 (unsigned char)ifr.ifr_hwaddr.sa_data[5]);
1985 *mac_address = macbuf;
1987 return TETHERING_ERROR_NONE;
1992 * @brief Gets the name of network interface. For example, usb0.
1994 * @privlevel platform
1995 * @privilege http://tizen.org/privilege/tethering.admin
1996 * @remarks @a interface_name must be released with free() by you.
1997 * @param[in] tethering The handle of tethering
1998 * @param[in] type The type of tethering
1999 * @param[out] interface_name The name of network interface
2000 * @return 0 on success, otherwise negative error value.
2001 * @retval #TETHERING_ERROR_NONE Successful
2002 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2003 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2004 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2005 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2006 * @pre tethering must be enabled.
2007 * @see tethering_is_enabled()
2008 * @see tethering_enable()
2010 API int tethering_get_network_interface_name(tethering_h tethering, tethering_type_e type, char **interface_name)
2012 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
2013 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2014 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
2016 _retvm_if(tethering_is_enabled(tethering, type) == false,
2017 TETHERING_ERROR_NOT_ENABLED,
2018 "tethering type[%d] is not enabled\n", type);
2019 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2020 "parameter(tethering) is NULL\n");
2021 _retvm_if(interface_name == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2022 "parameter(interface_name) is NULL\n");
2024 char intf[TETHERING_STR_INFO_LEN] = {0, };
2026 _retvm_if(!__get_intf_name(type, intf, sizeof(intf)),
2027 TETHERING_ERROR_OPERATION_FAILED,
2028 "getting interface name is failed\n");
2029 *interface_name = strdup(intf);
2030 _retvm_if(*interface_name == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2031 "Not enough memory\n");
2033 return TETHERING_ERROR_NONE;
2038 * @brief Gets the local IP address.
2040 * @privlevel platform
2041 * @privilege http://tizen.org/privilege/tethering.admin
2042 * @remarks @a ip_address must be released with free() by you.
2043 * @param[in] tethering The handle of tethering
2044 * @param[in] type The type of tethering
2045 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2046 * @param[out] ip_address The local IP address
2047 * @return 0 on success, otherwise negative error value.
2048 * @retval #TETHERING_ERROR_NONE Successful
2049 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2050 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2051 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2052 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2053 * @pre tethering must be enabled.
2054 * @see tethering_is_enabled()
2055 * @see tethering_enable()
2057 API int tethering_get_ip_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **ip_address)
2060 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
2061 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2062 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
2064 _retvm_if(tethering_is_enabled(tethering, type) == false,
2065 TETHERING_ERROR_NOT_ENABLED,
2066 "tethering type[%d] is not enabled\n", type);
2067 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2068 "parameter(tethering) is NULL\n");
2069 _retvm_if(ip_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2070 "parameter(ip_address) is NULL\n");
2076 _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
2077 TETHERING_ERROR_OPERATION_FAILED,
2078 "getting interface name is failed\n");
2080 s = socket(AF_INET, SOCK_DGRAM, 0);
2081 _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
2082 "getting socket is failed\n");
2083 if (ioctl(s, SIOCGIFADDR, &ifr) < 0) {
2084 ERR("ioctl is failed\n");
2086 return TETHERING_ERROR_OPERATION_FAILED;
2090 ipbuf = inet_ntoa(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr);
2091 *ip_address = strdup(ipbuf);
2092 _retvm_if(*ip_address == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2093 "Not enough memory\n");
2095 return TETHERING_ERROR_NONE;
2100 * @brief Gets the Gateway address.
2102 * @privlevel platform
2103 * @privilege http://tizen.org/privilege/tethering.admin
2104 * @remarks @a gateway_address must be released with free() by you.
2105 * @param[in] tethering The handle of tethering
2106 * @param[in] type The type of tethering
2107 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2108 * @param[out] gateway_address The local IP address
2109 * @return 0 on success, otherwise negative error value.
2110 * @retval #TETHERING_ERROR_NONE Successful
2111 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2112 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2113 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2114 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2115 * @pre tethering must be enabled.
2116 * @see tethering_is_enabled()
2117 * @see tethering_enable()
2119 API int tethering_get_gateway_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **gateway_address)
2122 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
2123 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2124 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
2126 _retvm_if(tethering_is_enabled(tethering, type) == false,
2127 TETHERING_ERROR_NOT_ENABLED,
2128 "tethering type[%d] is not enabled\n", type);
2129 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2130 "parameter(tethering) is NULL\n");
2131 _retvm_if(gateway_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2132 "parameter(gateway_address) is NULL\n");
2134 char gateway_buf[TETHERING_STR_INFO_LEN] = {0, };
2136 _retvm_if(!__get_gateway_addr(type, gateway_buf, sizeof(gateway_buf)),
2137 TETHERING_ERROR_OPERATION_FAILED,
2138 "getting gateway address is failed\n");
2140 *gateway_address = strdup(gateway_buf);
2142 return TETHERING_ERROR_NONE;
2147 * @brief Gets the Subnet Mask.
2149 * @privlevel platform
2150 * @privilege http://tizen.org/privilege/tethering.admin
2151 * @remarks @a subnet_mask must be released with free() by you.
2152 * @param[in] tethering The handle of tethering
2153 * @param[in] type The type of tethering
2154 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2155 * @param[out] subnet_mask The local IP address
2156 * @return 0 on success, otherwise negative error value.
2157 * @retval #TETHERING_ERROR_NONE Successful
2158 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2159 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2160 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2161 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2162 * @pre tethering must be enabled.
2163 * @see tethering_is_enabled()
2164 * @see tethering_enable()
2166 API int tethering_get_subnet_mask(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **subnet_mask)
2168 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
2169 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2170 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
2172 _retvm_if(tethering_is_enabled(tethering, type) == false,
2173 TETHERING_ERROR_NOT_ENABLED,
2174 "tethering is not enabled\n");
2175 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2176 "parameter(tethering) is NULL\n");
2177 _retvm_if(subnet_mask == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2178 "parameter(subnet_mask) is NULL\n");
2180 *subnet_mask = strdup(TETHERING_SUBNET_MASK);
2181 _retvm_if(*subnet_mask == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2182 "Not enough memory\n");
2184 return TETHERING_ERROR_NONE;
2189 * @brief Gets the data usage.
2191 * @privlevel platform
2192 * @privilege http://tizen.org/privilege/tethering.admin
2193 * @param[in] tethering The handle of tethering
2194 * @param[out] usage The data usage
2195 * @return 0 on success, otherwise negative error value.
2196 * @retval #TETHERING_ERROR_NONE Successful
2197 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2198 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2199 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2200 * @pre tethering must be enabled.
2201 * @see tethering_is_enabled()
2202 * @see tethering_enable()
2204 API int tethering_get_data_usage(tethering_h tethering, tethering_data_usage_cb callback, void *user_data)
2206 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2208 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2209 "parameter(tethering) is NULL\n");
2210 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2211 "parameter(callback) is NULL\n");
2212 _retvm_if(__any_tethering_is_enabled(tethering) == false,
2213 TETHERING_ERROR_NOT_ENABLED,
2214 "tethering is not enabled\n");
2216 __tethering_h *th = (__tethering_h *)tethering;
2217 GDBusProxy *proxy = th->client_bus_proxy;
2219 th->data_usage_cb = callback;
2220 th->data_usage_user_data = user_data;
2222 g_dbus_proxy_call(proxy, "get_data_packet_usage",
2223 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2224 (GAsyncReadyCallback) __get_data_usage_cb, (gpointer)tethering);
2226 return TETHERING_ERROR_NONE;
2231 * @brief Gets the client which is connected by tethering "type".
2233 * @privlevel platform
2234 * @privilege http://tizen.org/privilege/tethering.admin
2235 * @param[in] tethering The handle of tethering
2236 * @param[in] type The type of tethering
2237 * @param[in] callback The callback function to invoke
2238 * @param[in] user_data The user data to be passed to the callback function
2239 * @retval #TETHERING_ERROR_NONE Successful
2240 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2241 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2242 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2243 * @pre tethering must be enabled.
2244 * @see tethering_is_enabled()
2245 * @see tethering_enable()
2247 API int tethering_foreach_connected_clients(tethering_h tethering, tethering_type_e type, tethering_connected_client_cb callback, void *user_data)
2250 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
2251 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2252 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
2254 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2255 "parameter(tethering) is NULL\n");
2256 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2257 "parameter(callback) is NULL\n");
2258 _retvm_if(__any_tethering_is_enabled(tethering) == false,
2259 TETHERING_ERROR_NOT_ENABLED,
2260 "tethering is not enabled\n");
2262 mobile_ap_type_e interface;
2263 __tethering_h *th = (__tethering_h *)tethering;
2264 __tethering_client_h client = {0, };
2267 gchar *hostname = NULL;
2268 guint timestamp = 0;
2269 GError *error = NULL;
2270 GVariant *result = NULL;
2271 GVariantIter *outer_iter = NULL;
2272 GVariantIter *inner_iter = NULL;
2273 GVariant *station = NULL;
2274 GVariant *value = NULL;
2277 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "get_station_info",
2278 NULL, G_DBUS_CALL_FLAGS_NONE,
2279 -1, th->cancellable, &error);
2281 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
2282 g_variant_get(result, "(a(a{sv}))", &outer_iter);
2283 while (g_variant_iter_loop(outer_iter, "(@a{sv})", &station)) {
2284 g_variant_get(station, "a{sv}", &inner_iter);
2285 while (g_variant_iter_loop(inner_iter, "{sv}", &key, &value)) {
2286 if (g_strcmp0(key, "Type") == 0) {
2287 interface = g_variant_get_int32(value);
2288 if (interface == MOBILE_AP_TYPE_USB)
2289 client.interface = TETHERING_TYPE_USB;
2290 else if (interface == MOBILE_AP_TYPE_WIFI)
2291 client.interface = TETHERING_TYPE_WIFI;
2292 else if (interface == MOBILE_AP_TYPE_BT)
2293 client.interface = TETHERING_TYPE_BT;
2294 else if (interface == MOBILE_AP_TYPE_WIFI_AP)
2295 client.interface = TETHERING_TYPE_RESERVED;
2297 ERR("Invalid interface\n");
2299 g_variant_unref(value);
2302 DBG("interface is %d\n", client.interface);
2303 if (client.interface != type && (TETHERING_TYPE_ALL != type &&
2304 client.interface != TETHERING_TYPE_RESERVED)) {
2306 g_variant_unref(value);
2309 } else if (g_strcmp0(key, "IP") == 0) {
2310 g_variant_get(value, "s", &ip);
2311 SDBG("ip is %s\n", ip);
2312 g_strlcpy(client.ip, ip, sizeof(client.ip));
2313 } else if (g_strcmp0(key, "MAC") == 0) {
2314 g_variant_get(value, "s", &mac);
2315 SDBG("mac is %s\n", mac);
2316 g_strlcpy(client.mac, mac, sizeof(client.mac));
2317 } else if (g_strcmp0(key, "Name") == 0) {
2318 g_variant_get(value, "s", &hostname);
2319 SDBG("hsotname is %s\n", hostname);
2321 client.hostname = g_strdup(hostname);
2322 } else if (g_strcmp0(key, "Time") == 0) {
2323 timestamp = g_variant_get_int32(value);
2324 DBG("timestamp is %d\n", timestamp);
2325 client.tm = (time_t)timestamp;
2327 ERR("Key %s not required\n", key);
2333 g_variant_iter_free(inner_iter);
2334 if (callback((tethering_client_h)&client, user_data) == false) {
2335 DBG("iteration is stopped\n");
2336 g_free(client.hostname);
2337 g_variant_iter_free(outer_iter);
2338 g_variant_unref(station);
2339 g_variant_unref(result);
2341 return TETHERING_ERROR_OPERATION_FAILED;
2343 g_free(client.hostname);
2345 g_variant_iter_free(outer_iter);
2346 g_variant_unref(station);
2347 g_variant_unref(result);
2349 return TETHERING_ERROR_NONE;
2354 * @brief Registers the callback function called when tethering is enabled.
2356 * @privlevel platform
2357 * @privilege http://tizen.org/privilege/tethering.admin
2358 * @param[in] tethering The handle of tethering
2359 * @param[in] type The type of tethering
2360 * @param[in] callback The callback function to invoke
2361 * @param[in] user_data The user data to be passed to the callback function
2362 * @retval #TETHERING_ERROR_NONE Successful
2363 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2364 * @see tethering_unset_enabled_cb()
2366 API int tethering_set_enabled_cb(tethering_h tethering, tethering_type_e type, tethering_enabled_cb callback, void *user_data)
2368 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
2369 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2370 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
2372 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2373 "parameter(tethering) is NULL\n");
2374 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2375 "parameter(callback) is NULL\n");
2377 __tethering_h *th = (__tethering_h *)tethering;
2378 tethering_type_e ti;
2380 if (type != TETHERING_TYPE_ALL) {
2381 th->enabled_cb[type] = callback;
2382 th->enabled_user_data[type] = user_data;
2384 return TETHERING_ERROR_NONE;
2387 /* TETHERING_TYPE_ALL */
2388 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2389 th->enabled_cb[ti] = callback;
2390 th->enabled_user_data[ti] = user_data;
2393 return TETHERING_ERROR_NONE;
2398 * @brief Unregisters the callback function called when tethering is disabled.
2400 * @privlevel platform
2401 * @privilege http://tizen.org/privilege/tethering.admin
2402 * @param[in] tethering The handle of tethering
2403 * @param[in] type The type of tethering
2404 * @retval #TETHERING_ERROR_NONE Successful
2405 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2406 * @see tethering_set_enabled_cb()
2408 API int tethering_unset_enabled_cb(tethering_h tethering, tethering_type_e type)
2410 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
2411 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2412 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
2414 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2415 "parameter(tethering) is NULL\n");
2417 __tethering_h *th = (__tethering_h *)tethering;
2418 tethering_type_e ti;
2420 if (type != TETHERING_TYPE_ALL) {
2421 th->enabled_cb[type] = NULL;
2422 th->enabled_user_data[type] = NULL;
2424 return TETHERING_ERROR_NONE;
2427 /* TETHERING_TYPE_ALL */
2428 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2429 th->enabled_cb[ti] = NULL;
2430 th->enabled_user_data[ti] = NULL;
2433 return TETHERING_ERROR_NONE;
2438 * @brief Registers the callback function called when tethering is disabled.
2440 * @privlevel platform
2441 * @privilege http://tizen.org/privilege/tethering.admin
2442 * @param[in] tethering The handle of tethering
2443 * @param[in] type The type of tethering
2444 * @param[in] callback The callback function to invoke
2445 * @param[in] user_data The user data to be passed to the callback function
2446 * @retval #TETHERING_ERROR_NONE Successful
2447 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2448 * @see tethering_unset_disabled_cb()
2450 API int tethering_set_disabled_cb(tethering_h tethering, tethering_type_e type, tethering_disabled_cb callback, void *user_data)
2452 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
2453 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2454 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
2456 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2457 "parameter(tethering) is NULL\n");
2458 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2459 "parameter(callback) is NULL\n");
2461 __tethering_h *th = (__tethering_h *)tethering;
2462 tethering_type_e ti;
2464 if (type != TETHERING_TYPE_ALL) {
2465 th->disabled_cb[type] = callback;
2466 th->disabled_user_data[type] = user_data;
2468 return TETHERING_ERROR_NONE;
2471 /* TETHERING_TYPE_ALL */
2472 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2473 th->disabled_cb[ti] = callback;
2474 th->disabled_user_data[ti] = user_data;
2477 return TETHERING_ERROR_NONE;
2482 * @brief Unregisters the callback function called when tethering is disabled.
2484 * @privlevel platform
2485 * @privilege http://tizen.org/privilege/tethering.admin
2486 * @param[in] tethering The handle of tethering
2487 * @param[in] type The type of tethering
2488 * @retval #TETHERING_ERROR_NONE Successful
2489 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2490 * @see tethering_set_disabled_cb()
2492 API int tethering_unset_disabled_cb(tethering_h tethering, tethering_type_e type)
2494 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
2495 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2496 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
2498 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2499 "parameter(tethering) is NULL\n");
2501 __tethering_h *th = (__tethering_h *)tethering;
2502 tethering_type_e ti;
2504 if (type != TETHERING_TYPE_ALL) {
2505 th->disabled_cb[type] = NULL;
2506 th->disabled_user_data[type] = NULL;
2508 return TETHERING_ERROR_NONE;
2511 /* TETHERING_TYPE_ALL */
2512 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2513 th->disabled_cb[ti] = NULL;
2514 th->disabled_user_data[ti] = NULL;
2517 return TETHERING_ERROR_NONE;
2522 * @brief Registers the callback function called when the state of connection is changed.
2524 * @privlevel platform
2525 * @privilege http://tizen.org/privilege/tethering.admin
2526 * @param[in] tethering The handle of tethering
2527 * @param[in] type The type of tethering
2528 * @param[in] callback The callback function to invoke
2529 * @param[in] user_data The user data to be passed to the callback function
2530 * @retval #TETHERING_ERROR_NONE Successful
2531 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2532 * @see tethering_unset_connection_state_changed_cb_cb()
2534 API int tethering_set_connection_state_changed_cb(tethering_h tethering, tethering_type_e type, tethering_connection_state_changed_cb callback, void *user_data)
2536 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
2537 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2538 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
2540 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2541 "parameter(tethering) is NULL\n");
2542 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2543 "parameter(callback) is NULL\n");
2545 __tethering_h *th = (__tethering_h *)tethering;
2546 tethering_type_e ti;
2548 if (type != TETHERING_TYPE_ALL) {
2549 th->changed_cb[type] = callback;
2550 th->changed_user_data[type] = user_data;
2552 return TETHERING_ERROR_NONE;
2555 /* TETHERING_TYPE_ALL */
2556 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2557 th->changed_cb[ti] = callback;
2558 th->changed_user_data[ti] = user_data;
2561 return TETHERING_ERROR_NONE;
2566 * @brief Unregisters the callback function called when the state of connection is changed.
2568 * @privlevel platform
2569 * @privilege http://tizen.org/privilege/tethering.admin
2570 * @param[in] tethering The handle of tethering
2571 * @param[in] type The type of tethering
2572 * @retval #TETHERING_ERROR_NONE Successful
2573 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2574 * @see tethering_set_connection_state_changed_cb()
2576 API int tethering_unset_connection_state_changed_cb(tethering_h tethering, tethering_type_e type)
2578 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_USB_FEATURE);
2579 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2580 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_BT_FEATURE);
2582 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2583 "parameter(tethering) is NULL\n");
2585 __tethering_h *th = (__tethering_h *)tethering;
2586 tethering_type_e ti;
2588 if (type != TETHERING_TYPE_ALL) {
2589 th->changed_cb[type] = NULL;
2590 th->changed_user_data[type] = NULL;
2592 return TETHERING_ERROR_NONE;
2595 /* TETHERING_TYPE_ALL */
2596 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2597 th->changed_cb[ti] = NULL;
2598 th->changed_user_data[ti] = NULL;
2601 return TETHERING_ERROR_NONE;
2606 * @brief Registers the callback function called when the security type of Wi-Fi tethering is changed.
2608 * @privlevel platform
2609 * @privilege http://tizen.org/privilege/tethering.admin
2610 * @param[in] tethering The handle of tethering
2611 * @param[in] callback The callback function to invoke
2612 * @param[in] user_data The user data to be passed to the callback function
2613 * @retval #TETHERING_ERROR_NONE Successful
2614 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2615 * @see tethering_wifi_unset_security_type_changed_cb()
2617 API int tethering_wifi_set_security_type_changed_cb(tethering_h tethering, tethering_wifi_security_type_changed_cb callback, void *user_data)
2619 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2621 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2622 "parameter(tethering) is NULL\n");
2623 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2624 "parameter(callback) is NULL\n");
2626 __tethering_h *th = (__tethering_h *)tethering;
2628 th->security_type_changed_cb = callback;
2629 th->security_type_user_data = user_data;
2631 return TETHERING_ERROR_NONE;
2637 * @brief Unregisters the callback function called when the security type of Wi-Fi tethering is changed.
2639 * @privlevel platform
2640 * @privilege http://tizen.org/privilege/tethering.admin
2641 * @param[in] tethering The handle of tethering
2642 * @param[in] type The type of tethering
2643 * @retval #TETHERING_ERROR_NONE Successful
2644 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2645 * @see tethering_wifi_set_security_type_changed_cb()
2647 API int tethering_wifi_unset_security_type_changed_cb(tethering_h tethering)
2649 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2651 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2652 "parameter(tethering) is NULL\n");
2654 __tethering_h *th = (__tethering_h *)tethering;
2656 th->security_type_changed_cb = NULL;
2657 th->security_type_user_data = NULL;
2659 return TETHERING_ERROR_NONE;
2664 * @brief Registers the callback function called when the visibility of SSID is changed.
2666 * @privlevel platform
2667 * @privilege http://tizen.org/privilege/tethering.admin
2668 * @param[in] tethering The handle of tethering
2669 * @param[in] callback The callback function to invoke
2670 * @param[in] user_data The user data to be passed to the callback function
2671 * @retval #TETHERING_ERROR_NONE Successful
2672 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2673 * @see tethering_wifi_unset_ssid_visibility_changed_cb_cb()
2675 API int tethering_wifi_set_ssid_visibility_changed_cb(tethering_h tethering, tethering_wifi_ssid_visibility_changed_cb callback, void *user_data)
2677 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2679 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2680 "parameter(tethering) is NULL\n");
2681 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2682 "parameter(callback) is NULL\n");
2684 __tethering_h *th = (__tethering_h *)tethering;
2686 th->ssid_visibility_changed_cb = callback;
2687 th->ssid_visibility_user_data = user_data;
2689 return TETHERING_ERROR_NONE;
2694 * @brief Unregisters the callback function called when the visibility of SSID is changed.
2696 * @privlevel platform
2697 * @privilege http://tizen.org/privilege/tethering.admin
2698 * @param[in] tethering The handle of tethering
2699 * @retval #TETHERING_ERROR_NONE Successful
2700 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2701 * @see tethering_wifi_set_ssid_visibility_changed_cb()
2703 API int tethering_wifi_unset_ssid_visibility_changed_cb(tethering_h tethering)
2705 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2707 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2708 "parameter(tethering) is NULL\n");
2710 __tethering_h *th = (__tethering_h *)tethering;
2712 th->ssid_visibility_changed_cb = NULL;
2713 th->ssid_visibility_user_data = NULL;
2715 return TETHERING_ERROR_NONE;
2720 * @brief Registers the callback function called when the passphrase of Wi-Fi tethering is changed.
2722 * @privlevel platform
2723 * @privilege http://tizen.org/privilege/tethering.admin
2724 * @param[in] tethering The handle of tethering
2725 * @param[in] callback The callback function to invoke
2726 * @param[in] user_data The user data to be passed to the callback function
2727 * @retval #TETHERING_ERROR_NONE Successful
2728 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2729 * @see tethering_wifi_unset_passphrase_changed_cb()
2731 API int tethering_wifi_set_passphrase_changed_cb(tethering_h tethering, tethering_wifi_passphrase_changed_cb callback, void *user_data)
2733 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2735 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2736 "parameter(tethering) is NULL\n");
2737 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2738 "parameter(callback) is NULL\n");
2740 __tethering_h *th = (__tethering_h *)tethering;
2742 th->passphrase_changed_cb = callback;
2743 th->passphrase_user_data = user_data;
2745 return TETHERING_ERROR_NONE;
2750 * @brief Unregisters the callback function called when the passphrase of Wi-Fi tethering is changed.
2752 * @privlevel platform
2753 * @privilege http://tizen.org/privilege/tethering.admin
2754 * @param[in] tethering The handle of tethering
2755 * @retval #TETHERING_ERROR_NONE Successful
2756 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2757 * @see tethering_wifi_set_passphrase_changed_cb()
2759 API int tethering_wifi_unset_passphrase_changed_cb(tethering_h tethering)
2761 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2763 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2764 "parameter(tethering) is NULL\n");
2766 __tethering_h *th = (__tethering_h *)tethering;
2768 th->passphrase_changed_cb = NULL;
2769 th->passphrase_user_data = NULL;
2771 return TETHERING_ERROR_NONE;
2776 * @brief Sets the security type of Wi-Fi tethering.
2778 * @privlevel platform
2779 * @privilege http://tizen.org/privilege/tethering.admin
2780 * @remarks This change is applied next time Wi-Fi tethering is enabled
2781 * @param[in] tethering The handle of tethering
2782 * @param[in] type The security type
2783 * @return 0 on success, otherwise negative error value.
2784 * @retval #TETHERING_ERROR_NONE Successful
2785 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2786 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2787 * @see tethering_wifi_get_security_type()
2789 API int tethering_wifi_set_security_type(tethering_h tethering, tethering_wifi_security_type_e type)
2791 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2793 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2794 "parameter(tethering) is NULL\n");
2796 __tethering_h *th = (__tethering_h *)tethering;
2797 tethering_error_e ret = TETHERING_ERROR_NONE;
2799 ret = __set_security_type(type);
2800 if (ret == TETHERING_ERROR_NONE) {
2802 __send_dbus_signal(th->client_bus,
2803 SIGNAL_NAME_SECURITY_TYPE_CHANGED,
2804 type == TETHERING_WIFI_SECURITY_TYPE_NONE ?
2805 TETHERING_WIFI_SECURITY_TYPE_OPEN_STR :
2806 TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR);
2813 * @brief Gets the security type of Wi-Fi tethering.
2815 * @privlevel platform
2816 * @privilege http://tizen.org/privilege/tethering.admin
2817 * @param[in] tethering The handle of tethering
2818 * @param[out] type The security type
2819 * @return 0 on success, otherwise negative error value.
2820 * @retval #TETHERING_ERROR_NONE Successful
2821 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2822 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2823 * @see tethering_wifi_set_security_type()
2825 API int tethering_wifi_get_security_type(tethering_h tethering, tethering_wifi_security_type_e *type)
2827 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2829 _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2830 "parameter(type) is NULL\n");
2832 return __get_security_type(type);
2837 * @brief Sets the SSID (service set identifier).
2839 * @privlevel platform
2840 * @privilege http://tizen.org/privilege/tethering.admin
2841 * @details If SSID is not set, Device name is used as SSID
2842 * @remarks This change is applied next time Wi-Fi tethering is enabled with same @a tethering handle
2843 * @param[in] tethering The handle of tethering
2844 * @param[out] ssid The SSID
2845 * @return 0 on success, otherwise negative error value.
2846 * @retval #TETHERING_ERROR_NONE Successful
2847 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2848 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2850 API int tethering_wifi_set_ssid(tethering_h tethering, const char *ssid)
2852 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2854 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2855 "parameter(tethering) is NULL\n");
2856 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2857 "parameter(ssid) is NULL\n");
2859 __tethering_h *th = (__tethering_h *)tethering;
2860 char *p_ssid = NULL;
2863 ssid_len = strlen(ssid);
2864 if (ssid_len > TETHERING_WIFI_SSID_MAX_LEN) {
2865 ERR("parameter(ssid) is too long");
2866 return TETHERING_ERROR_INVALID_PARAMETER;
2869 p_ssid = strdup(ssid);
2870 _retvm_if(p_ssid == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2871 "strdup is failed\n");
2877 return TETHERING_ERROR_NONE;
2882 * @brief Gets the SSID (service set identifier).
2884 * @privlevel platform
2885 * @privilege http://tizen.org/privilege/tethering.admin
2886 * @remarks @a ssid must be released with free() by you.
2887 * @param[in] tethering The handle of tethering
2888 * @param[out] ssid The SSID
2889 * @return 0 on success, otherwise negative error value.
2890 * @retval #TETHERING_ERROR_NONE Successful
2891 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2892 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2893 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2895 API int tethering_wifi_get_ssid(tethering_h tethering, char **ssid)
2897 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2899 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2900 "parameter(tethering) is NULL\n");
2901 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2902 "parameter(ssid) is NULL\n");
2905 __tethering_h *th = (__tethering_h *)tethering;
2906 char val[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
2908 if (!tethering_is_enabled(NULL, TETHERING_TYPE_WIFI)) {
2909 if (th->ssid != NULL) {
2910 DBG("Private SSID is set\n");
2911 *ssid = strdup(th->ssid);
2913 if (__get_ssid_from_vconf(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
2914 val, sizeof(val)) == false) {
2915 return TETHERING_ERROR_OPERATION_FAILED;
2917 *ssid = strdup(val);
2920 if (__get_ssid_from_vconf(VCONFKEY_MOBILE_HOTSPOT_SSID,
2921 val, sizeof(val)) == false) {
2922 return TETHERING_ERROR_OPERATION_FAILED;
2924 *ssid = strdup(val);
2927 if (*ssid == NULL) {
2928 ERR("strdup is failed\n");
2929 return TETHERING_ERROR_OUT_OF_MEMORY;
2932 return TETHERING_ERROR_NONE;
2937 * @brief Sets the visibility of SSID(service set identifier).
2939 * @privlevel platform
2940 * @privilege http://tizen.org/privilege/tethering.admin
2941 * @details If you set the visibility invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
2942 * @remarks This change is applied next time Wi-Fi tethering is enabled
2943 * @param[in] tethering The handle of tethering
2944 * @param[in] visible The visibility of SSID: (@c true = visible, @c false = invisible)
2945 * @return 0 on success, otherwise negative error value.
2946 * @retval #TETHERING_ERROR_NONE Successful
2947 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2948 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2949 * @see tethering_wifi_get_ssid_visibility()
2951 API int tethering_wifi_set_ssid_visibility(tethering_h tethering, bool visible)
2953 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2955 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2956 "parameter(tethering) is NULL\n");
2958 __tethering_h *th = (__tethering_h *)tethering;
2959 tethering_error_e ret = TETHERING_ERROR_NONE;
2961 ret = __set_visible(visible);
2962 if (ret == TETHERING_ERROR_NONE) {
2964 __send_dbus_signal(th->client_bus,
2965 SIGNAL_NAME_SSID_VISIBILITY_CHANGED,
2966 visible ? SIGNAL_MSG_SSID_VISIBLE :
2967 SIGNAL_MSG_SSID_HIDE);
2974 * @brief Gets the visibility of SSID(service set identifier).
2976 * @privlevel platform
2977 * @privilege http://tizen.org/privilege/tethering.admin
2978 * @details If the visibility is set invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
2979 * @param[in] tethering The handle of tethering
2980 * @param[out] visible The visibility of SSID: (@c true = visible, @c false = invisible)
2981 * @return 0 on success, otherwise negative error value.
2982 * @retval #TETHERING_ERROR_NONE Successful
2983 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2984 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2985 * @see tethering_wifi_set_ssid_visibility()
2987 API int tethering_wifi_get_ssid_visibility(tethering_h tethering, bool *visible)
2989 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
2991 _retvm_if(visible == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2992 "parameter(visible) is NULL\n");
2994 return __get_visible(visible);
2999 * @brief Sets the passphrase.
3001 * @privlevel platform
3002 * @privilege http://tizen.org/privilege/tethering.admin
3003 * @remarks This change is applied next time Wi-Fi tethering is enabled
3004 * @param[in] tethering The handle of tethering
3005 * @param[in] passphrase The passphrase
3006 * @return 0 on success, otherwise negative error value.
3007 * @retval #TETHERING_ERROR_NONE Successful
3008 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3009 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3010 * @see tethering_wifi_get_passphrase()
3012 API int tethering_wifi_set_passphrase(tethering_h tethering, const char *passphrase)
3014 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
3016 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3017 "parameter(tethering) is NULL\n");
3018 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3019 "parameter(passphrase) is NULL\n");
3021 __tethering_h *th = (__tethering_h *)tethering;
3022 int passphrase_len = 0;
3024 char old_passphrase[TETHERING_WIFI_KEY_MAX_LEN + 1] = {0, };
3025 unsigned int old_len = 0;
3026 tethering_error_e ret = TETHERING_ERROR_NONE;
3028 passphrase_len = strlen(passphrase);
3029 if (passphrase_len < TETHERING_WIFI_KEY_MIN_LEN ||
3030 passphrase_len > TETHERING_WIFI_KEY_MAX_LEN) {
3031 ERR("parameter(passphrase) is too short or long\n");
3032 return TETHERING_ERROR_INVALID_PARAMETER;
3035 ret = __get_passphrase(old_passphrase, sizeof(old_passphrase), &old_len);
3036 if (ret == TETHERING_ERROR_NONE && old_len == passphrase_len &&
3037 !g_strcmp0(old_passphrase, passphrase)) {
3038 return TETHERING_ERROR_NONE;
3041 ret = __set_passphrase(passphrase, passphrase_len);
3042 if (ret == TETHERING_ERROR_NONE) {
3043 __send_dbus_signal(th->client_bus,
3044 SIGNAL_NAME_PASSPHRASE_CHANGED, NULL);
3051 * @brief Gets the passphrase.
3053 * @privlevel platform
3054 * @privilege http://tizen.org/privilege/tethering.admin
3055 * @remarks @a passphrase must be released with free() by you.
3056 * @param[in] tethering The handle of tethering
3057 * @param[out] passphrase The passphrase
3058 * @return 0 on success, otherwise negative error value.
3059 * @retval #TETHERING_ERROR_NONE Successful
3060 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3061 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
3062 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3063 * @see tethering_wifi_set_passphrase()
3065 API int tethering_wifi_get_passphrase(tethering_h tethering, char **passphrase)
3067 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
3069 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3070 "parameter(tethering) is NULL\n");
3071 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3072 "parameter(passphrase) is NULL\n");
3074 char passphrase_buf[TETHERING_WIFI_KEY_MAX_LEN + 1] = {0, };
3075 unsigned int len = 0;
3076 tethering_error_e ret = TETHERING_ERROR_NONE;
3078 ret = __get_passphrase(passphrase_buf, sizeof(passphrase_buf), &len);
3079 if (ret != TETHERING_ERROR_NONE)
3082 *passphrase = strdup(passphrase_buf);
3083 if (*passphrase == NULL) {
3084 ERR("strdup is failed\n");
3085 return TETHERING_ERROR_OUT_OF_MEMORY;
3088 return TETHERING_ERROR_NONE;
3093 * @brief Reload the settings (SSID / Passphrase / Security type / SSID visibility).
3095 * @privlevel platform
3096 * @privilege http://tizen.org/privilege/tethering.admin
3097 * @remarks Connected devices via Wi-Fi tethering or MobileAP will be disconnected when the settings are reloaded
3098 * @param[in] tethering The handle of tethering
3099 * @param[in] callback The callback function to invoke
3100 * @param[in] user_data The user data to be passed to the callback function
3101 * @return 0 on success, otherwise negative error value.
3102 * @retval #TETHERING_ERROR_NONE Successful
3103 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3104 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3106 API int tethering_wifi_reload_settings(tethering_h tethering, tethering_wifi_settings_reloaded_cb callback, void *user_data)
3109 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
3111 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3112 "parameter(tethering) is NULL\n");
3113 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3114 "parameter(callback) is NULL\n");
3116 __tethering_h *th = (__tethering_h *)tethering;
3117 _softap_settings_t set = {"", "", 0, false};
3118 GDBusProxy *proxy = th->client_bus_proxy;
3123 if (th->settings_reloaded_cb) {
3124 ERR("Operation in progress\n");
3125 return TETHERING_ERROR_OPERATION_FAILED;
3128 ret = __prepare_wifi_settings(tethering, &set);
3129 if (ret != TETHERING_ERROR_NONE) {
3130 ERR("softap settings initialization failed\n");
3131 return TETHERING_ERROR_OPERATION_FAILED;
3134 th->settings_reloaded_cb = callback;
3135 th->settings_reloaded_user_data = user_data;
3137 g_dbus_proxy_call(proxy, "reload_wifi_settings",
3138 g_variant_new("(ssii)", set.ssid, set.key, set.visibility, set.sec_type),
3139 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
3140 (GAsyncReadyCallback) __settings_reloaded_cb, (gpointer)tethering);
3142 return TETHERING_ERROR_NONE;
3147 * @brief Sets the security type of Wi-Fi AP.
3149 * @privlevel platform
3150 * @privilege http://tizen.org/privilege/tethering.admin
3151 * @details If security type is not set, WPA2_PSK is used
3152 * @param[in] tethering The handle of tethering
3153 * @param[in] type The security type
3154 * @return 0 on success, otherwise negative error value.
3155 * @retval #TETHERING_ERROR_NONE Successful
3156 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3157 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3158 * @see tethering_wifi_ap_get_security_type()
3160 API int tethering_wifi_ap_set_security_type(tethering_h tethering, tethering_wifi_security_type_e type)
3162 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
3164 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3165 "parameter(tethering) is NULL\n");
3167 __tethering_h *th = (__tethering_h *)tethering;
3168 th->sec_type = type;
3169 return TETHERING_ERROR_NONE;
3174 * @brief Gets the security type of Wi-Fi AP.
3176 * @privlevel platform
3177 * @privilege http://tizen.org/privilege/tethering.admin
3178 * @details If security type is not set, WPA2_PSK is used
3179 * @param[in] tethering The handle of tethering
3180 * @param[out] type The security type
3181 * @return 0 on success, otherwise negative error value.
3182 * @retval #TETHERING_ERROR_NONE Successful
3183 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3184 * @see tethering_wifi_ap_set_security_type()
3186 API int tethering_wifi_ap_get_security_type(tethering_h tethering, tethering_wifi_security_type_e *type)
3188 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
3190 _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3191 "parameter(type) is NULL\n");
3193 __tethering_h *th = (__tethering_h *)tethering;
3195 *type = th->sec_type;
3196 return TETHERING_ERROR_NONE;
3201 * @brief Sets the SSID (service set identifier) for Wi-Fi AP. The SSID cannot exceed 32 bytes.
3203 * @privlevel platform
3204 * @privilege http://tizen.org/privilege/tethering.admin
3205 * @details If SSID is not set, Device name is used as SSID
3206 * @param[in] tethering The handle of tethering
3207 * @param[in] ssid The SSID
3208 * @return 0 on success, otherwise negative error value.
3209 * @retval #TETHERING_ERROR_NONE Successful
3210 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3211 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
3213 API int tethering_wifi_ap_set_ssid(tethering_h tethering, const char *ssid)
3215 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
3217 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3218 "parameter(tethering) is NULL\n");
3219 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3220 "parameter(ssid) is NULL\n");
3222 __tethering_h *th = (__tethering_h *)tethering;
3223 char *p_ssid = NULL;
3226 ssid_len = strlen(ssid);
3227 if (ssid_len > TETHERING_WIFI_SSID_MAX_LEN) {
3228 ERR("parameter(ssid) is too long");
3229 return TETHERING_ERROR_INVALID_PARAMETER;
3232 p_ssid = strdup(ssid);
3233 if (p_ssid == NULL) {
3234 ERR("strdup failed\n");
3235 return TETHERING_ERROR_OUT_OF_MEMORY;
3239 g_free(th->ap_ssid);
3240 th->ap_ssid = p_ssid;
3242 return TETHERING_ERROR_NONE;
3247 * @brief Gets the SSID (service set identifier) for Wi-Fi AP.
3249 * @privlevel platform
3250 * @privilege http://tizen.org/privilege/tethering.admin
3251 * @details If SSID is not set, Device name is used as SSID
3252 * @remarks @a ssid must be released with free() by you.
3253 * @param[in] tethering The handle of tethering
3254 * @param[out] ssid The SSID
3255 * @return 0 on success, otherwise negative error value.
3256 * @retval #TETHERING_ERROR_NONE Successful
3257 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3258 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
3260 API int tethering_wifi_ap_get_ssid(tethering_h tethering, char **ssid)
3262 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
3264 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3265 "parameter(tethering) is NULL\n");
3266 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3267 "parameter(ssid) is NULL\n");
3269 __tethering_h *th = (__tethering_h *)tethering;
3271 *ssid = g_strdup(th->ap_ssid);
3272 if (*ssid == NULL) {
3273 ERR("strdup failed\n");
3274 return TETHERING_ERROR_OUT_OF_MEMORY;
3277 return TETHERING_ERROR_NONE;
3282 * @brief Sets the visibility of SSID(service set identifier) for Wi-Fi AP.
3284 * @privlevel platform
3285 * @privilege http://tizen.org/privilege/tethering.admin
3286 * @details If you set the visibility invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
3287 * @details by default visibility is set to true.
3288 * @remarks This change is applied next time Wi-Fi tethering is enabled
3289 * @param[in] tethering The handle of tethering
3290 * @param[in] visible The visibility of SSID: (@c true = visible, @c false = invisible)
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
3295 * @see tethering_wifi_ap_get_ssid_visibility()
3297 API int tethering_wifi_ap_set_ssid_visibility(tethering_h tethering, bool visible)
3299 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
3301 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3302 "parameter(tethering) is NULL\n");
3304 __tethering_h *th = (__tethering_h *)tethering;
3305 th->visibility = visible;
3306 return TETHERING_ERROR_NONE;
3311 * @brief Gets the visibility of SSID(service set identifier) for Wi-Fi AP.
3313 * @privlevel platform
3314 * @privilege http://tizen.org/privilege/tethering.admin
3315 * @details If the visibility is set invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
3316 * @details by default visibility is set to true.
3317 * @param[in] tethering The handle of tethering
3318 * @param[out] visible The visibility of SSID: (@c true = visible, @c false = invisible)
3319 * @return 0 on success, otherwise negative error value.
3320 * @retval #TETHERING_ERROR_NONE Successful
3321 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3322 * @see tethering_wifi_ap_set_ssid_visibility()
3324 API int tethering_wifi_ap_get_ssid_visibility(tethering_h tethering, bool *visible)
3326 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
3328 _retvm_if(visible == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3329 "parameter(visible) is NULL\n");
3331 __tethering_h *th = (__tethering_h *)tethering;
3333 *visible = th->visibility;
3334 return TETHERING_ERROR_NONE;
3339 * @brief Sets the passphrase for Wi-Fi AP.
3341 * @privlevel platform
3342 * @privilege http://tizen.org/privilege/tethering.admin
3343 * @details If the passphrase is not set, random string of 8 alphabets will be used.
3344 * @param[in] tethering The handle of tethering
3345 * @param[in] passphrase The passphrase
3346 * @return 0 on success, otherwise negative error value.
3347 * @retval #TETHERING_ERROR_NONE Successful
3348 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3349 * @see tethering_wifi_ap_get_passphrase()
3351 API int tethering_wifi_ap_set_passphrase(tethering_h tethering, const char *passphrase)
3353 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
3355 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3356 "parameter(tethering) is NULL\n");
3357 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3358 "parameter(passphrase) is NULL\n");
3360 __tethering_h *th = (__tethering_h *)tethering;
3361 int passphrase_len = 0;
3363 passphrase_len = strlen(passphrase);
3365 if (passphrase_len < TETHERING_WIFI_KEY_MIN_LEN ||
3366 passphrase_len > TETHERING_WIFI_KEY_MAX_LEN) {
3367 ERR("parameter(passphrase) is too short or long\n");
3368 return TETHERING_ERROR_INVALID_PARAMETER;
3371 if (!g_strcmp0(passphrase, th->passphrase))
3372 return TETHERING_ERROR_NONE;
3374 g_strlcpy(th->passphrase, passphrase, sizeof(th->passphrase));
3375 return TETHERING_ERROR_NONE;
3380 * @brief Gets the passphrase for Wi-Fi AP.
3382 * @privlevel platform
3383 * @privilege http://tizen.org/privilege/tethering.admin
3384 * @details If the passphrase is not set, random string of 8 alphabets will be used.
3385 * @remarks @a passphrase must be released with free() by you.
3386 * @param[in] tethering The handle of tethering
3387 * @param[out] passphrase The passphrase
3388 * @return 0 on success, otherwise negative error value.
3389 * @retval #TETHERING_ERROR_NONE Successful
3390 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3391 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
3392 * @see tethering_wifi_ap_set_passphrase()
3394 API int tethering_wifi_ap_get_passphrase(tethering_h tethering, char **passphrase)
3396 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
3398 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3399 "parameter(tethering) is NULL\n");
3400 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3401 "parameter(passphrase) is NULL\n");
3403 __tethering_h *th = (__tethering_h *)tethering;
3405 *passphrase = g_strdup(th->passphrase);
3406 if (*passphrase == NULL) {
3407 ERR("strdup is failed\n");
3408 return TETHERING_ERROR_OUT_OF_MEMORY;
3411 return TETHERING_ERROR_NONE;
3416 * @brief Reload the settings (SSID / Passphrase / Security type / SSID visibility) for Wi-Fi AP.
3418 * @privlevel platform
3419 * @privilege http://tizen.org/privilege/tethering.admin
3420 * @remarks Connected devices via MobileAP will be disconnected when the settings are reloaded
3421 * @param[in] tethering The handle of tethering
3422 * @param[in] callback The callback function to invoke
3423 * @param[in] user_data The user data to be passed to the callback function
3424 * @return 0 on success, otherwise negative error value.
3425 * @retval #TETHERING_ERROR_NONE Successful
3426 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3427 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3429 API int tethering_wifi_ap_reload_settings(tethering_h tethering, tethering_wifi_ap_settings_reloaded_cb callback, void *user_data)
3432 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE, TETHERING_WIFI_FEATURE);
3434 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3435 "parameter(tethering) is NULL\n");
3436 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3437 "parameter(callback) is NULL\n");
3439 __tethering_h *th = (__tethering_h *)tethering;
3440 _softap_settings_t set = {"", "", 0, false};
3441 GDBusProxy *proxy = th->client_bus_proxy;
3446 if (th->ap_settings_reloaded_cb) {
3447 ERR("Operation in progress\n");
3448 return TETHERING_ERROR_OPERATION_FAILED;
3451 ret = __prepare_wifi_ap_settings(tethering, &set);
3452 if (ret != TETHERING_ERROR_NONE) {
3453 ERR("softap settings initialization failed\n");
3454 return TETHERING_ERROR_OPERATION_FAILED;
3457 th->ap_settings_reloaded_cb = callback;
3458 th->ap_settings_reloaded_user_data = user_data;
3460 g_dbus_proxy_call(proxy, "reload_wifi_ap_settings",
3461 g_variant_new("(ssii)", set.ssid, set.key, set.visibility, set.sec_type),
3462 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
3463 (GAsyncReadyCallback) __ap_settings_reloaded_cb, (gpointer)tethering);
3465 return TETHERING_ERROR_NONE;