2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
20 #include <sys/ioctl.h>
21 #include <sys/socket.h>
22 #include <netinet/in.h>
24 #include <arpa/inet.h>
26 #include <dbus/dbus.h>
29 #include <openssl/evp.h>
30 #include <openssl/sha.h>
31 #include <ckmc/ckmc-manager.h>
32 #include <tzplatform_config.h>
33 #include "tethering_private.h"
35 #define ALLOWED_LIST tzplatform_mkpath(TZ_SYS_VAR, "/lib/hostapd/hostapd.accept")
36 #define BLOCKED_LIST tzplatform_mkpath(TZ_SYS_VAR, "/lib/hostapd/hostapd.deny")
37 #define TEMP_LIST tzplatform_mkpath(TZ_SYS_VAR, "/lib/hostapd/.hostapd_tmp")
38 #define MAC_ADDR_LEN 18
39 #define MAX_BUF_SIZE 80
41 #define IPTABLES "/usr/sbin/iptables"
42 #define TABLE_NAT "nat"
43 #define TETH_NAT_PRE "teth_nat_pre"
44 #define TABLE_FILTER "filter"
45 #define TETH_FILTER_FW "teth_filter_fw"
46 #define ACTION_DROP "DROP"
47 #define ACTION_ACCEPT "ACCEPT"
48 #define PORT_FORWARD_RULE_STR "-t %s -A %s -i %s -p %s -d %s --dport %d -j DNAT --to %s:%d"
49 #define FILTERING_MULTIPORT_RULE_STR "-t %s -A %s -p %s -m multiport --dport %d,%d -j %s"
50 #define FILTERING_RULE_STR "-t %s -A %s -p %s --dport %d -j %s"
52 static GSList *allowed_list = NULL;
53 static GSList *blocked_list = NULL;
54 static GSList *port_forwarding = NULL;
55 static GSList *port_filtering = NULL;
56 static GSList *custom_port_filtering = NULL;
58 static void __handle_wifi_tether_on(GDBusConnection *connection, const gchar *sender_name,
59 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
60 GVariant *parameters, gpointer user_data);
62 static void __handle_wifi_tether_off(GDBusConnection *connection, const gchar *sender_name,
63 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
64 GVariant *parameters, gpointer user_data);
66 static void __handle_usb_tether_on(GDBusConnection *connection, const gchar *sender_name,
67 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
68 GVariant *parameters, gpointer user_data);
70 static void __handle_usb_tether_off(GDBusConnection *connection, const gchar *sender_name,
71 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
72 GVariant *parameters, gpointer user_data);
74 static void __handle_bt_tether_on(GDBusConnection *connection, const gchar *sender_name,
75 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
76 GVariant *parameters, gpointer user_data);
78 static void __handle_bt_tether_off(GDBusConnection *connection, const gchar *sender_name,
79 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
80 GVariant *parameters, gpointer user_data);
82 static void __handle_net_closed(GDBusConnection *connection, const gchar *sender_name,
83 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
84 GVariant *parameters, gpointer user_data);
86 static void __handle_no_data_timeout(GDBusConnection *connection, const gchar *sender_name,
87 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
88 GVariant *parameters, gpointer user_data);
90 static void __handle_low_battery_mode(GDBusConnection *connection, const gchar *sender_name,
91 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
92 GVariant *parameters, gpointer user_data);
94 static void __handle_flight_mode(GDBusConnection *connection, const gchar *sender_name,
95 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
96 GVariant *parameters, gpointer user_data);
98 static void __handle_security_type_changed(GDBusConnection *connection, const gchar *sender_name,
99 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
100 GVariant *parameters, gpointer user_data);
102 static void __handle_ssid_visibility_changed(GDBusConnection *connection, const gchar *sender_name,
103 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
104 GVariant *parameters, gpointer user_data);
106 static void __handle_passphrase_changed(GDBusConnection *connection, const gchar *sender_name,
107 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
108 GVariant *parameters, gpointer user_data);
110 static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name,
111 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
112 GVariant *parameters, gpointer user_data);
114 static __tethering_sig_t sigs[] = {
115 {0, SIGNAL_NAME_NET_CLOSED, __handle_net_closed},
116 {0, SIGNAL_NAME_WIFI_TETHER_ON, __handle_wifi_tether_on},
117 {0, SIGNAL_NAME_WIFI_TETHER_OFF, __handle_wifi_tether_off},
118 {0, SIGNAL_NAME_USB_TETHER_ON, __handle_usb_tether_on},
119 {0, SIGNAL_NAME_USB_TETHER_OFF, __handle_usb_tether_off},
120 {0, SIGNAL_NAME_BT_TETHER_ON, __handle_bt_tether_on},
121 {0, SIGNAL_NAME_BT_TETHER_OFF, __handle_bt_tether_off},
122 {0, SIGNAL_NAME_NO_DATA_TIMEOUT, __handle_no_data_timeout},
123 {0, SIGNAL_NAME_LOW_BATTERY_MODE, __handle_low_battery_mode},
124 {0, SIGNAL_NAME_FLIGHT_MODE, __handle_flight_mode},
125 {0, SIGNAL_NAME_SECURITY_TYPE_CHANGED, __handle_security_type_changed},
126 {0, SIGNAL_NAME_SSID_VISIBILITY_CHANGED, __handle_ssid_visibility_changed},
127 {0, SIGNAL_NAME_PASSPHRASE_CHANGED, __handle_passphrase_changed},
128 {0, SIGNAL_NAME_DHCP_STATUS, __handle_dhcp},
131 static int retry = 0;
133 static void __send_dbus_signal(GDBusConnection *conn, const char *signal_name, const char *arg)
135 if (conn == NULL || signal_name == NULL)
136 return; //LCOV_EXCL_LINE
138 GVariant *message = NULL;
139 GError *error = NULL;
142 message = g_variant_new("(s)", arg);
144 g_dbus_connection_emit_signal(conn, NULL, TETHERING_SERVICE_OBJECT_PATH,
145 TETHERING_SERVICE_INTERFACE, signal_name, message, &error);
147 ERR("g_dbus_connection_emit_signal is failed because %s\n", error->message); //LCOV_EXCL_LINE
148 g_error_free(error); //LCOV_EXCL_LINE
150 g_variant_unref(message);
153 static bool __any_tethering_is_enabled(tethering_h tethering)
155 if (tethering_is_enabled(tethering, TETHERING_TYPE_USB) ||
156 tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) ||
157 tethering_is_enabled(tethering, TETHERING_TYPE_BT))
163 static tethering_error_e __set_security_type(const tethering_wifi_security_type_e security_type)
165 if (security_type != TETHERING_WIFI_SECURITY_TYPE_NONE &&
166 security_type != TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK &&
167 security_type != TETHERING_WIFI_SECURITY_TYPE_WPS) {
168 ERR("Invalid param\n");
169 return TETHERING_ERROR_INVALID_PARAMETER;
172 if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY, security_type) < 0) {
173 ERR("vconf_set_int is failed\n");
174 return TETHERING_ERROR_OPERATION_FAILED;
177 return TETHERING_ERROR_NONE;
180 static tethering_error_e __get_security_type(tethering_wifi_security_type_e *security_type)
182 if (security_type == NULL) {
183 ERR("Invalid param\n");
184 return TETHERING_ERROR_INVALID_PARAMETER;
187 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY,
188 (int *)security_type) < 0) {
189 ERR("vconf_get_int is failed\n");
190 return TETHERING_ERROR_OPERATION_FAILED;
193 return TETHERING_ERROR_NONE;
196 static bool __get_ssid_from_vconf(const char *path, char *ssid, unsigned int size)
198 if (path == NULL || ssid == NULL || size == 0)
202 char *ptr_tmp = NULL;
204 ptr = vconf_get_str(path);
208 if (!g_utf8_validate(ptr, -1, (const char **)&ptr_tmp))
211 g_strlcpy(ssid, ptr, size);
217 static tethering_error_e __set_visible(const bool visible)
219 if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, visible ? 0 : 1) < 0) {
220 ERR("vconf_set_int is failed\n");
221 return TETHERING_ERROR_OPERATION_FAILED;
224 return TETHERING_ERROR_NONE;
227 static tethering_error_e __get_visible(bool *visible)
229 if (visible == NULL) {
230 ERR("Invalid param\n");
231 return TETHERING_ERROR_INVALID_PARAMETER;
236 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, &hide) < 0) {
237 ERR("vconf_get_int is failed\n");
238 return TETHERING_ERROR_OPERATION_FAILED;
245 return TETHERING_ERROR_NONE;
248 static unsigned int __generate_initial_passphrase(char *passphrase, unsigned int size)
250 if (passphrase == NULL ||
251 size == 0 || size < TETHERING_WIFI_KEY_MIN_LEN + 1)
254 guint32 rand_int = 0;
257 for (index = 0; index < TETHERING_WIFI_KEY_MIN_LEN; index++) {
258 rand_int = g_random_int_range('a', 'z');
259 passphrase[index] = rand_int;
261 passphrase[index] = '\0';
266 static tethering_error_e __get_error(int agent_error)
268 tethering_error_e err = TETHERING_ERROR_NONE;
270 switch (agent_error) {
271 case MOBILE_AP_ERROR_NONE:
272 err = TETHERING_ERROR_NONE;
276 case MOBILE_AP_ERROR_RESOURCE:
277 err = TETHERING_ERROR_OUT_OF_MEMORY;
281 case MOBILE_AP_ERROR_INTERNAL:
282 err = TETHERING_ERROR_OPERATION_FAILED;
285 case MOBILE_AP_ERROR_INVALID_PARAM:
286 err = TETHERING_ERROR_INVALID_PARAMETER;
289 case MOBILE_AP_ERROR_ALREADY_ENABLED:
290 err = TETHERING_ERROR_OPERATION_FAILED;
293 case MOBILE_AP_ERROR_NOT_ENABLED:
294 err = TETHERING_ERROR_NOT_ENABLED;
297 case MOBILE_AP_ERROR_NET_OPEN:
298 err = TETHERING_ERROR_OPERATION_FAILED;
301 case MOBILE_AP_ERROR_NET_CLOSE:
302 err = TETHERING_ERROR_OPERATION_FAILED;
305 case MOBILE_AP_ERROR_DHCP:
306 err = TETHERING_ERROR_OPERATION_FAILED;
309 case MOBILE_AP_ERROR_IN_PROGRESS:
310 err = TETHERING_ERROR_OPERATION_FAILED;
314 case MOBILE_AP_ERROR_NOT_PERMITTED:
315 err = TETHERING_ERROR_NOT_PERMITTED;
318 case MOBILE_AP_ERROR_PERMISSION_DENIED:
319 err = TETHERING_ERROR_PERMISSION_DENIED;
323 ERR("Not defined error : %d\n", agent_error);
324 err = TETHERING_ERROR_OPERATION_FAILED;
332 static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name,
333 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
334 GVariant *parameters, gpointer user_data)
338 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
340 __tethering_h *th = (__tethering_h *)user_data;
342 tethering_type_e type = 0;
343 mobile_ap_type_e ap_type = 0;
344 tethering_connection_state_changed_cb ccb = NULL;
345 __tethering_client_h client;
353 memset(&client, 0, sizeof(__tethering_client_h));
354 g_variant_get(parameters, "(susssu)", &buf, &ap_type, &ip, &mac, &name, ×tamp);
356 if (!g_strcmp0(buf, "DhcpConnected")) {
358 } else if (!g_strcmp0(buf, "DhcpLeaseDeleted")) {
361 ERR("Unknown event [%s]\n", buf);
365 if (ap_type == MOBILE_AP_TYPE_USB)
366 type = TETHERING_TYPE_USB;
367 else if (ap_type == MOBILE_AP_TYPE_WIFI)
368 type = TETHERING_TYPE_WIFI;
369 else if (ap_type == MOBILE_AP_TYPE_BT)
370 type = TETHERING_TYPE_BT;
372 ERR("Not supported tethering type [%d]\n", ap_type);
376 ccb = th->changed_cb[type];
379 data = th->changed_user_data[type];
381 client.interface = type;
382 g_strlcpy(client.ip, ip, sizeof(client.ip));
383 g_strlcpy(client.mac, mac, sizeof(client.mac));
385 client.hostname = g_strdup(name);
386 client.tm = (time_t)timestamp;
388 ccb((tethering_client_h)&client, opened, data);
389 g_free(client.hostname);
400 static void __handle_net_closed(GDBusConnection *connection, const gchar *sender_name,
401 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
402 GVariant *parameters, gpointer user_data)
406 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
408 __tethering_h *th = (__tethering_h *)user_data;
409 tethering_type_e type = 0;
410 tethering_disabled_cb dcb = NULL;
412 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_NETWORK_CLOSE;
414 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
415 dcb = th->disabled_cb[type];
418 data = th->disabled_user_data[type];
420 dcb(TETHERING_ERROR_NONE, type, code, data);
427 static void __handle_wifi_tether_on(GDBusConnection *connection, const gchar *sender_name,
428 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
429 GVariant *parameters, gpointer user_data)
433 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
435 __tethering_h *th = (__tethering_h *)user_data;
436 tethering_type_e type = TETHERING_TYPE_WIFI;
437 bool is_requested = false;
438 tethering_enabled_cb ecb = NULL;
441 ecb = th->enabled_cb[type];
444 data = th->enabled_user_data[type];
446 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
450 static void __handle_wifi_tether_off(GDBusConnection *connection, const gchar *sender_name,
451 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
452 GVariant *parameters, gpointer user_data)
456 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
458 __tethering_h *th = (__tethering_h *)user_data;
459 tethering_type_e type = TETHERING_TYPE_WIFI;
460 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
461 tethering_disabled_cb dcb = NULL;
465 dcb = th->disabled_cb[type];
468 data = th->disabled_user_data[type];
469 g_variant_get(parameters, "(s)", &buf);
470 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
471 code = TETHERING_DISABLED_BY_WIFI_ON;
472 else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT))
473 code = TETHERING_DISABLED_BY_TIMEOUT;
476 dcb(TETHERING_ERROR_NONE, type, code, data);
482 static void __handle_usb_tether_on(GDBusConnection *connection, const gchar *sender_name,
483 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
484 GVariant *parameters, gpointer user_data)
488 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
490 __tethering_h *th = (__tethering_h *)user_data;
491 tethering_type_e type = TETHERING_TYPE_USB;
492 bool is_requested = false;
493 tethering_enabled_cb ecb = NULL;
496 ecb = th->enabled_cb[type];
499 data = th->enabled_user_data[type];
501 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
505 static void __handle_usb_tether_off(GDBusConnection *connection, const gchar *sender_name,
506 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
507 GVariant *parameters, gpointer user_data)
511 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
513 __tethering_h *th = (__tethering_h *)user_data;
514 tethering_type_e type = TETHERING_TYPE_USB;
515 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
516 tethering_disabled_cb dcb = NULL;
520 dcb = th->disabled_cb[type];
523 data = th->disabled_user_data[type];
525 g_variant_get(parameters, "(s)", &buf);
526 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
527 code = TETHERING_DISABLED_BY_USB_DISCONNECTION;
529 dcb(TETHERING_ERROR_NONE, type, code, data);
535 static void __handle_bt_tether_on(GDBusConnection *connection, const gchar *sender_name,
536 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
537 GVariant *parameters, gpointer user_data)
541 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
543 __tethering_h *th = (__tethering_h *)user_data;
544 tethering_type_e type = TETHERING_TYPE_BT;
545 bool is_requested = false;
546 tethering_enabled_cb ecb = NULL;
549 ecb = th->enabled_cb[type];
552 data = th->enabled_user_data[type];
554 ecb(TETHERING_ERROR_NONE, type, is_requested, data);
558 static void __handle_bt_tether_off(GDBusConnection *connection, const gchar *sender_name,
559 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
560 GVariant *parameters, gpointer user_data)
564 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
566 __tethering_h *th = (__tethering_h *)user_data;
567 tethering_type_e type = TETHERING_TYPE_BT;
568 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
569 tethering_disabled_cb dcb = NULL;
573 dcb = th->disabled_cb[type];
576 data = th->disabled_user_data[type];
577 g_variant_get(parameters, "(s)", &buf);
578 if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
579 code = TETHERING_DISABLED_BY_BT_OFF;
580 else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT))
581 code = TETHERING_DISABLED_BY_TIMEOUT;
583 dcb(TETHERING_ERROR_NONE, type, code, data);
590 static void __handle_no_data_timeout(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 = 0;
600 tethering_disabled_cb dcb = NULL;
602 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_TIMEOUT;
604 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
605 dcb = th->disabled_cb[type];
608 data = th->disabled_user_data[type];
610 dcb(TETHERING_ERROR_NONE, type, code, data);
615 static void __handle_low_battery_mode(GDBusConnection *connection, const gchar *sender_name,
616 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
617 GVariant *parameters, gpointer user_data)
621 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
623 __tethering_h *th = (__tethering_h *)user_data;
624 tethering_type_e type = 0;
625 tethering_disabled_cb dcb = NULL;
627 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_LOW_BATTERY;
629 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
630 dcb = th->disabled_cb[type];
633 data = th->disabled_user_data[type];
635 dcb(TETHERING_ERROR_NONE, type, code, data);
640 static void __handle_flight_mode(GDBusConnection *connection, const gchar *sender_name,
641 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
642 GVariant *parameters, gpointer user_data)
646 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
648 __tethering_h *th = (__tethering_h *)user_data;
649 tethering_type_e type = 0;
650 tethering_disabled_cb dcb = NULL;
652 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_FLIGHT_MODE;
654 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
655 dcb = th->disabled_cb[type];
658 data = th->disabled_user_data[type];
660 dcb(TETHERING_ERROR_NONE, type, code, data);
666 static void __handle_security_type_changed(GDBusConnection *connection, const gchar *sender_name,
667 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
668 GVariant *parameters, gpointer user_data)
673 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
674 __tethering_h *th = (__tethering_h *)user_data;
676 tethering_wifi_security_type_changed_cb scb = NULL;
678 tethering_wifi_security_type_e security_type;
681 scb = th->security_type_changed_cb;
685 g_variant_get(parameters, "(s)", &buf);
686 data = th->security_type_user_data;
687 if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_OPEN_STR) == 0)
688 security_type = TETHERING_WIFI_SECURITY_TYPE_NONE;
689 else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR) == 0)
690 security_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK;
691 else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_WPS_STR) == 0)
692 security_type = TETHERING_WIFI_SECURITY_TYPE_WPS;
694 SERR("Unknown type : %s\n", buf);
699 scb(security_type, data);
704 static void __handle_ssid_visibility_changed(GDBusConnection *connection, const gchar *sender_name,
705 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
706 GVariant *parameters, gpointer user_data)
710 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
711 __tethering_h *th = (__tethering_h *)user_data;
713 tethering_wifi_ssid_visibility_changed_cb scb = NULL;
715 bool visible = false;
718 scb = th->ssid_visibility_changed_cb;
723 g_variant_get(parameters, "(s)", &buf);
724 data = th->ssid_visibility_user_data;
725 if (g_strcmp0(buf, SIGNAL_MSG_SSID_VISIBLE) == 0)
733 static void __handle_passphrase_changed(GDBusConnection *connection, const gchar *sender_name,
734 const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
735 GVariant *parameters, gpointer user_data)
739 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
740 __tethering_h *th = (__tethering_h *)user_data;
742 tethering_wifi_passphrase_changed_cb pcb = NULL;
745 pcb = th->passphrase_changed_cb;
749 data = th->passphrase_user_data;
755 static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
760 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
761 GError *g_error = NULL;
764 tethering_error_e error;
765 __tethering_h *th = (__tethering_h *)user_data;
766 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_WIFI];
767 void *data = th->enabled_user_data[TETHERING_TYPE_WIFI];
769 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
772 ERR("DBus error [%s]\n", g_error->message);
773 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
774 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
775 g_error_free(g_error);
776 tethering_enable((tethering_h)th, TETHERING_TYPE_WIFI);
778 } else if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
779 error = TETHERING_ERROR_PERMISSION_DENIED;
781 error = TETHERING_ERROR_OPERATION_FAILED;
782 g_error_free(g_error);
785 g_variant_get(g_var, "(u)", &info);
786 error = __get_error(info);
790 INFO("cfm event : wifi tethering enable info : %d\n", error);
792 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
793 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_ON].name,
794 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
795 sigs[E_SIGNAL_WIFI_TETHER_ON].cb, (gpointer)th, NULL);
801 ecb(error, TETHERING_TYPE_WIFI, true, data);
802 g_variant_unref(g_var);
806 static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
810 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
811 GError *g_error = NULL;
814 tethering_error_e error;
816 __tethering_h *th = (__tethering_h *)user_data;
817 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_BT];
818 void *data = th->enabled_user_data[TETHERING_TYPE_BT];
820 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
823 ERR("DBus error [%s]\n", g_error->message);
824 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
825 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
826 g_error_free(g_error);
827 tethering_enable((tethering_h)th, TETHERING_TYPE_BT);
831 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
832 error = TETHERING_ERROR_PERMISSION_DENIED;
834 error = TETHERING_ERROR_OPERATION_FAILED;
835 g_error_free(g_error);
838 g_variant_get(g_var, "(u)", &info);
839 g_variant_unref(g_var);
840 error = __get_error(info);
844 sigs[E_SIGNAL_BT_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
845 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_ON].name,
846 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
847 sigs[E_SIGNAL_BT_TETHER_ON].cb, (gpointer)th, NULL);
854 ecb(error, TETHERING_TYPE_BT, true, data);
859 static void __usb_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
864 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
865 __tethering_h *th = (__tethering_h *)user_data;
866 GError *g_error = NULL;
869 tethering_error_e error;
870 tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_USB];
871 void *data = th->enabled_user_data[TETHERING_TYPE_USB];
873 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
875 ERR("DBus error [%s]\n", g_error->message);
876 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
877 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
878 g_error_free(g_error);
879 tethering_enable((tethering_h)th, TETHERING_TYPE_USB);
883 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
884 error = TETHERING_ERROR_PERMISSION_DENIED;
886 error = TETHERING_ERROR_OPERATION_FAILED;
887 g_error_free(g_error);
889 g_variant_get(g_var, "(u)", &info);
890 g_variant_unref(g_var);
891 error = __get_error(info);
895 sigs[E_SIGNAL_USB_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
896 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_ON].name,
897 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
898 sigs[E_SIGNAL_USB_TETHER_ON].cb, (gpointer)th, NULL);
905 ecb(error, TETHERING_TYPE_USB, true, data);
910 static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res,
915 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
916 GError *g_error = NULL;
918 guint info, event_type;
919 tethering_error_e error;
920 tethering_type_e type;
921 tethering_h tethering = (tethering_h)user_data;
922 __tethering_h *th = (__tethering_h *)tethering;
923 tethering_disabled_cause_e code = TETHERING_DISABLED_BY_REQUEST;
924 tethering_disabled_cb dcb = NULL;
927 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
930 ERR("DBus error [%s]\n", g_error->message);
931 g_error_free(g_error);
935 g_variant_get(g_var, "(uu)", &event_type, &info);
936 INFO("cfm event : %d info : %d\n", event_type, info);
937 g_variant_unref(g_var);
938 error = __get_error(info);
939 INFO("cfm event : %d info : %d\n", event_type, error);
940 switch (event_type) {
941 case MOBILE_AP_DISABLE_WIFI_TETHERING_CFM:
942 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
943 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_OFF].name,
944 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
945 sigs[E_SIGNAL_WIFI_TETHER_OFF].cb, (gpointer)th, NULL);
947 type = TETHERING_TYPE_WIFI;
948 dcb = th->disabled_cb[type];
949 data = th->disabled_user_data[type];
951 dcb(error, type, code, data);
954 case MOBILE_AP_DISABLE_BT_TETHERING_CFM:
955 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
956 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_OFF].name,
957 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
958 sigs[E_SIGNAL_BT_TETHER_OFF].cb, (gpointer)th, NULL);
960 type = TETHERING_TYPE_BT;
961 dcb = th->disabled_cb[type];
962 data = th->disabled_user_data[type];
964 dcb(error, type, code, data);
968 case MOBILE_AP_DISABLE_USB_TETHERING_CFM:
969 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
970 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
971 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
972 sigs[E_SIGNAL_USB_TETHER_OFF].cb, (gpointer)th, NULL);
974 type = TETHERING_TYPE_USB;
975 dcb = th->disabled_cb[type];
976 data = th->disabled_user_data[type];
978 dcb(error, type, code, data);
982 case MOBILE_AP_DISABLE_CFM:
984 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
985 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_OFF].name,
986 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
987 sigs[E_SIGNAL_WIFI_TETHER_OFF].cb, (gpointer)th, NULL);
988 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
989 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_OFF].name,
990 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
991 sigs[E_SIGNAL_BT_TETHER_OFF].cb, (gpointer)th, NULL);
992 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
993 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
994 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
995 sigs[E_SIGNAL_USB_TETHER_OFF].cb, (gpointer)th, NULL);
997 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
998 dcb = th->disabled_cb[type];
1001 data = th->disabled_user_data[type];
1003 dcb(error, type, code, data);
1008 ERR("Invalid event\n");
1014 static void __get_data_usage_cb(GObject *source_object, GAsyncResult *res,
1019 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1021 GError *g_error = NULL;
1024 guint64 tx_bytes, rx_bytes;
1025 __tethering_h *th = (__tethering_h *)user_data;
1026 tethering_error_e tethering_error = TETHERING_ERROR_NONE;
1029 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1032 ERR("DBus fail [%s]\n", g_error->message);
1033 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1034 tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1036 tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1041 if (th->data_usage_cb == NULL) {
1042 ERR("There is no data_usage_cb\n");
1046 th->data_usage_cb(tethering_error, 0LL, 0LL, th->data_usage_user_data);
1048 g_variant_get(g_var, "(utt)", &event_type, &tx_bytes, &rx_bytes);
1049 th->data_usage_cb(TETHERING_ERROR_NONE,
1050 rx_bytes, tx_bytes, th->data_usage_user_data);
1051 g_variant_unref(g_var);
1053 th->data_usage_cb = NULL;
1054 th->data_usage_user_data = NULL;
1059 static void __settings_reloaded_cb(GObject *source_object, GAsyncResult *res,
1064 _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1065 GError *g_error = NULL;
1068 __tethering_h *th = (__tethering_h *)user_data;
1069 tethering_error_e tethering_error;
1071 g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1073 ERR("DBus fail [%s]\n", g_error->message);
1074 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1075 tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1077 tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1078 g_error_free(g_error);
1080 if (th->settings_reloaded_cb == NULL) {
1081 DBG("There is no settings_reloaded_cb\n-\n");
1084 g_variant_get(g_var, "(u)", &info);
1085 tethering_error = __get_error(info);
1086 g_variant_unref(g_var);
1088 th->settings_reloaded_cb(tethering_error,
1089 th->settings_reloaded_user_data);
1091 th->settings_reloaded_cb = NULL;
1092 th->settings_reloaded_user_data = NULL;
1096 static void __connect_signals(tethering_h tethering)
1099 _retm_if(tethering == NULL, "parameter(tethering) is NULL\n");
1101 __tethering_h *th = (__tethering_h *)tethering;
1102 GDBusConnection *connection = th->client_bus;
1105 for (i = E_SIGNAL_NET_CLOSED; i < E_SIGNAL_MAX; i++) {
1106 sigs[i].sig_id = g_dbus_connection_signal_subscribe(connection,
1107 NULL, TETHERING_SERVICE_INTERFACE, sigs[i].name,
1108 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1109 sigs[i].cb, tethering, NULL);
1114 static void __disconnect_signals(tethering_h tethering)
1118 _retm_if(tethering == NULL, "parameter(tethering) is NULL\n");
1120 __tethering_h *th = (__tethering_h *)tethering;
1121 GDBusConnection *connection = th->client_bus;
1125 for (i = E_SIGNAL_NET_CLOSED; i < E_SIGNAL_MAX; i++)
1126 g_dbus_connection_signal_unsubscribe(connection, sigs[i].sig_id);
1132 static bool __get_intf_name(tethering_type_e type, char *buf, unsigned int len)
1134 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1138 case TETHERING_TYPE_USB:
1139 g_strlcpy(buf, TETHERING_USB_IF, len);
1142 case TETHERING_TYPE_WIFI:
1143 g_strlcpy(buf, TETHERING_WIFI_IF, len);
1146 case TETHERING_TYPE_BT:
1147 g_strlcpy(buf, TETHERING_BT_IF, len);
1151 ERR("Not supported type : %d\n", type);
1157 static bool __get_gateway_addr(tethering_type_e type, char *buf, unsigned int len)
1159 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1162 case TETHERING_TYPE_USB:
1163 g_strlcpy(buf, TETHERING_USB_GATEWAY, len);
1166 case TETHERING_TYPE_WIFI:
1167 g_strlcpy(buf, TETHERING_WIFI_GATEWAY, len);
1170 case TETHERING_TYPE_BT:
1171 g_strlcpy(buf, TETHERING_BT_GATEWAY, len);
1175 ERR("Not supported type : %d\n", type);
1181 static int __get_common_ssid(char *ssid, unsigned int size)
1184 ERR("ssid is null\n"); //LCOV_EXCL_LINE
1185 return TETHERING_ERROR_INVALID_PARAMETER;
1189 char *ptr_tmp = NULL;
1191 ptr = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
1193 ERR("vconf_get_str is failed and set default ssid");
1194 g_strlcpy(ssid, TETHERING_DEFAULT_SSID, size);
1196 g_strlcpy(ssid, ptr, size);
1200 if (!g_utf8_validate(ssid, -1, (const char **)&ptr_tmp))
1203 return TETHERING_ERROR_NONE;
1206 static bool __get_wifi_mode_type(tethering_wifi_mode_type_e type, char **buf)
1208 _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1211 case TETHERING_WIFI_MODE_TYPE_B:
1212 *buf = g_strdup("b");
1214 case TETHERING_WIFI_MODE_TYPE_G:
1215 *buf = g_strdup("g");
1217 case TETHERING_WIFI_MODE_TYPE_A:
1218 *buf = g_strdup("a");
1220 case TETHERING_WIFI_MODE_TYPE_AD:
1221 *buf = g_strdup("ad");
1224 ERR("Not supported type : %d\n", type);
1230 static int __prepare_wifi_settings(tethering_h tethering, _softap_settings_t *set)
1234 __tethering_h *th = (__tethering_h *)tethering;
1235 tethering_error_e ret = TETHERING_ERROR_NONE;
1238 if (th == NULL || set == NULL) {
1239 ERR("null parameter\n-\n");
1240 return TETHERING_ERROR_INVALID_PARAMETER;
1243 if (th->ssid == NULL)
1244 __get_common_ssid(set->ssid, sizeof(set->ssid));
1246 g_strlcpy(set->ssid, th->ssid, sizeof(set->ssid));
1248 ret = __get_security_type(&set->sec_type);
1249 if (ret != TETHERING_ERROR_NONE)
1250 set->sec_type = th->sec_type;
1252 ret = __get_visible(&set->visibility);
1253 if (ret != TETHERING_ERROR_NONE)
1254 set->visibility = th->visibility;
1256 set->mac_filter = th->mac_filter;
1257 set->max_connected = th->wifi_max_connected;
1258 set->channel = th->channel;
1260 __get_wifi_mode_type(th->mode_type, &ptr);
1262 g_strlcpy(set->mode, "", sizeof(set->mode));
1264 g_strlcpy(set->mode, ptr, sizeof(set->mode));
1268 if (set->sec_type == TETHERING_WIFI_SECURITY_TYPE_NONE) {
1269 g_strlcpy(set->key, "", sizeof(set->key));
1271 GDBusProxy *proxy = th->client_bus_proxy;
1272 GVariant *parameters;
1273 GError *error = NULL;
1274 char *passphrase = NULL;
1275 unsigned int len = 0;
1277 parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_passphrase",
1278 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1282 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
1284 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
1285 ret = TETHERING_ERROR_PERMISSION_DENIED;
1287 ret = TETHERING_ERROR_OPERATION_FAILED;
1289 g_error_free(error);
1294 if (parameters != NULL) {
1295 g_variant_get(parameters, "(siu)", &passphrase, &len, &ret);
1296 g_variant_unref(parameters);
1299 g_strlcpy(set->key, passphrase, sizeof(set->key));
1302 INFO("ssid: %s security: %d mode: %s channel: %d visibility: %s\n",
1303 set->ssid, set->sec_type, set->mode, set->channel,
1304 (set->visibility) ? "true" : "false");
1306 return TETHERING_ERROR_NONE;
1309 static bool __check_precondition(tethering_type_e type)
1312 int cellular_state = 0;
1315 /* data network through cellular */
1316 vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &cellular_state);
1317 if (cellular_state == VCONFKEY_NETWORK_CELLULAR_ON) {
1318 INFO("Data Network can be connected later");
1323 /* data network through ethernet */
1324 vconf_get_int(VCONFKEY_NETWORK_STATUS, &dnet_state);
1325 if (dnet_state == VCONFKEY_NETWORK_ETHERNET) {
1326 INFO("Data Network is connected");
1330 vconf_get_int(VCONFKEY_DNET_STATE, &dnet_state);
1331 if (dnet_state > VCONFKEY_DNET_OFF) {
1332 INFO("Data Network is connected");
1335 #endif/*TIZEN_TV_EXT*/
1337 /* data network through wifi */
1338 if (type != TETHERING_TYPE_WIFI) {
1339 vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state);
1340 if (wifi_state > VCONFKEY_WIFI_UNCONNECTED) {
1341 INFO("Wi-Fi is connected!");
1346 ERR("Network is not available!");
1352 * @brief Creates the handle of tethering.
1354 * @privlevel platform
1355 * @privilege http://tizen.org/privilege/tethering.admin
1356 * @remarks The @a tethering must be released tethering_destroy() by you.
1357 * @param[out] tethering A handle of a new mobile ap handle on success
1358 * @return 0 on success, otherwise a negative error value.
1359 * @retval #TETHERING_ERROR_NONE Successful
1360 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1361 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1362 * @retval #TETHERING_ERROR_NOT_SUPPORT_API API is not supported
1363 * @see tethering_destroy()
1365 API int tethering_create(tethering_h *tethering)
1367 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1368 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1369 "parameter(tethering) is NULL\n");
1372 __tethering_h *th = NULL;
1373 GError *error = NULL;
1374 char ssid[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
1376 th = (__tethering_h *)malloc(sizeof(__tethering_h));
1378 _retvm_if(th == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
1379 "malloc is failed\n");
1380 memset(th, 0x00, sizeof(__tethering_h));
1381 th->sec_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK;
1382 th->visibility = true;
1383 th->mac_filter = false;
1385 th->mode_type = TETHERING_WIFI_MODE_TYPE_G;
1386 th->wifi_max_connected = TETHERING_WIFI_MAX_STA;
1387 th->change_mac = false;
1389 if (__generate_initial_passphrase(th->passphrase,
1390 sizeof(th->passphrase)) == 0) {
1391 ERR("random passphrase generation failed\n"); //LCOV_EXCL_LINE
1393 return TETHERING_ERROR_OPERATION_FAILED;
1396 if (__get_common_ssid(ssid, sizeof(ssid)) != TETHERING_ERROR_NONE) {
1397 ERR("common ssid get failed\n"); //LCOV_EXCL_LINE
1399 return TETHERING_ERROR_OPERATION_FAILED;
1402 #if !GLIB_CHECK_VERSION(2, 36, 0)
1405 GCancellable *cancellable = g_cancellable_new();
1406 th->client_bus = g_bus_get_sync(DBUS_BUS_SYSTEM, cancellable, &error);
1409 ERR("Couldn't connect to the System bus[%s]", error->message);
1410 g_error_free(error);
1411 g_cancellable_cancel(cancellable);
1412 g_object_unref(cancellable);
1414 return TETHERING_ERROR_OPERATION_FAILED;
1417 th->cancellable = cancellable;
1419 th->client_bus_proxy = g_dbus_proxy_new_sync(th->client_bus, G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION,
1420 NULL, TETHERING_SERVICE_NAME, TETHERING_SERVICE_OBJECT_PATH,
1421 TETHERING_SERVICE_INTERFACE, th->cancellable, &error);
1422 if (!th->client_bus_proxy) {
1425 ERR("Couldn't create the proxy object because of %s\n", error->message);
1426 g_cancellable_cancel(th->cancellable);
1427 g_object_unref(th->cancellable);
1428 g_object_unref(th->client_bus);
1430 return TETHERING_ERROR_OPERATION_FAILED;
1434 __connect_signals((tethering_h)th);
1436 *tethering = (tethering_h)th;
1437 INFO("Tethering Handle : 0x%X\n", th);
1439 return TETHERING_ERROR_NONE;
1444 * @brief Destroys the handle of tethering.
1446 * @privlevel platform
1447 * @privilege http://tizen.org/privilege/tethering.admin
1448 * @param[in] tethering The handle of tethering
1449 * @return 0 on success, otherwise a negative error value.
1450 * @retval #TETHERING_ERROR_NONE Successful
1451 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1452 * @see tethering_create()
1454 API int tethering_destroy(tethering_h tethering)
1457 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1458 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1459 "parameter(tethering) is NULL\n");
1461 GVariant *result = NULL;
1462 __tethering_h *th = (__tethering_h *)tethering;
1464 INFO("Tethering Handle : 0x%X\n", th);
1466 if (th->change_mac) {
1467 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "reset_mac", NULL,
1468 G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL);
1469 g_variant_unref(result);
1472 __disconnect_signals(tethering);
1477 g_object_unref(th->cancellable);
1478 g_object_unref(th->client_bus_proxy);
1479 g_object_unref(th->client_bus);
1480 memset(th, 0x00, sizeof(__tethering_h));
1484 return TETHERING_ERROR_NONE;
1489 * @brief Enables the tethering, asynchronously.
1491 * @privlevel platform
1492 * @privilege http://tizen.org/privilege/tethering.admin
1493 * @param[in] tethering The handle of tethering
1494 * @param[in] type The type of tethering
1495 * @return 0 on success, otherwise negative error value.
1496 * @retval #TETHERING_ERROR_NONE Successful
1497 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1498 * @post tethering_enabled_cb() will be invoked.
1499 * @see tethering_is_enabled()
1500 * @see tethering_disable()
1502 API int tethering_enable(tethering_h tethering, tethering_type_e type)
1504 INFO("+ type : %d\n", type);
1505 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1506 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1507 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1508 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1510 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1511 "parameter(tethering) is NULL\n");
1513 tethering_error_e ret = TETHERING_ERROR_NONE;
1514 __tethering_h *th = (__tethering_h *)tethering;
1515 GDBusProxy *proxy = th->client_bus_proxy;
1516 GDBusConnection *connection = th->client_bus;
1518 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
1520 if (__check_precondition(type) == FALSE) {
1523 return TETHERING_ERROR_OPERATION_FAILED;
1529 case TETHERING_TYPE_USB:
1530 g_dbus_connection_signal_unsubscribe(connection,
1531 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1533 g_dbus_proxy_call(proxy, "enable_usb_tethering", NULL,
1534 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1535 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1539 case TETHERING_TYPE_WIFI: {
1540 _softap_settings_t set = {"", "", "", 0, false};
1542 ret = __prepare_wifi_settings(tethering, &set);
1543 if (ret != TETHERING_ERROR_NONE) {
1544 ERR("softap settings initialization failed\n");
1546 return TETHERING_ERROR_OPERATION_FAILED;
1548 g_dbus_connection_signal_unsubscribe(connection,
1549 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1551 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1552 g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, TETHERING_ADDRESS_FAMILY_IPV4),
1553 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1554 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1558 case TETHERING_TYPE_BT:
1559 g_dbus_connection_signal_unsubscribe(connection,
1560 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1562 g_dbus_proxy_call(proxy, "enable_bt_tethering", NULL,
1563 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1564 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1569 case TETHERING_TYPE_ALL: {
1570 _softap_settings_t set = {"", "", "", 0, false};
1572 ret = __prepare_wifi_settings(tethering, &set);
1573 if (ret != TETHERING_ERROR_NONE) {
1574 ERR("softap settings initialization failed\n");
1575 return TETHERING_ERROR_OPERATION_FAILED;
1578 /* TETHERING_TYPE_USB */
1579 g_dbus_connection_signal_unsubscribe(connection,
1580 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1582 g_dbus_proxy_call(proxy, "enable_usb_tethering", NULL,
1583 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1584 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1586 /* TETHERING_TYPE_WIFI */
1587 g_dbus_connection_signal_unsubscribe(connection,
1588 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1590 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1591 g_variant_new("(ssii)", set.ssid, set.key, set.visibility, set.sec_type),
1592 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1593 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1595 /* TETHERING_TYPE_BT */
1596 g_dbus_connection_signal_unsubscribe(connection,
1597 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1599 g_dbus_proxy_call(proxy, "enable_usb_tethering", NULL,
1600 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1601 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1606 ERR("Unknown type : %d\n", type);
1608 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1611 return TETHERING_ERROR_INVALID_PARAMETER;
1614 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1616 return TETHERING_ERROR_NONE;
1619 API int tethering_ipv6_enable(tethering_h tethering, tethering_type_e type)
1621 DBG("+ type : %d\n", type);
1622 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1623 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1624 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1625 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1627 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1628 "parameter(tethering) is NULL\n");
1630 __tethering_h *th = (__tethering_h *)tethering;
1631 GDBusProxy *proxy = th->client_bus_proxy;
1632 GDBusConnection *connection = th->client_bus;
1635 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
1637 if (__check_precondition(type) == FALSE) {
1640 return TETHERING_ERROR_OPERATION_FAILED;
1646 case TETHERING_TYPE_WIFI: {
1647 _softap_settings_t set = {"", "", "", 0, false, false, 0, 0};
1649 ret = __prepare_wifi_settings(tethering, &set);
1650 if (ret != TETHERING_ERROR_NONE) {
1651 ERR("softap settings initialization failed\n");
1653 return TETHERING_ERROR_OPERATION_FAILED;
1655 g_dbus_connection_signal_unsubscribe(connection,
1656 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1657 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1658 g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, TETHERING_ADDRESS_FAMILY_IPV6),
1659 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1660 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1663 case TETHERING_TYPE_BT: {
1664 g_dbus_connection_signal_unsubscribe(connection,
1665 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1668 g_dbus_proxy_call(proxy, "enable_bt_tethering", g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1669 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1670 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1676 ERR("Unknown type : %d\n", type);
1678 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1681 return TETHERING_ERROR_INVALID_PARAMETER;
1685 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1687 return TETHERING_ERROR_NONE;
1690 API int tethering_ipv6_disable(tethering_h tethering, tethering_type_e type)
1692 DBG("+ type : %d\n", type);
1693 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1694 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1695 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1696 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1698 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1699 "parameter(tethering) is NULL\n");
1701 __tethering_h *th = (__tethering_h *)tethering;
1702 GDBusProxy *proxy = th->client_bus_proxy;
1703 GDBusConnection *connection = th->client_bus;
1706 case TETHERING_TYPE_WIFI:
1707 DBG("Disable wifi tethering..");
1708 g_dbus_connection_signal_unsubscribe(connection,
1709 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1711 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1712 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1713 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1714 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1716 case TETHERING_TYPE_BT:
1717 g_dbus_connection_signal_unsubscribe(connection,
1718 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1720 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1721 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6), G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1722 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1726 ERR("Not supported tethering type [%d]\n", type);
1728 return TETHERING_ERROR_INVALID_PARAMETER;
1731 return TETHERING_ERROR_NONE;
1735 * @brief Disables the tethering, asynchronously.
1737 * @privlevel platform
1738 * @privilege http://tizen.org/privilege/tethering.admin
1739 * @param[in] tethering The handle of tethering
1740 * @param[in] type The type of tethering
1741 * @return 0 on success, otherwise negative error value.
1742 * @retval #TETHERING_ERROR_NONE Successful
1743 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1744 * @post tethering_disabled_cb() will be invoked.
1745 * @see tethering_is_enabled()
1746 * @see tethering_enable()
1748 API int tethering_disable(tethering_h tethering, tethering_type_e type)
1750 INFO("+ type : %d\n", type);
1751 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1752 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1753 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1754 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1756 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1757 "parameter(tethering) is NULL\n");
1759 __tethering_h *th = (__tethering_h *)tethering;
1760 GDBusProxy *proxy = th->client_bus_proxy;
1761 GDBusConnection *connection = th->client_bus;
1764 case TETHERING_TYPE_USB:
1765 g_dbus_connection_signal_unsubscribe(connection,
1766 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1768 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1769 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1770 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1774 case TETHERING_TYPE_WIFI:
1776 g_dbus_connection_signal_unsubscribe(connection,
1777 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1779 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1780 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1781 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1784 case TETHERING_TYPE_BT:
1786 g_dbus_connection_signal_unsubscribe(connection,
1787 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1789 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1790 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1791 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1794 case TETHERING_TYPE_ALL:
1795 g_dbus_connection_signal_unsubscribe(connection,
1796 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1798 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1799 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1800 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1802 g_dbus_connection_signal_unsubscribe(connection,
1803 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1805 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1806 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1807 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1809 g_dbus_connection_signal_unsubscribe(connection,
1810 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1812 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1813 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1814 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1818 ERR("Not supported tethering type [%d]\n", type);
1820 return TETHERING_ERROR_INVALID_PARAMETER;
1823 return TETHERING_ERROR_NONE;
1828 * @brief Checks whetehr the tethering is enabled or not.
1830 * @privlevel platform
1831 * @privilege http://tizen.org/privilege/tethering.admin
1832 * @param[in] tethering The handle of tethering
1833 * @param[in] type The type of tethering
1834 * @return @c true if tethering is enabled, \n @c false if tethering is disabled.
1836 API bool tethering_is_enabled(tethering_h tethering, tethering_type_e type)
1838 INFO("+ type : %d\n", type);
1840 int vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_NONE;
1842 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1844 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &is_on) != 0)
1848 case TETHERING_TYPE_USB:
1849 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_USB;
1852 case TETHERING_TYPE_WIFI:
1853 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI;
1856 case TETHERING_TYPE_BT:
1857 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_BT;
1861 ERR("Not supported type : %d\n", type);
1864 INFO("- enabled: %s\n", (is_on & vconf_type) ? "true" : "false");
1865 return is_on & vconf_type ? true : false;
1870 * @brief Gets the MAC address of local device as "FC:A1:3E:D6:B1:B1".
1872 * @privlevel platform
1873 * @privilege http://tizen.org/privilege/tethering.admin
1874 * @remarks @a mac_address must be released with free() by you.
1875 * @param[in] tethering The handle of tethering
1876 * @param[in] type The type of tethering
1877 * @param[out] mac_address The MAC address
1878 * @return 0 on success, otherwise a negative error value.
1879 * @retval #TETHERING_ERROR_NONE Successful
1880 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1881 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1882 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
1883 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
1884 * @pre tethering must be enabled.
1885 * @see tethering_is_enabled()
1886 * @see tethering_enable()
1888 API int tethering_get_mac_address(tethering_h tethering, tethering_type_e type, char **mac_address)
1890 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1891 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1892 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1893 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1895 _retvm_if(tethering_is_enabled(tethering, type) == false,
1896 TETHERING_ERROR_NOT_ENABLED,
1897 "tethering type[%d] is not enabled\n", type);
1898 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1899 "parameter(tethering) is NULL\n");
1900 _retvm_if(mac_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1901 "parameter(mac_address) is NULL\n");
1905 char *macbuf = NULL;
1907 _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
1908 TETHERING_ERROR_OPERATION_FAILED,
1909 "getting interface name is failed\n");
1911 s = socket(AF_INET, SOCK_DGRAM, 0);
1912 _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
1913 "getting socket is failed\n");
1914 if (ioctl(s, SIOCGIFHWADDR, &ifr) < 0) {
1915 ERR("getting mac is failed\n");
1917 return TETHERING_ERROR_OPERATION_FAILED;
1921 macbuf = (char *)malloc(TETHERING_STR_INFO_LEN);
1922 _retvm_if(macbuf == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
1923 "Not enough memory\n");
1924 snprintf(macbuf, TETHERING_STR_INFO_LEN, "%02X:%02X:%02X:%02X:%02X:%02X",
1925 (unsigned char)ifr.ifr_hwaddr.sa_data[0],
1926 (unsigned char)ifr.ifr_hwaddr.sa_data[1],
1927 (unsigned char)ifr.ifr_hwaddr.sa_data[2],
1928 (unsigned char)ifr.ifr_hwaddr.sa_data[3],
1929 (unsigned char)ifr.ifr_hwaddr.sa_data[4],
1930 (unsigned char)ifr.ifr_hwaddr.sa_data[5]);
1932 *mac_address = macbuf;
1934 return TETHERING_ERROR_NONE;
1939 * @brief Gets the name of network interface. For example, usb0.
1941 * @privlevel platform
1942 * @privilege http://tizen.org/privilege/tethering.admin
1943 * @remarks @a interface_name must be released with free() by you.
1944 * @param[in] tethering The handle of tethering
1945 * @param[in] type The type of tethering
1946 * @param[out] interface_name The name of network interface
1947 * @return 0 on success, otherwise negative error value.
1948 * @retval #TETHERING_ERROR_NONE Successful
1949 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1950 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1951 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
1952 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
1953 * @pre tethering must be enabled.
1954 * @see tethering_is_enabled()
1955 * @see tethering_enable()
1957 API int tethering_get_network_interface_name(tethering_h tethering, tethering_type_e type, char **interface_name)
1959 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1960 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1961 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1962 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1964 _retvm_if(tethering_is_enabled(tethering, type) == false,
1965 TETHERING_ERROR_NOT_ENABLED,
1966 "tethering type[%d] is not enabled\n", type);
1967 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1968 "parameter(tethering) is NULL\n");
1969 _retvm_if(interface_name == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1970 "parameter(interface_name) is NULL\n");
1972 char intf[TETHERING_STR_INFO_LEN] = {0, };
1974 _retvm_if(!__get_intf_name(type, intf, sizeof(intf)),
1975 TETHERING_ERROR_OPERATION_FAILED,
1976 "getting interface name is failed\n");
1977 *interface_name = strdup(intf);
1978 _retvm_if(*interface_name == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
1979 "Not enough memory\n");
1981 return TETHERING_ERROR_NONE;
1986 * @brief Gets the local IP address.
1988 * @privlevel platform
1989 * @privilege http://tizen.org/privilege/tethering.admin
1990 * @remarks @a ip_address must be released with free() by you.
1991 * @param[in] tethering The handle of tethering
1992 * @param[in] type The type of tethering
1993 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
1994 * @param[out] ip_address The local IP address
1995 * @return 0 on success, otherwise negative error value.
1996 * @retval #TETHERING_ERROR_NONE Successful
1997 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1998 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1999 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2000 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2001 * @pre tethering must be enabled.
2002 * @see tethering_is_enabled()
2003 * @see tethering_enable()
2005 API int tethering_get_ip_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **ip_address)
2007 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2008 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2009 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2010 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2012 _retvm_if(tethering_is_enabled(tethering, type) == false,
2013 TETHERING_ERROR_NOT_ENABLED,
2014 "tethering type[%d] is not enabled\n", type);
2015 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2016 "parameter(tethering) is NULL\n");
2017 _retvm_if(ip_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2018 "parameter(ip_address) is NULL\n");
2024 _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
2025 TETHERING_ERROR_OPERATION_FAILED,
2026 "getting interface name is failed\n");
2028 s = socket(AF_INET, SOCK_DGRAM, 0);
2029 _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
2030 "getting socket is failed\n");
2031 if (ioctl(s, SIOCGIFADDR, &ifr) < 0) {
2032 ERR("ioctl is failed\n");
2034 return TETHERING_ERROR_OPERATION_FAILED;
2038 ipbuf = inet_ntoa(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr);
2039 *ip_address = strdup(ipbuf);
2040 _retvm_if(*ip_address == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2041 "Not enough memory\n");
2043 return TETHERING_ERROR_NONE;
2048 * @brief Gets the Gateway address.
2050 * @privlevel platform
2051 * @privilege http://tizen.org/privilege/tethering.admin
2052 * @remarks @a gateway_address must be released with free() by you.
2053 * @param[in] tethering The handle of tethering
2054 * @param[in] type The type of tethering
2055 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2056 * @param[out] gateway_address The local IP address
2057 * @return 0 on success, otherwise negative error value.
2058 * @retval #TETHERING_ERROR_NONE Successful
2059 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2060 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2061 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2062 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2063 * @pre tethering must be enabled.
2064 * @see tethering_is_enabled()
2065 * @see tethering_enable()
2067 API int tethering_get_gateway_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **gateway_address)
2069 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2070 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2071 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2072 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2074 _retvm_if(tethering_is_enabled(tethering, type) == false,
2075 TETHERING_ERROR_NOT_ENABLED,
2076 "tethering type[%d] is not enabled\n", type);
2077 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2078 "parameter(tethering) is NULL\n");
2079 _retvm_if(gateway_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2080 "parameter(gateway_address) is NULL\n");
2082 char gateway_buf[TETHERING_STR_INFO_LEN] = {0, };
2084 _retvm_if(!__get_gateway_addr(type, gateway_buf, sizeof(gateway_buf)),
2085 TETHERING_ERROR_OPERATION_FAILED,
2086 "getting gateway address is failed\n");
2088 *gateway_address = strdup(gateway_buf);
2090 return TETHERING_ERROR_NONE;
2095 * @brief Gets the Subnet Mask.
2097 * @privlevel platform
2098 * @privilege http://tizen.org/privilege/tethering.admin
2099 * @remarks @a subnet_mask must be released with free() by you.
2100 * @param[in] tethering The handle of tethering
2101 * @param[in] type The type of tethering
2102 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2103 * @param[out] subnet_mask The local IP address
2104 * @return 0 on success, otherwise negative error value.
2105 * @retval #TETHERING_ERROR_NONE Successful
2106 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2107 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2108 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2109 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2110 * @pre tethering must be enabled.
2111 * @see tethering_is_enabled()
2112 * @see tethering_enable()
2114 API int tethering_get_subnet_mask(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **subnet_mask)
2116 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2117 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2118 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2119 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2121 _retvm_if(tethering_is_enabled(tethering, type) == false,
2122 TETHERING_ERROR_NOT_ENABLED,
2123 "tethering is not enabled\n");
2124 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2125 "parameter(tethering) is NULL\n");
2126 _retvm_if(subnet_mask == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2127 "parameter(subnet_mask) is NULL\n");
2129 *subnet_mask = strdup(TETHERING_SUBNET_MASK);
2130 _retvm_if(*subnet_mask == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2131 "Not enough memory\n");
2133 return TETHERING_ERROR_NONE;
2138 * @brief Gets the data usage.
2140 * @privlevel platform
2141 * @privilege http://tizen.org/privilege/tethering.admin
2142 * @param[in] tethering The handle of tethering
2143 * @param[out] usage The data usage
2144 * @return 0 on success, otherwise negative error value.
2145 * @retval #TETHERING_ERROR_NONE Successful
2146 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2147 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2148 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2149 * @pre tethering must be enabled.
2150 * @see tethering_is_enabled()
2151 * @see tethering_enable()
2153 API int tethering_get_data_usage(tethering_h tethering, tethering_data_usage_cb callback, void *user_data)
2155 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2157 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2158 "parameter(tethering) is NULL\n");
2159 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2160 "parameter(callback) is NULL\n");
2161 _retvm_if(__any_tethering_is_enabled(tethering) == false,
2162 TETHERING_ERROR_NOT_ENABLED,
2163 "tethering is not enabled\n");
2165 __tethering_h *th = (__tethering_h *)tethering;
2166 GDBusProxy *proxy = th->client_bus_proxy;
2168 th->data_usage_cb = callback;
2169 th->data_usage_user_data = user_data;
2171 g_dbus_proxy_call(proxy, "get_data_packet_usage",
2172 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2173 (GAsyncReadyCallback) __get_data_usage_cb, (gpointer)tethering);
2175 return TETHERING_ERROR_NONE;
2180 * @brief Gets the client which is connected by tethering "type".
2182 * @privlevel platform
2183 * @privilege http://tizen.org/privilege/tethering.admin
2184 * @param[in] tethering The handle of tethering
2185 * @param[in] type The type of tethering
2186 * @param[in] callback The callback function to invoke
2187 * @param[in] user_data The user data to be passed to the callback function
2188 * @retval #TETHERING_ERROR_NONE Successful
2189 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2190 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2191 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2192 * @pre tethering must be enabled.
2193 * @see tethering_is_enabled()
2194 * @see tethering_enable()
2196 API int tethering_foreach_connected_clients(tethering_h tethering, tethering_type_e type, tethering_connected_client_cb callback, void *user_data)
2198 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2199 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2200 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2201 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2203 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2204 "parameter(tethering) is NULL\n");
2205 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2206 "parameter(callback) is NULL\n");
2207 _retvm_if(__any_tethering_is_enabled(tethering) == false,
2208 TETHERING_ERROR_NOT_ENABLED,
2209 "tethering is not enabled\n");
2211 mobile_ap_type_e interface;
2212 __tethering_h *th = (__tethering_h *)tethering;
2213 __tethering_client_h client = {0, };
2216 gchar *hostname = NULL;
2217 guint timestamp = 0;
2218 GError *error = NULL;
2219 GVariant *result = NULL;
2220 GVariantIter *outer_iter = NULL;
2221 GVariantIter *inner_iter = NULL;
2222 GVariant *station = NULL;
2223 GVariant *value = NULL;
2226 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "get_station_info",
2227 NULL, G_DBUS_CALL_FLAGS_NONE,
2228 -1, th->cancellable, &error);
2230 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
2231 g_variant_get(result, "(a(a{sv}))", &outer_iter);
2232 while (g_variant_iter_loop(outer_iter, "(@a{sv})", &station)) {
2233 g_variant_get(station, "a{sv}", &inner_iter);
2234 while (g_variant_iter_loop(inner_iter, "{sv}", &key, &value)) {
2235 if (g_strcmp0(key, "Type") == 0) {
2236 interface = g_variant_get_int32(value);
2237 if (interface == MOBILE_AP_TYPE_USB)
2238 client.interface = TETHERING_TYPE_USB;
2239 else if (interface == MOBILE_AP_TYPE_WIFI)
2240 client.interface = TETHERING_TYPE_WIFI;
2241 else if (interface == MOBILE_AP_TYPE_BT)
2242 client.interface = TETHERING_TYPE_BT;
2244 ERR("Invalid interface\n");
2246 g_variant_unref(value);
2249 DBG("interface is %d\n", client.interface);
2250 if (client.interface != type && (TETHERING_TYPE_ALL != type)) {
2252 g_variant_unref(value);
2255 } else if (g_strcmp0(key, "IP") == 0) {
2256 g_variant_get(value, "s", &ip);
2257 SDBG("ip is %s\n", ip);
2258 g_strlcpy(client.ip, ip, sizeof(client.ip));
2259 } else if (g_strcmp0(key, "MAC") == 0) {
2260 g_variant_get(value, "s", &mac);
2261 SDBG("mac is %s\n", mac);
2262 g_strlcpy(client.mac, mac, sizeof(client.mac));
2263 } else if (g_strcmp0(key, "Name") == 0) {
2264 g_variant_get(value, "s", &hostname);
2265 SDBG("hsotname is %s\n", hostname);
2267 client.hostname = g_strdup(hostname);
2268 } else if (g_strcmp0(key, "Time") == 0) {
2269 timestamp = g_variant_get_int32(value);
2270 DBG("timestamp is %d\n", timestamp);
2271 client.tm = (time_t)timestamp;
2273 ERR("Key %s not required\n", key);
2279 g_variant_iter_free(inner_iter);
2280 if (callback((tethering_client_h)&client, user_data) == false) {
2281 DBG("iteration is stopped\n");
2282 g_free(client.hostname);
2283 g_variant_iter_free(outer_iter);
2284 g_variant_unref(station);
2285 g_variant_unref(result);
2287 return TETHERING_ERROR_OPERATION_FAILED;
2289 g_free(client.hostname);
2291 g_variant_iter_free(outer_iter);
2292 g_variant_unref(station);
2293 g_variant_unref(result);
2295 return TETHERING_ERROR_NONE;
2300 * @brief Registers the callback function called when tethering is enabled.
2302 * @privlevel platform
2303 * @privilege http://tizen.org/privilege/tethering.admin
2304 * @param[in] tethering The handle of tethering
2305 * @param[in] type The type of tethering
2306 * @param[in] callback The callback function to invoke
2307 * @param[in] user_data The user data to be passed to the callback function
2308 * @retval #TETHERING_ERROR_NONE Successful
2309 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2310 * @see tethering_unset_enabled_cb()
2312 API int tethering_set_enabled_cb(tethering_h tethering, tethering_type_e type, tethering_enabled_cb callback, void *user_data)
2314 INFO("+ type: %d\n", type);
2315 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2316 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2317 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2318 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2320 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2321 "parameter(tethering) is NULL\n");
2322 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2323 "parameter(callback) is NULL\n");
2325 __tethering_h *th = (__tethering_h *)tethering;
2326 tethering_type_e ti;
2328 if (type != TETHERING_TYPE_ALL) {
2329 th->enabled_cb[type] = callback;
2330 th->enabled_user_data[type] = user_data;
2332 return TETHERING_ERROR_NONE;
2335 /* TETHERING_TYPE_ALL */
2336 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2337 th->enabled_cb[ti] = callback;
2338 th->enabled_user_data[ti] = user_data;
2342 return TETHERING_ERROR_NONE;
2347 * @brief Unregisters the callback function called when tethering is disabled.
2349 * @privlevel platform
2350 * @privilege http://tizen.org/privilege/tethering.admin
2351 * @param[in] tethering The handle of tethering
2352 * @param[in] type The type of tethering
2353 * @retval #TETHERING_ERROR_NONE Successful
2354 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2355 * @see tethering_set_enabled_cb()
2357 API int tethering_unset_enabled_cb(tethering_h tethering, tethering_type_e type)
2359 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2360 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2361 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2362 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2364 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2365 "parameter(tethering) is NULL\n");
2367 __tethering_h *th = (__tethering_h *)tethering;
2368 tethering_type_e ti;
2370 if (type != TETHERING_TYPE_ALL) {
2371 th->enabled_cb[type] = NULL;
2372 th->enabled_user_data[type] = NULL;
2374 return TETHERING_ERROR_NONE;
2377 /* TETHERING_TYPE_ALL */
2378 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2379 th->enabled_cb[ti] = NULL;
2380 th->enabled_user_data[ti] = NULL;
2383 return TETHERING_ERROR_NONE;
2388 * @brief Registers the callback function called when tethering is disabled.
2390 * @privlevel platform
2391 * @privilege http://tizen.org/privilege/tethering.admin
2392 * @param[in] tethering The handle of tethering
2393 * @param[in] type The type of tethering
2394 * @param[in] callback The callback function to invoke
2395 * @param[in] user_data The user data to be passed to the callback function
2396 * @retval #TETHERING_ERROR_NONE Successful
2397 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2398 * @see tethering_unset_disabled_cb()
2400 API int tethering_set_disabled_cb(tethering_h tethering, tethering_type_e type, tethering_disabled_cb callback, void *user_data)
2402 INFO("+ type: %d\n", type);
2403 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2404 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2405 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2406 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2408 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2409 "parameter(tethering) is NULL\n");
2410 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2411 "parameter(callback) is NULL\n");
2413 __tethering_h *th = (__tethering_h *)tethering;
2414 tethering_type_e ti;
2416 if (type != TETHERING_TYPE_ALL) {
2417 th->disabled_cb[type] = callback;
2418 th->disabled_user_data[type] = user_data;
2420 return TETHERING_ERROR_NONE;
2423 /* TETHERING_TYPE_ALL */
2424 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2425 th->disabled_cb[ti] = callback;
2426 th->disabled_user_data[ti] = user_data;
2429 return TETHERING_ERROR_NONE;
2434 * @brief Unregisters the callback function called when tethering is disabled.
2436 * @privlevel platform
2437 * @privilege http://tizen.org/privilege/tethering.admin
2438 * @param[in] tethering The handle of tethering
2439 * @param[in] type The type of tethering
2440 * @retval #TETHERING_ERROR_NONE Successful
2441 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2442 * @see tethering_set_disabled_cb()
2444 API int tethering_unset_disabled_cb(tethering_h tethering, tethering_type_e type)
2446 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2447 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2448 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2449 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2451 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2452 "parameter(tethering) is NULL\n");
2454 __tethering_h *th = (__tethering_h *)tethering;
2455 tethering_type_e ti;
2457 if (type != TETHERING_TYPE_ALL) {
2458 th->disabled_cb[type] = NULL;
2459 th->disabled_user_data[type] = NULL;
2461 return TETHERING_ERROR_NONE;
2464 /* TETHERING_TYPE_ALL */
2465 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2466 th->disabled_cb[ti] = NULL;
2467 th->disabled_user_data[ti] = NULL;
2470 return TETHERING_ERROR_NONE;
2475 * @brief Registers the callback function called when the state of connection is changed.
2477 * @privlevel platform
2478 * @privilege http://tizen.org/privilege/tethering.admin
2479 * @param[in] tethering The handle of tethering
2480 * @param[in] type The type of tethering
2481 * @param[in] callback The callback function to invoke
2482 * @param[in] user_data The user data to be passed to the callback function
2483 * @retval #TETHERING_ERROR_NONE Successful
2484 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2485 * @see tethering_unset_connection_state_changed_cb_cb()
2487 API int tethering_set_connection_state_changed_cb(tethering_h tethering, tethering_type_e type, tethering_connection_state_changed_cb callback, void *user_data)
2489 INFO("+ type: %d\n", type);
2490 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2491 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2492 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2493 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2495 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2496 "parameter(tethering) is NULL\n");
2497 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2498 "parameter(callback) is NULL\n");
2500 __tethering_h *th = (__tethering_h *)tethering;
2501 tethering_type_e ti;
2503 if (type != TETHERING_TYPE_ALL) {
2504 th->changed_cb[type] = callback;
2505 th->changed_user_data[type] = user_data;
2507 return TETHERING_ERROR_NONE;
2510 /* TETHERING_TYPE_ALL */
2511 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2512 th->changed_cb[ti] = callback;
2513 th->changed_user_data[ti] = user_data;
2516 return TETHERING_ERROR_NONE;
2521 * @brief Unregisters the callback function called when the state of connection is changed.
2523 * @privlevel platform
2524 * @privilege http://tizen.org/privilege/tethering.admin
2525 * @param[in] tethering The handle of tethering
2526 * @param[in] type The type of tethering
2527 * @retval #TETHERING_ERROR_NONE Successful
2528 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2529 * @see tethering_set_connection_state_changed_cb()
2531 API int tethering_unset_connection_state_changed_cb(tethering_h tethering, tethering_type_e type)
2533 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2534 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2535 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2536 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2538 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2539 "parameter(tethering) is NULL\n");
2541 __tethering_h *th = (__tethering_h *)tethering;
2542 tethering_type_e ti;
2544 if (type != TETHERING_TYPE_ALL) {
2545 th->changed_cb[type] = NULL;
2546 th->changed_user_data[type] = NULL;
2548 return TETHERING_ERROR_NONE;
2551 /* TETHERING_TYPE_ALL */
2552 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2553 th->changed_cb[ti] = NULL;
2554 th->changed_user_data[ti] = NULL;
2557 return TETHERING_ERROR_NONE;
2562 * @brief Registers the callback function called when the security type of Wi-Fi tethering is changed.
2564 * @privlevel platform
2565 * @privilege http://tizen.org/privilege/tethering.admin
2566 * @param[in] tethering The handle of tethering
2567 * @param[in] callback The callback function to invoke
2568 * @param[in] user_data The user data to be passed to the callback function
2569 * @retval #TETHERING_ERROR_NONE Successful
2570 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2571 * @see tethering_wifi_unset_security_type_changed_cb()
2573 API int tethering_wifi_set_security_type_changed_cb(tethering_h tethering, tethering_wifi_security_type_changed_cb callback, void *user_data)
2575 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2576 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2578 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2579 "parameter(tethering) is NULL\n");
2580 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2581 "parameter(callback) is NULL\n");
2583 __tethering_h *th = (__tethering_h *)tethering;
2585 th->security_type_changed_cb = callback;
2586 th->security_type_user_data = user_data;
2588 return TETHERING_ERROR_NONE;
2594 * @brief Unregisters the callback function called when the security type of Wi-Fi tethering is changed.
2596 * @privlevel platform
2597 * @privilege http://tizen.org/privilege/tethering.admin
2598 * @param[in] tethering The handle of tethering
2599 * @param[in] type The type of tethering
2600 * @retval #TETHERING_ERROR_NONE Successful
2601 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2602 * @see tethering_wifi_set_security_type_changed_cb()
2604 API int tethering_wifi_unset_security_type_changed_cb(tethering_h tethering)
2606 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2607 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2609 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2610 "parameter(tethering) is NULL\n");
2612 __tethering_h *th = (__tethering_h *)tethering;
2614 th->security_type_changed_cb = NULL;
2615 th->security_type_user_data = NULL;
2617 return TETHERING_ERROR_NONE;
2622 * @brief Registers the callback function called when the visibility of SSID is changed.
2624 * @privlevel platform
2625 * @privilege http://tizen.org/privilege/tethering.admin
2626 * @param[in] tethering The handle of tethering
2627 * @param[in] callback The callback function to invoke
2628 * @param[in] user_data The user data to be passed to the callback function
2629 * @retval #TETHERING_ERROR_NONE Successful
2630 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2631 * @see tethering_wifi_unset_ssid_visibility_changed_cb_cb()
2633 API int tethering_wifi_set_ssid_visibility_changed_cb(tethering_h tethering, tethering_wifi_ssid_visibility_changed_cb callback, void *user_data)
2635 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2636 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2638 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2639 "parameter(tethering) is NULL\n");
2640 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2641 "parameter(callback) is NULL\n");
2643 __tethering_h *th = (__tethering_h *)tethering;
2645 th->ssid_visibility_changed_cb = callback;
2646 th->ssid_visibility_user_data = user_data;
2648 return TETHERING_ERROR_NONE;
2653 * @brief Unregisters the callback function called when the visibility of SSID is changed.
2655 * @privlevel platform
2656 * @privilege http://tizen.org/privilege/tethering.admin
2657 * @param[in] tethering The handle of tethering
2658 * @retval #TETHERING_ERROR_NONE Successful
2659 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2660 * @see tethering_wifi_set_ssid_visibility_changed_cb()
2662 API int tethering_wifi_unset_ssid_visibility_changed_cb(tethering_h tethering)
2664 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2665 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2667 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2668 "parameter(tethering) is NULL\n");
2670 __tethering_h *th = (__tethering_h *)tethering;
2672 th->ssid_visibility_changed_cb = NULL;
2673 th->ssid_visibility_user_data = NULL;
2675 return TETHERING_ERROR_NONE;
2680 * @brief Registers the callback function called when the passphrase of Wi-Fi tethering is changed.
2682 * @privlevel platform
2683 * @privilege http://tizen.org/privilege/tethering.admin
2684 * @param[in] tethering The handle of tethering
2685 * @param[in] callback The callback function to invoke
2686 * @param[in] user_data The user data to be passed to the callback function
2687 * @retval #TETHERING_ERROR_NONE Successful
2688 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2689 * @see tethering_wifi_unset_passphrase_changed_cb()
2691 API int tethering_wifi_set_passphrase_changed_cb(tethering_h tethering, tethering_wifi_passphrase_changed_cb callback, void *user_data)
2693 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2694 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2696 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2697 "parameter(tethering) is NULL\n");
2698 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2699 "parameter(callback) is NULL\n");
2701 __tethering_h *th = (__tethering_h *)tethering;
2703 th->passphrase_changed_cb = callback;
2704 th->passphrase_user_data = user_data;
2706 return TETHERING_ERROR_NONE;
2711 * @brief Unregisters the callback function called when the passphrase of Wi-Fi tethering is changed.
2713 * @privlevel platform
2714 * @privilege http://tizen.org/privilege/tethering.admin
2715 * @param[in] tethering The handle of tethering
2716 * @retval #TETHERING_ERROR_NONE Successful
2717 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2718 * @see tethering_wifi_set_passphrase_changed_cb()
2720 API int tethering_wifi_unset_passphrase_changed_cb(tethering_h tethering)
2722 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2723 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2725 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2726 "parameter(tethering) is NULL\n");
2728 __tethering_h *th = (__tethering_h *)tethering;
2730 th->passphrase_changed_cb = NULL;
2731 th->passphrase_user_data = NULL;
2733 return TETHERING_ERROR_NONE;
2738 * @brief Sets the security type of Wi-Fi tethering.
2740 * @privlevel platform
2741 * @privilege http://tizen.org/privilege/tethering.admin
2742 * @remarks This change is applied next time Wi-Fi tethering is enabled
2743 * @param[in] tethering The handle of tethering
2744 * @param[in] type The security type
2745 * @return 0 on success, otherwise negative error value.
2746 * @retval #TETHERING_ERROR_NONE Successful
2747 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2748 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2749 * @see tethering_wifi_get_security_type()
2751 API int tethering_wifi_set_security_type(tethering_h tethering, tethering_wifi_security_type_e type)
2753 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2754 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2756 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2757 "parameter(tethering) is NULL\n");
2759 __tethering_h *th = (__tethering_h *)tethering;
2760 tethering_error_e ret = TETHERING_ERROR_NONE;
2761 char *sec_str = NULL;
2763 ret = __set_security_type(type);
2764 if (ret == TETHERING_ERROR_NONE) {
2767 case TETHERING_WIFI_SECURITY_TYPE_NONE:
2768 sec_str = TETHERING_WIFI_SECURITY_TYPE_OPEN_STR;
2770 case TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK:
2771 sec_str = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR;
2773 case TETHERING_WIFI_SECURITY_TYPE_WPS:
2774 sec_str = TETHERING_WIFI_SECURITY_TYPE_WPS_STR;
2778 __send_dbus_signal(th->client_bus,
2779 SIGNAL_NAME_SECURITY_TYPE_CHANGED, sec_str);
2786 * @brief Gets the security type of Wi-Fi tethering.
2788 * @privlevel platform
2789 * @privilege http://tizen.org/privilege/tethering.admin
2790 * @param[in] tethering The handle of tethering
2791 * @param[out] type The security type
2792 * @return 0 on success, otherwise negative error value.
2793 * @retval #TETHERING_ERROR_NONE Successful
2794 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2795 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2796 * @see tethering_wifi_set_security_type()
2798 API int tethering_wifi_get_security_type(tethering_h tethering, tethering_wifi_security_type_e *type)
2800 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2801 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2803 _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2804 "parameter(type) is NULL\n");
2806 return __get_security_type(type);
2811 * @brief Sets the SSID (service set identifier).
2813 * @privlevel platform
2814 * @privilege http://tizen.org/privilege/tethering.admin
2815 * @details If SSID is not set, Device name is used as SSID
2816 * @remarks This change is applied next time Wi-Fi tethering is enabled with same @a tethering handle
2817 * @param[in] tethering The handle of tethering
2818 * @param[out] ssid The SSID
2819 * @return 0 on success, otherwise negative error value.
2820 * @retval #TETHERING_ERROR_NONE Successful
2821 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2822 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2824 API int tethering_wifi_set_ssid(tethering_h tethering, const char *ssid)
2826 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2827 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2829 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2830 "parameter(tethering) is NULL\n");
2831 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2832 "parameter(ssid) is NULL\n");
2834 __tethering_h *th = (__tethering_h *)tethering;
2835 char *p_ssid = NULL;
2838 ssid_len = strlen(ssid);
2839 if (ssid_len > TETHERING_WIFI_SSID_MAX_LEN) {
2840 ERR("parameter(ssid) is too long");
2841 return TETHERING_ERROR_INVALID_PARAMETER;
2844 p_ssid = strdup(ssid);
2845 _retvm_if(p_ssid == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2846 "strdup is failed\n");
2852 return TETHERING_ERROR_NONE;
2857 * @brief Gets the SSID (service set identifier).
2859 * @privlevel platform
2860 * @privilege http://tizen.org/privilege/tethering.admin
2861 * @remarks @a ssid must be released with free() by you.
2862 * @param[in] tethering The handle of tethering
2863 * @param[out] ssid The SSID
2864 * @return 0 on success, otherwise negative error value.
2865 * @retval #TETHERING_ERROR_NONE Successful
2866 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2867 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2868 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2870 API int tethering_wifi_get_ssid(tethering_h tethering, char **ssid)
2872 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2873 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2875 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2876 "parameter(tethering) is NULL\n");
2877 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2878 "parameter(ssid) is NULL\n");
2881 __tethering_h *th = (__tethering_h *)tethering;
2882 char val[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
2884 if (!tethering_is_enabled(NULL, TETHERING_TYPE_WIFI)) {
2885 if (th->ssid != NULL) {
2886 DBG("Private SSID is set\n");
2887 *ssid = strdup(th->ssid);
2889 if (__get_ssid_from_vconf(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
2890 val, sizeof(val)) == false) {
2891 return TETHERING_ERROR_OPERATION_FAILED;
2893 *ssid = strdup(val);
2896 if (__get_ssid_from_vconf(VCONFKEY_MOBILE_HOTSPOT_SSID,
2897 val, sizeof(val)) == false) {
2898 return TETHERING_ERROR_OPERATION_FAILED;
2900 *ssid = strdup(val);
2903 if (*ssid == NULL) {
2904 ERR("strdup is failed\n");
2905 return TETHERING_ERROR_OUT_OF_MEMORY;
2908 return TETHERING_ERROR_NONE;
2913 * @brief Sets the visibility of SSID(service set identifier).
2915 * @privlevel platform
2916 * @privilege http://tizen.org/privilege/tethering.admin
2917 * @details If you set the visibility invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
2918 * @remarks This change is applied next time Wi-Fi tethering is enabled
2919 * @param[in] tethering The handle of tethering
2920 * @param[in] visible The visibility of SSID: (@c true = visible, @c false = invisible)
2921 * @return 0 on success, otherwise negative error value.
2922 * @retval #TETHERING_ERROR_NONE Successful
2923 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2924 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2925 * @see tethering_wifi_get_ssid_visibility()
2927 API int tethering_wifi_set_ssid_visibility(tethering_h tethering, bool visible)
2929 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2930 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2932 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2933 "parameter(tethering) is NULL\n");
2935 __tethering_h *th = (__tethering_h *)tethering;
2936 tethering_error_e ret = TETHERING_ERROR_NONE;
2938 ret = __set_visible(visible);
2939 if (ret == TETHERING_ERROR_NONE) {
2941 __send_dbus_signal(th->client_bus,
2942 SIGNAL_NAME_SSID_VISIBILITY_CHANGED,
2943 visible ? SIGNAL_MSG_SSID_VISIBLE :
2944 SIGNAL_MSG_SSID_HIDE);
2951 * @brief Gets the visibility of SSID(service set identifier).
2953 * @privlevel platform
2954 * @privilege http://tizen.org/privilege/tethering.admin
2955 * @details If the visibility is set invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
2956 * @param[in] tethering The handle of tethering
2957 * @param[out] visible The visibility of SSID: (@c true = visible, @c false = invisible)
2958 * @return 0 on success, otherwise negative error value.
2959 * @retval #TETHERING_ERROR_NONE Successful
2960 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2961 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2962 * @see tethering_wifi_set_ssid_visibility()
2964 API int tethering_wifi_get_ssid_visibility(tethering_h tethering, bool *visible)
2966 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2967 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2969 _retvm_if(visible == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2970 "parameter(visible) is NULL\n");
2972 return __get_visible(visible);
2977 * @brief Sets the passphrase.
2979 * @privlevel platform
2980 * @privilege http://tizen.org/privilege/tethering.admin
2981 * @remarks This change is applied next time Wi-Fi tethering is enabled
2982 * @param[in] tethering The handle of tethering
2983 * @param[in] passphrase The passphrase
2984 * @return 0 on success, otherwise negative error value.
2985 * @retval #TETHERING_ERROR_NONE Successful
2986 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2987 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2988 * @see tethering_wifi_get_passphrase()
2990 API int tethering_wifi_set_passphrase(tethering_h tethering, const char *passphrase)
2992 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2993 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2995 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2996 "parameter(tethering) is NULL\n");
2997 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2998 "parameter(passphrase) is NULL\n");
3000 __tethering_h *th = (__tethering_h *)tethering;
3001 GDBusProxy *proxy = th->client_bus_proxy;
3002 GVariant *parameters;
3003 GError *error = NULL;
3004 int passphrase_len = 0;
3008 passphrase_len = strlen(passphrase);
3009 if (passphrase_len < TETHERING_WIFI_KEY_MIN_LEN ||
3010 passphrase_len > TETHERING_WIFI_KEY_MAX_LEN) {
3011 ERR("parameter(passphrase) is too short or long\n");
3012 return TETHERING_ERROR_INVALID_PARAMETER;
3015 parameters = g_dbus_proxy_call_sync(proxy, "set_wifi_tethering_passphrase",
3016 g_variant_new("(s)", passphrase), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3020 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3022 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3023 ret = TETHERING_ERROR_PERMISSION_DENIED;
3025 ret = TETHERING_ERROR_OPERATION_FAILED;
3027 g_error_free(error);
3032 g_variant_get(parameters, "(u)", &ret);
3033 g_variant_unref(parameters);
3035 if (ret == TETHERING_ERROR_NONE) {
3036 __send_dbus_signal(th->client_bus,
3037 SIGNAL_NAME_PASSPHRASE_CHANGED, NULL);
3046 * @brief Gets the passphrase.
3048 * @privlevel platform
3049 * @privilege http://tizen.org/privilege/tethering.admin
3050 * @remarks @a passphrase must be released with free() by you.
3051 * @param[in] tethering The handle of tethering
3052 * @param[out] passphrase The passphrase
3053 * @return 0 on success, otherwise negative error value.
3054 * @retval #TETHERING_ERROR_NONE Successful
3055 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3056 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
3057 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3058 * @see tethering_wifi_set_passphrase()
3060 API int tethering_wifi_get_passphrase(tethering_h tethering, char **passphrase)
3062 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3063 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3065 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3066 "parameter(tethering) is NULL\n");
3067 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3068 "parameter(passphrase) is NULL\n");
3070 __tethering_h *th = (__tethering_h *)tethering;
3071 GDBusProxy *proxy = th->client_bus_proxy;
3072 GVariant *parameters;
3073 GError *error = NULL;
3074 unsigned int len = 0;
3075 tethering_error_e ret = TETHERING_ERROR_NONE;
3077 parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_passphrase",
3078 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3082 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3084 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3085 ret = TETHERING_ERROR_PERMISSION_DENIED;
3087 ret = TETHERING_ERROR_OPERATION_FAILED;
3089 g_error_free(error);
3094 if (parameters != NULL) {
3095 g_variant_get(parameters, "(siu)", passphrase, &len, &ret);
3096 g_variant_unref(parameters);
3099 return TETHERING_ERROR_NONE;
3102 API int tethering_wifi_set_channel(tethering_h tethering, int channel)
3104 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3105 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3107 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3108 "parameter(tethering) is NULL\n");
3110 __tethering_h *th = (__tethering_h *)tethering;
3111 th->channel = channel;
3113 return TETHERING_ERROR_NONE;
3116 API int tethering_wifi_get_channel(tethering_h tethering, int *channel)
3118 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3119 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3121 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3122 "parameter(tethering) is NULL\n");
3124 _retvm_if(channel == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3125 "parameter(channel) is NULL\n");
3127 __tethering_h *th = (__tethering_h *)tethering;
3128 *channel = th->channel;
3130 return TETHERING_ERROR_NONE;
3133 API int tethering_wifi_set_mode(tethering_h tethering, tethering_wifi_mode_type_e type)
3135 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3136 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3138 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3139 "parameter(tethering) is NULL\n");
3141 __tethering_h *th = (__tethering_h *)tethering;
3143 th->mode_type = type;
3145 return TETHERING_ERROR_NONE;
3148 API int tethering_wifi_get_mode(tethering_h tethering, tethering_wifi_mode_type_e *type)
3150 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3151 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3153 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3154 "parameter(tethering) is NULL\n");
3155 _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3156 "parameter(type) is NULL\n");
3158 __tethering_h *th = (__tethering_h *)tethering;
3159 *type = th->mode_type;
3161 return TETHERING_ERROR_NONE;
3167 * @brief Reload the settings (SSID / Passphrase / Security type / SSID visibility).
3169 * @privlevel platform
3170 * @privilege http://tizen.org/privilege/tethering.admin
3171 * @remarks Connected devices via Wi-Fi tethering or MobileAP will be disconnected when the settings are reloaded
3172 * @param[in] tethering The handle of tethering
3173 * @param[in] callback The callback function to invoke
3174 * @param[in] user_data The user data to be passed to the callback function
3175 * @return 0 on success, otherwise negative error value.
3176 * @retval #TETHERING_ERROR_NONE Successful
3177 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3178 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3180 API int tethering_wifi_reload_settings(tethering_h tethering, tethering_wifi_settings_reloaded_cb callback, void *user_data)
3183 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3184 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3186 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3187 "parameter(tethering) is NULL\n");
3188 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3189 "parameter(callback) is NULL\n");
3191 __tethering_h *th = (__tethering_h *)tethering;
3192 _softap_settings_t set = {"", "", "", 0, false};
3193 GDBusProxy *proxy = th->client_bus_proxy;
3198 if (th->settings_reloaded_cb) {
3199 ERR("Operation in progress\n");
3200 return TETHERING_ERROR_OPERATION_FAILED;
3203 ret = __prepare_wifi_settings(tethering, &set);
3204 if (ret != TETHERING_ERROR_NONE) {
3205 ERR("softap settings initialization failed\n");
3206 return TETHERING_ERROR_OPERATION_FAILED;
3209 th->settings_reloaded_cb = callback;
3210 th->settings_reloaded_user_data = user_data;
3212 g_dbus_proxy_call(proxy, "reload_wifi_settings",
3213 g_variant_new("(sssiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type),
3214 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
3215 (GAsyncReadyCallback) __settings_reloaded_cb, (gpointer)tethering);
3217 return TETHERING_ERROR_NONE;
3220 API int tethering_wifi_set_mac_filter(tethering_h tethering, bool mac_filter)
3222 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3223 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3225 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3226 "parameter(tethering) is NULL\n");
3228 __tethering_h *th = (__tethering_h *)tethering;
3229 th->mac_filter = mac_filter;
3231 return TETHERING_ERROR_NONE;
3234 API int tethering_wifi_get_mac_filter(tethering_h tethering, bool *mac_filter)
3236 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3237 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3239 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3240 "parameter(mac_filter) is NULL\n");
3241 _retvm_if(mac_filter == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3242 "parameter(mac_filter) is NULL\n");
3244 __tethering_h *th = (__tethering_h *)tethering;
3245 *mac_filter = th->mac_filter;
3247 return TETHERING_ERROR_NONE;
3250 static int __add_mac_to_file(const char *filepath, const char *mac)
3253 char line[MAX_BUF_SIZE] = "\0";
3254 bool mac_exist = false;
3257 p_mac = strdup(mac);
3258 if (p_mac == NULL) {
3259 ERR("strdup failed\n");
3260 return TETHERING_ERROR_OUT_OF_MEMORY;
3263 fp = fopen(filepath, "a+");
3265 ERR("fopen is failed\n");
3266 return TETHERING_ERROR_OPERATION_FAILED;
3269 while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
3270 if (strncmp(mac, line, 17) == 0) {
3271 DBG("MAC %s already exist in the list\n", mac);
3278 fprintf(fp, "%s\n", mac);
3280 if ((strcmp(filepath, ALLOWED_LIST) == 0))
3281 allowed_list = g_slist_append(allowed_list, p_mac);
3282 else if ((strcmp(filepath, BLOCKED_LIST) == 0))
3283 blocked_list = g_slist_append(blocked_list, p_mac);
3288 return TETHERING_ERROR_NONE;
3291 static int __remove_mac_from_file(const char *filepath, const char *mac)
3295 char line[MAX_BUF_SIZE] = "\0";
3297 fp = fopen(filepath, "r");
3299 ERR("fopen is failed\n");
3300 return TETHERING_ERROR_OPERATION_FAILED;
3303 fp1 = fopen(TEMP_LIST, "w+");
3306 ERR("fopen is failed\n");
3307 return TETHERING_ERROR_OPERATION_FAILED;
3310 while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
3311 if (strncmp(mac, line, 17) == 0) {
3312 DBG("MAC %s found in the list\n", mac);
3314 if ((strcmp(filepath, ALLOWED_LIST) == 0)) {
3315 GSList *list = NULL;
3316 for (list = allowed_list; list != NULL; list = list->next) {
3317 char *p_mac = (char *)list->data;
3318 if (strncmp(mac, p_mac, strlen(mac)) == 0)
3319 allowed_list = g_slist_remove(allowed_list, p_mac);
3321 } else if ((strcmp(filepath, BLOCKED_LIST) == 0)) {
3322 GSList *list = NULL;
3323 for (list = blocked_list; list != NULL; list = list->next) {
3324 char *p_mac = (char *)list->data;
3325 if (strncmp(mac, p_mac, strlen(mac)) == 0)
3326 blocked_list = g_slist_remove(blocked_list, p_mac);
3330 fprintf(fp1, "%s", line);
3337 if ((strcmp(filepath, ALLOWED_LIST) == 0))
3338 rename(TEMP_LIST, ALLOWED_LIST);
3339 else if ((strcmp(filepath, BLOCKED_LIST) == 0))
3340 rename(TEMP_LIST, BLOCKED_LIST);
3342 return TETHERING_ERROR_NONE;
3345 API int tethering_wifi_add_allowed_mac_list(tethering_h tethering, const char *mac)
3347 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3348 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3350 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3351 "parameter(tethering) is NULL\n");
3352 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3353 "parameter(mac) is NULL\n");
3355 return __add_mac_to_file(ALLOWED_LIST, mac);
3358 API int tethering_wifi_remove_allowed_mac_list(tethering_h tethering, const char *mac)
3360 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3361 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3363 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3364 "parameter(tethering) is NULL\n");
3365 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3366 "parameter(mac) is NULL\n");
3368 return __remove_mac_from_file(ALLOWED_LIST, mac);
3371 API int tethering_wifi_get_allowed_mac_list(tethering_h tethering, void **allowed_mac_list)
3373 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3374 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3376 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3377 "parameter(tethering) is NULL\n");
3378 _retvm_if(allowed_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3379 "parameter(allowed_mac_list) is NULL\n");
3381 *allowed_mac_list = g_slist_copy(allowed_list);
3382 return TETHERING_ERROR_NONE;
3385 API int tethering_wifi_add_blocked_mac_list(tethering_h tethering, const char *mac)
3387 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3388 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3390 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3391 "parameter(tethering) is NULL\n");
3392 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3393 "parameter(mac) is NULL\n");
3395 return __add_mac_to_file(BLOCKED_LIST, mac);
3398 API int tethering_wifi_remove_blocked_mac_list(tethering_h tethering, const char *mac)
3400 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3401 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3403 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3404 "parameter(tethering) is NULL\n");
3405 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3406 "parameter(mac) is NULL\n");
3408 return __remove_mac_from_file(BLOCKED_LIST, mac);
3411 API int tethering_wifi_get_blocked_mac_list(tethering_h tethering, void **blocked_mac_list)
3413 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3414 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3416 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3417 "parameter(tethering) is NULL\n");
3418 _retvm_if(blocked_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3419 "parameter(blocked_mac_list) is NULL\n");
3421 *blocked_mac_list = g_slist_copy(blocked_list);
3422 return TETHERING_ERROR_NONE;
3425 API int tethering_wifi_enable_dhcp(tethering_h tethering, bool enable)
3427 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3428 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3430 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3431 "parameter(tethering) is NULL\n");
3433 GVariant *parameters;
3434 GError *error = NULL;
3437 __tethering_h *th = (__tethering_h *)tethering;
3439 GDBusProxy *proxy = th->client_bus_proxy;
3441 parameters = g_dbus_proxy_call_sync(proxy, "enable_dhcp",
3442 g_variant_new("(b)", enable),
3443 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3446 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3447 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3448 result = TETHERING_ERROR_PERMISSION_DENIED;
3450 result = TETHERING_ERROR_OPERATION_FAILED;
3452 g_error_free(error);
3453 th->dhcp_enabled = false;
3458 g_variant_get(parameters, "(u)", &result);
3459 g_variant_unref(parameters);
3462 th->dhcp_enabled = true;
3464 th->dhcp_enabled = false;
3466 return TETHERING_ERROR_NONE;
3469 API int tethering_wifi_set_dhcp_range(tethering_h tethering, char *rangestart, char *rangestop)
3471 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3472 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3474 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3475 "parameter(tethering) is NULL\n");
3476 _retvm_if(rangestart == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3477 "parameter(rangestart) is NULL\n");
3478 _retvm_if(rangestop == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3479 "parameter(rangestop) is NULL\n");
3481 GVariant *parameters;
3482 GError *error = NULL;
3485 __tethering_h *th = (__tethering_h *)tethering;
3487 GDBusProxy *proxy = th->client_bus_proxy;
3489 parameters = g_dbus_proxy_call_sync(proxy, "dhcp_range",
3490 g_variant_new("(ss)", rangestart, rangestop),
3491 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3493 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3495 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3496 result = TETHERING_ERROR_PERMISSION_DENIED;
3498 result = TETHERING_ERROR_OPERATION_FAILED;
3500 g_error_free(error);
3501 th->dhcp_enabled = false;
3506 g_variant_get(parameters, "(u)", &result);
3507 g_variant_unref(parameters);
3509 th->dhcp_enabled = true;
3511 return TETHERING_ERROR_NONE;
3514 API int tethering_wifi_is_dhcp_enabled(tethering_h tethering, bool *dhcp_enabled)
3516 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3517 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3519 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3520 "parameter(tethering) is NULL\n");
3521 _retvm_if(dhcp_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3522 "parameter(dhcp_enabled) is NULL\n");
3524 __tethering_h *th = (__tethering_h *)tethering;
3525 *dhcp_enabled = th->dhcp_enabled;
3527 return TETHERING_ERROR_NONE;
3530 API int tethering_wifi_set_txpower(tethering_h tethering, unsigned int txpower)
3532 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3533 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3535 GError *error = NULL;
3537 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3538 "parameter(tethering) is NULL\n");
3539 _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false,
3540 TETHERING_ERROR_NOT_ENABLED,
3541 "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
3542 __tethering_h *th = (__tethering_h *)tethering;
3544 g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_set_txpower",
3545 g_variant_new("(u)", txpower),
3546 G_DBUS_CALL_FLAGS_NONE,
3547 -1, th->cancellable, &error);
3549 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
3550 g_clear_error(&error);
3551 return TETHERING_ERROR_OPERATION_FAILED;
3553 return TETHERING_ERROR_NONE;
3556 API int tethering_wifi_get_txpower(tethering_h tethering, unsigned int *txpower)
3558 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3559 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3561 GError *error = NULL;
3562 GVariant *result = NULL;
3564 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3565 "parameter(tethering) is NULL\n");
3566 _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false,
3567 TETHERING_ERROR_NOT_ENABLED,
3568 "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
3570 __tethering_h *th = (__tethering_h *)tethering;
3572 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_get_txpower",
3574 G_DBUS_CALL_FLAGS_NONE,
3575 -1, th->cancellable, &error);
3577 if (result != NULL) {
3578 g_variant_get(result, "(u)", txpower);
3579 g_variant_unref(result);
3582 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
3583 g_clear_error(&error);
3584 return TETHERING_ERROR_OPERATION_FAILED;
3586 g_clear_error(&error);
3587 return TETHERING_ERROR_NONE;
3590 API int tethering_wifi_set_mtu(tethering_h tethering, unsigned int mtu)
3592 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3593 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3595 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3596 "parameter(tethering) is NULL\n");
3598 GVariant *parameters;
3599 GError *error = NULL;
3602 __tethering_h *th = (__tethering_h *)tethering;
3604 GDBusProxy *proxy = th->client_bus_proxy;
3606 parameters = g_dbus_proxy_call_sync(proxy, "set_mtu",
3607 g_variant_new("(u)", mtu),
3608 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3610 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3612 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3613 result = TETHERING_ERROR_PERMISSION_DENIED;
3615 result = TETHERING_ERROR_OPERATION_FAILED;
3617 g_error_free(error);
3621 g_variant_get(parameters, "(u)", &result);
3623 g_variant_unref(parameters);
3625 return TETHERING_ERROR_NONE;
3628 API int tethering_wifi_change_mac(tethering_h tethering, char *mac)
3630 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3631 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3633 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3634 "parameter(tethering) is NULL\n");
3635 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3636 "parameter(mac) is NULL\n");
3638 GVariant *parameters;
3639 GError *error = NULL;
3642 __tethering_h *th = (__tethering_h *)tethering;
3644 GDBusProxy *proxy = th->client_bus_proxy;
3646 parameters = g_dbus_proxy_call_sync(proxy, "change_mac",
3647 g_variant_new("(s)", mac),
3648 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3650 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3652 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3653 result = TETHERING_ERROR_PERMISSION_DENIED;
3655 result = TETHERING_ERROR_OPERATION_FAILED;
3657 g_error_free(error);
3661 g_variant_get(parameters, "(u)", &result);
3663 g_variant_unref(parameters);
3665 th->change_mac = true;
3667 return TETHERING_ERROR_NONE;
3670 API int tethering_wifi_set_max_connected_device(tethering_h tethering, int max_device)
3672 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3673 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3675 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3676 "parameter(tethering) is NULL\n");
3678 __tethering_h *th = (__tethering_h *)tethering;
3680 th->wifi_max_connected = max_device;
3682 return TETHERING_ERROR_NONE;
3685 API int tethering_wifi_get_max_connected_device(tethering_h tethering, int *max_device)
3687 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3688 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3690 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3691 "parameter(tethering) is NULL\n");
3692 _retvm_if(max_device == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3693 "parameter(max_device) is NULL\n");
3695 __tethering_h *th = (__tethering_h *)tethering;
3697 *max_device = th->wifi_max_connected;
3698 return TETHERING_ERROR_NONE;
3701 API int tethering_wifi_enable_port_forwarding(tethering_h tethering, bool enable)
3703 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3704 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3706 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3707 "parameter(tethering) is NULL\n");
3709 GVariant *parameters;
3710 GError *error = NULL;
3713 __tethering_h *th = (__tethering_h *)tethering;
3715 GDBusProxy *proxy = th->client_bus_proxy;
3717 parameters = g_dbus_proxy_call_sync(proxy, "enable_port_forwarding",
3718 g_variant_new("(b)", enable),
3719 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3721 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3723 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3724 result = TETHERING_ERROR_PERMISSION_DENIED;
3726 result = TETHERING_ERROR_OPERATION_FAILED;
3728 g_error_free(error);
3732 g_variant_get(parameters, "(u)", &result);
3733 g_variant_unref(parameters);
3735 th->port_forwarding = true;
3737 return TETHERING_ERROR_NONE;
3740 API int tethering_wifi_add_port_forwarding_rule(tethering_h tethering, char *ifname, char *protocol, char *org_ip, int org_port, char *final_ip, int final_port)
3742 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3743 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3745 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3746 "parameter(tethering) is NULL\n");
3747 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3748 "parameter(protocol) is NULL\n");
3750 GVariant *parameters;
3751 GError *error = NULL;
3753 char cmd[MAX_BUF_SIZE] = { 0, };
3756 __tethering_h *th = (__tethering_h *)tethering;
3758 GDBusProxy *proxy = th->client_bus_proxy;
3760 parameters = g_dbus_proxy_call_sync(proxy, "add_port_forwarding_rule",
3761 g_variant_new("(sssisi)", ifname, protocol, org_ip, org_port, final_ip, final_port),
3762 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3764 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3766 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3767 result = TETHERING_ERROR_PERMISSION_DENIED;
3769 result = TETHERING_ERROR_OPERATION_FAILED;
3771 g_error_free(error);
3775 g_variant_get(parameters, "(u)", &result);
3776 g_variant_unref(parameters);
3778 snprintf(cmd, sizeof(cmd), "%s "PORT_FORWARD_RULE_STR, IPTABLES, TABLE_NAT, TETH_NAT_PRE, ifname, protocol, org_ip, org_port, final_ip, final_port);
3782 ERR("strdup failed\n");
3783 return TETHERING_ERROR_OUT_OF_MEMORY;
3786 port_forwarding = g_slist_append(port_forwarding, list);
3788 return TETHERING_ERROR_NONE;
3791 API int tethering_wifi_reset_port_forwarding_rule(tethering_h tethering)
3793 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3794 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3796 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3797 "parameter(tethering) is NULL\n");
3799 GVariant *parameters;
3800 GError *error = NULL;
3803 __tethering_h *th = (__tethering_h *)tethering;
3805 GDBusProxy *proxy = th->client_bus_proxy;
3807 parameters = g_dbus_proxy_call_sync(proxy, "reset_port_forwarding_rule",
3808 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3810 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3812 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3813 result = TETHERING_ERROR_PERMISSION_DENIED;
3815 result = TETHERING_ERROR_OPERATION_FAILED;
3817 g_error_free(error);
3821 g_variant_get(parameters, "(u)", &result);
3823 g_variant_unref(parameters);
3825 return TETHERING_ERROR_NONE;
3828 API int tethering_wifi_is_port_forwarding_enabled(tethering_h tethering, bool* forwarding_enabled)
3830 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3831 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3833 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3834 "parameter(tethering) is NULL\n");
3835 _retvm_if(forwarding_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3836 "parameter(forwarding_enabled) is NULL\n");
3838 __tethering_h *th = (__tethering_h *)tethering;
3840 *forwarding_enabled = th->port_forwarding;
3842 return TETHERING_ERROR_NONE;
3845 API int tethering_wifi_get_port_forwarding_rule(tethering_h tethering, void **port_forwarding_list)
3847 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3848 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3850 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3851 "parameter(tethering) is NULL\n");
3852 _retvm_if(port_forwarding_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3853 "parameter(port_forwarding_list) is NULL\n");
3855 *port_forwarding_list = g_slist_copy(port_forwarding);
3856 return TETHERING_ERROR_NONE;
3859 API int tethering_wifi_enable_port_filtering(tethering_h tethering, bool enable)
3861 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3862 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3864 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3865 "parameter(tethering) is NULL\n");
3867 GVariant *parameters;
3868 GError *error = NULL;
3871 __tethering_h *th = (__tethering_h *)tethering;
3873 GDBusProxy *proxy = th->client_bus_proxy;
3875 parameters = g_dbus_proxy_call_sync(proxy, "enable_port_filtering",
3876 g_variant_new("(b)", enable),
3877 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3879 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3881 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3882 result = TETHERING_ERROR_PERMISSION_DENIED;
3884 result = TETHERING_ERROR_OPERATION_FAILED;
3886 g_error_free(error);
3890 g_variant_get(parameters, "(u)", &result);
3891 g_variant_unref(parameters);
3893 th->port_filtering = true;
3895 return TETHERING_ERROR_NONE;
3898 API int tethering_wifi_add_port_filtering_rule(tethering_h tethering, int port, char *protocol, bool allow)
3900 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3901 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3903 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3904 "parameter(tethering) is NULL\n");
3905 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3906 "parameter(protocol) is NULL\n");
3908 GVariant *parameters;
3909 GError *error = NULL;
3911 char cmd[MAX_BUF_SIZE] = { 0, };
3914 __tethering_h *th = (__tethering_h *)tethering;
3916 GDBusProxy *proxy = th->client_bus_proxy;
3918 parameters = g_dbus_proxy_call_sync(proxy, "add_port_filtering_rule",
3919 g_variant_new("(isb)", port, protocol, allow),
3920 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3922 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3924 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3925 result = TETHERING_ERROR_PERMISSION_DENIED;
3927 result = TETHERING_ERROR_OPERATION_FAILED;
3929 g_error_free(error);
3933 g_variant_get(parameters, "(u)", &result);
3934 g_variant_unref(parameters);
3937 snprintf(cmd, sizeof(cmd), "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_ACCEPT);
3939 snprintf(cmd, sizeof(cmd), "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_DROP);
3945 ERR("strdup failed\n");
3946 return TETHERING_ERROR_OUT_OF_MEMORY;
3949 port_filtering = g_slist_append(port_filtering, list);
3951 return TETHERING_ERROR_NONE;
3954 API int tethering_wifi_add_custom_port_filtering_rule(tethering_h tethering, int port1, int port2, char *protocol, bool allow)
3956 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3957 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3959 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3960 "parameter(tethering) is NULL\n");
3961 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3962 "parameter(protocol) is NULL\n");
3964 GVariant *parameters;
3965 GError *error = NULL;
3967 char cmd[MAX_BUF_SIZE] = { 0, };
3970 __tethering_h *th = (__tethering_h *)tethering;
3972 GDBusProxy *proxy = th->client_bus_proxy;
3974 parameters = g_dbus_proxy_call_sync(proxy, "add_custom_port_filtering_rule",
3975 g_variant_new("(iisb)", port1, port2, protocol, allow),
3976 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3978 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3980 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3981 result = TETHERING_ERROR_PERMISSION_DENIED;
3983 result = TETHERING_ERROR_OPERATION_FAILED;
3985 g_error_free(error);
3989 g_variant_get(parameters, "(u)", &result);
3990 g_variant_unref(parameters);
3993 snprintf(cmd, sizeof(cmd), "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_ACCEPT);
3995 snprintf(cmd, sizeof(cmd), "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_DROP);
4001 ERR("strdup failed\n");
4002 return TETHERING_ERROR_OUT_OF_MEMORY;
4005 custom_port_filtering = g_slist_append(custom_port_filtering, list);
4007 return TETHERING_ERROR_NONE;
4010 API int tethering_wifi_get_port_filtering_rule(tethering_h tethering, void **port_filtering_list)
4012 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4013 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4015 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4016 "parameter(tethering) is NULL\n");
4017 _retvm_if(port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4018 "parameter(port_filtering_list) is NULL\n");
4020 *port_filtering_list = g_slist_copy(port_filtering);
4021 return TETHERING_ERROR_NONE;
4024 API int tethering_wifi_get_custom_port_filtering_rule(tethering_h tethering, void **custom_port_filtering_list)
4026 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4027 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4029 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4030 "parameter(tethering) is NULL\n");
4031 _retvm_if(custom_port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4032 "parameter(custom_port_filtering_list) is NULL\n");
4034 *custom_port_filtering_list = g_slist_copy(custom_port_filtering);
4035 return TETHERING_ERROR_NONE;
4038 API int tethering_wifi_is_port_filtering_enabled(tethering_h tethering, bool* filtering_enabled)
4040 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4041 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4043 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4044 "parameter(tethering) is NULL\n");
4045 _retvm_if(filtering_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4046 "parameter(filtering_enabled) is NULL\n");
4048 __tethering_h *th = (__tethering_h *)tethering;
4050 *filtering_enabled = th->port_filtering;
4052 return TETHERING_ERROR_NONE;
4055 API int tethering_wifi_set_vpn_passthrough_rule(tethering_h tethering, tethering_vpn_passthrough_type_e type, bool enable)
4057 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4058 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4060 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4061 "parameter(tethering) is NULL\n");
4063 GVariant *parameters;
4064 GError *error = NULL;
4067 __tethering_h *th = (__tethering_h *)tethering;
4069 GDBusProxy *proxy = th->client_bus_proxy;
4071 parameters = g_dbus_proxy_call_sync(proxy, "set_vpn_passthrough_rule",
4072 g_variant_new("(ib)", type, enable),
4073 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4075 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4077 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4078 result = TETHERING_ERROR_PERMISSION_DENIED;
4080 result = TETHERING_ERROR_OPERATION_FAILED;
4082 g_error_free(error);
4086 g_variant_get(parameters, "(u)", &result);
4088 g_variant_unref(parameters);
4090 return TETHERING_ERROR_NONE;
4093 API int tethering_wifi_push_wps_button(tethering_h tethering)
4095 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4096 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4098 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4099 "parameter(tethering) is NULL");
4100 __tethering_h *th = (__tethering_h *)tethering;
4101 GDBusProxy *proxy = th->client_bus_proxy;
4102 GVariant *parameters = NULL;
4104 GError *error = NULL;
4106 parameters = g_dbus_proxy_call_sync(proxy, "push_wps_button",
4107 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4110 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4112 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4113 ret = TETHERING_ERROR_PERMISSION_DENIED;
4115 ret = TETHERING_ERROR_OPERATION_FAILED;
4117 g_error_free(error);
4121 if (parameters != NULL) {
4122 g_variant_get(parameters, "(u)", &ret);
4123 g_variant_unref(parameters);
4126 return TETHERING_ERROR_NONE;
4129 API int tethering_wifi_set_wps_pin(tethering_h tethering, const char *wps_pin)
4131 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4132 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4134 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4135 "parameter(tethering) is NULL");
4136 __tethering_h *th = (__tethering_h *)tethering;
4137 GDBusProxy *proxy = th->client_bus_proxy;
4138 GVariant *parameters = NULL;
4140 GError *error = NULL;
4142 parameters = g_dbus_proxy_call_sync(proxy, "set_wps_pin",
4143 g_variant_new("(s)", wps_pin), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4146 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4148 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4149 ret = TETHERING_ERROR_PERMISSION_DENIED;
4151 ret = TETHERING_ERROR_OPERATION_FAILED;
4153 g_error_free(error);
4157 if (parameters != NULL) {
4158 g_variant_get(parameters, "(u)", &ret);
4159 g_variant_unref(parameters);
4162 return TETHERING_ERROR_NONE;