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("(sssiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type),
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;
1621 * @brief Disables the tethering, asynchronously.
1623 * @privlevel platform
1624 * @privilege http://tizen.org/privilege/tethering.admin
1625 * @param[in] tethering The handle of tethering
1626 * @param[in] type The type of tethering
1627 * @return 0 on success, otherwise negative error value.
1628 * @retval #TETHERING_ERROR_NONE Successful
1629 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1630 * @post tethering_disabled_cb() will be invoked.
1631 * @see tethering_is_enabled()
1632 * @see tethering_enable()
1634 API int tethering_disable(tethering_h tethering, tethering_type_e type)
1636 INFO("+ type : %d\n", type);
1637 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1638 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1639 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1640 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1642 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1643 "parameter(tethering) is NULL\n");
1645 __tethering_h *th = (__tethering_h *)tethering;
1646 GDBusProxy *proxy = th->client_bus_proxy;
1647 GDBusConnection *connection = th->client_bus;
1650 case TETHERING_TYPE_USB:
1651 g_dbus_connection_signal_unsubscribe(connection,
1652 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1654 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1655 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1656 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1660 case TETHERING_TYPE_WIFI:
1662 g_dbus_connection_signal_unsubscribe(connection,
1663 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1665 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1666 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1667 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1670 case TETHERING_TYPE_BT:
1672 g_dbus_connection_signal_unsubscribe(connection,
1673 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1675 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1676 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1677 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1680 case TETHERING_TYPE_ALL:
1681 g_dbus_connection_signal_unsubscribe(connection,
1682 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1684 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1685 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1686 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1688 g_dbus_connection_signal_unsubscribe(connection,
1689 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1691 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1692 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1693 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1695 g_dbus_connection_signal_unsubscribe(connection,
1696 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1698 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1699 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1700 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1704 ERR("Not supported tethering type [%d]\n", type);
1706 return TETHERING_ERROR_INVALID_PARAMETER;
1709 return TETHERING_ERROR_NONE;
1714 * @brief Checks whetehr the tethering is enabled or not.
1716 * @privlevel platform
1717 * @privilege http://tizen.org/privilege/tethering.admin
1718 * @param[in] tethering The handle of tethering
1719 * @param[in] type The type of tethering
1720 * @return @c true if tethering is enabled, \n @c false if tethering is disabled.
1722 API bool tethering_is_enabled(tethering_h tethering, tethering_type_e type)
1724 INFO("+ type : %d\n", type);
1726 int vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_NONE;
1728 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1730 if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &is_on) != 0)
1734 case TETHERING_TYPE_USB:
1735 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_USB;
1738 case TETHERING_TYPE_WIFI:
1739 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI;
1742 case TETHERING_TYPE_BT:
1743 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_BT;
1747 ERR("Not supported type : %d\n", type);
1750 INFO("- enabled: %s\n",(is_on & vconf_type)? "true" : "false");
1751 return is_on & vconf_type ? true : false;
1756 * @brief Gets the MAC address of local device as "FC:A1:3E:D6:B1:B1".
1758 * @privlevel platform
1759 * @privilege http://tizen.org/privilege/tethering.admin
1760 * @remarks @a mac_address must be released with free() by you.
1761 * @param[in] tethering The handle of tethering
1762 * @param[in] type The type of tethering
1763 * @param[out] mac_address The MAC address
1764 * @return 0 on success, otherwise a negative error value.
1765 * @retval #TETHERING_ERROR_NONE Successful
1766 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1767 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1768 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
1769 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
1770 * @pre tethering must be enabled.
1771 * @see tethering_is_enabled()
1772 * @see tethering_enable()
1774 API int tethering_get_mac_address(tethering_h tethering, tethering_type_e type, char **mac_address)
1776 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1777 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1778 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1779 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1781 _retvm_if(tethering_is_enabled(tethering, type) == false,
1782 TETHERING_ERROR_NOT_ENABLED,
1783 "tethering type[%d] is not enabled\n", type);
1784 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1785 "parameter(tethering) is NULL\n");
1786 _retvm_if(mac_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1787 "parameter(mac_address) is NULL\n");
1791 char *macbuf = NULL;
1793 _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
1794 TETHERING_ERROR_OPERATION_FAILED,
1795 "getting interface name is failed\n");
1797 s = socket(AF_INET, SOCK_DGRAM, 0);
1798 _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
1799 "getting socket is failed\n");
1800 if (ioctl(s, SIOCGIFHWADDR, &ifr) < 0) {
1801 ERR("getting mac is failed\n");
1803 return TETHERING_ERROR_OPERATION_FAILED;
1807 macbuf = (char *)malloc(TETHERING_STR_INFO_LEN);
1808 _retvm_if(macbuf == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
1809 "Not enough memory\n");
1810 snprintf(macbuf, TETHERING_STR_INFO_LEN, "%02X:%02X:%02X:%02X:%02X:%02X",
1811 (unsigned char)ifr.ifr_hwaddr.sa_data[0],
1812 (unsigned char)ifr.ifr_hwaddr.sa_data[1],
1813 (unsigned char)ifr.ifr_hwaddr.sa_data[2],
1814 (unsigned char)ifr.ifr_hwaddr.sa_data[3],
1815 (unsigned char)ifr.ifr_hwaddr.sa_data[4],
1816 (unsigned char)ifr.ifr_hwaddr.sa_data[5]);
1818 *mac_address = macbuf;
1820 return TETHERING_ERROR_NONE;
1825 * @brief Gets the name of network interface. For example, usb0.
1827 * @privlevel platform
1828 * @privilege http://tizen.org/privilege/tethering.admin
1829 * @remarks @a interface_name must be released with free() by you.
1830 * @param[in] tethering The handle of tethering
1831 * @param[in] type The type of tethering
1832 * @param[out] interface_name The name of network interface
1833 * @return 0 on success, otherwise negative error value.
1834 * @retval #TETHERING_ERROR_NONE Successful
1835 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1836 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1837 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
1838 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
1839 * @pre tethering must be enabled.
1840 * @see tethering_is_enabled()
1841 * @see tethering_enable()
1843 API int tethering_get_network_interface_name(tethering_h tethering, tethering_type_e type, char **interface_name)
1845 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1846 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1847 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1848 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1850 _retvm_if(tethering_is_enabled(tethering, type) == false,
1851 TETHERING_ERROR_NOT_ENABLED,
1852 "tethering type[%d] is not enabled\n", type);
1853 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1854 "parameter(tethering) is NULL\n");
1855 _retvm_if(interface_name == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1856 "parameter(interface_name) is NULL\n");
1858 char intf[TETHERING_STR_INFO_LEN] = {0, };
1860 _retvm_if(!__get_intf_name(type, intf, sizeof(intf)),
1861 TETHERING_ERROR_OPERATION_FAILED,
1862 "getting interface name is failed\n");
1863 *interface_name = strdup(intf);
1864 _retvm_if(*interface_name == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
1865 "Not enough memory\n");
1867 return TETHERING_ERROR_NONE;
1872 * @brief Gets the local IP address.
1874 * @privlevel platform
1875 * @privilege http://tizen.org/privilege/tethering.admin
1876 * @remarks @a ip_address must be released with free() by you.
1877 * @param[in] tethering The handle of tethering
1878 * @param[in] type The type of tethering
1879 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
1880 * @param[out] ip_address The local IP address
1881 * @return 0 on success, otherwise negative error value.
1882 * @retval #TETHERING_ERROR_NONE Successful
1883 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1884 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1885 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
1886 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
1887 * @pre tethering must be enabled.
1888 * @see tethering_is_enabled()
1889 * @see tethering_enable()
1891 API int tethering_get_ip_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **ip_address)
1893 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1894 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1895 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1896 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1898 _retvm_if(tethering_is_enabled(tethering, type) == false,
1899 TETHERING_ERROR_NOT_ENABLED,
1900 "tethering type[%d] is not enabled\n", type);
1901 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1902 "parameter(tethering) is NULL\n");
1903 _retvm_if(ip_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1904 "parameter(ip_address) is NULL\n");
1910 _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
1911 TETHERING_ERROR_OPERATION_FAILED,
1912 "getting interface name is failed\n");
1914 s = socket(AF_INET, SOCK_DGRAM, 0);
1915 _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
1916 "getting socket is failed\n");
1917 if (ioctl(s, SIOCGIFADDR, &ifr) < 0) {
1918 ERR("ioctl is failed\n");
1920 return TETHERING_ERROR_OPERATION_FAILED;
1924 ipbuf = inet_ntoa(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr);
1925 *ip_address = strdup(ipbuf);
1926 _retvm_if(*ip_address == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
1927 "Not enough memory\n");
1929 return TETHERING_ERROR_NONE;
1934 * @brief Gets the Gateway address.
1936 * @privlevel platform
1937 * @privilege http://tizen.org/privilege/tethering.admin
1938 * @remarks @a gateway_address must be released with free() by you.
1939 * @param[in] tethering The handle of tethering
1940 * @param[in] type The type of tethering
1941 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
1942 * @param[out] gateway_address The local IP address
1943 * @return 0 on success, otherwise negative error value.
1944 * @retval #TETHERING_ERROR_NONE Successful
1945 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1946 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1947 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
1948 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
1949 * @pre tethering must be enabled.
1950 * @see tethering_is_enabled()
1951 * @see tethering_enable()
1953 API int tethering_get_gateway_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **gateway_address)
1955 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1956 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1957 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1958 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1960 _retvm_if(tethering_is_enabled(tethering, type) == false,
1961 TETHERING_ERROR_NOT_ENABLED,
1962 "tethering type[%d] is not enabled\n", type);
1963 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1964 "parameter(tethering) is NULL\n");
1965 _retvm_if(gateway_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1966 "parameter(gateway_address) is NULL\n");
1968 char gateway_buf[TETHERING_STR_INFO_LEN] = {0, };
1970 _retvm_if(!__get_gateway_addr(type, gateway_buf, sizeof(gateway_buf)),
1971 TETHERING_ERROR_OPERATION_FAILED,
1972 "getting gateway address is failed\n");
1974 *gateway_address = strdup(gateway_buf);
1976 return TETHERING_ERROR_NONE;
1981 * @brief Gets the Subnet Mask.
1983 * @privlevel platform
1984 * @privilege http://tizen.org/privilege/tethering.admin
1985 * @remarks @a subnet_mask must be released with free() by you.
1986 * @param[in] tethering The handle of tethering
1987 * @param[in] type The type of tethering
1988 * @param[in] address_family The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
1989 * @param[out] subnet_mask The local IP address
1990 * @return 0 on success, otherwise negative error value.
1991 * @retval #TETHERING_ERROR_NONE Successful
1992 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
1993 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
1994 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
1995 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
1996 * @pre tethering must be enabled.
1997 * @see tethering_is_enabled()
1998 * @see tethering_enable()
2000 API int tethering_get_subnet_mask(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **subnet_mask)
2002 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2003 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2004 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2005 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2007 _retvm_if(tethering_is_enabled(tethering, type) == false,
2008 TETHERING_ERROR_NOT_ENABLED,
2009 "tethering is not enabled\n");
2010 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2011 "parameter(tethering) is NULL\n");
2012 _retvm_if(subnet_mask == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2013 "parameter(subnet_mask) is NULL\n");
2015 *subnet_mask = strdup(TETHERING_SUBNET_MASK);
2016 _retvm_if(*subnet_mask == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2017 "Not enough memory\n");
2019 return TETHERING_ERROR_NONE;
2024 * @brief Gets the data usage.
2026 * @privlevel platform
2027 * @privilege http://tizen.org/privilege/tethering.admin
2028 * @param[in] tethering The handle of tethering
2029 * @param[out] usage The data usage
2030 * @return 0 on success, otherwise negative error value.
2031 * @retval #TETHERING_ERROR_NONE Successful
2032 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2033 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2034 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2035 * @pre tethering must be enabled.
2036 * @see tethering_is_enabled()
2037 * @see tethering_enable()
2039 API int tethering_get_data_usage(tethering_h tethering, tethering_data_usage_cb callback, void *user_data)
2041 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2043 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2044 "parameter(tethering) is NULL\n");
2045 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2046 "parameter(callback) is NULL\n");
2047 _retvm_if(__any_tethering_is_enabled(tethering) == false,
2048 TETHERING_ERROR_NOT_ENABLED,
2049 "tethering is not enabled\n");
2051 __tethering_h *th = (__tethering_h *)tethering;
2052 GDBusProxy *proxy = th->client_bus_proxy;
2054 th->data_usage_cb = callback;
2055 th->data_usage_user_data = user_data;
2057 g_dbus_proxy_call(proxy, "get_data_packet_usage",
2058 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2059 (GAsyncReadyCallback) __get_data_usage_cb, (gpointer)tethering);
2061 return TETHERING_ERROR_NONE;
2066 * @brief Gets the client which is connected by tethering "type".
2068 * @privlevel platform
2069 * @privilege http://tizen.org/privilege/tethering.admin
2070 * @param[in] tethering The handle of tethering
2071 * @param[in] type The type of tethering
2072 * @param[in] callback The callback function to invoke
2073 * @param[in] user_data The user data to be passed to the callback function
2074 * @retval #TETHERING_ERROR_NONE Successful
2075 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2076 * @retval #TETHERING_ERROR_NOT_ENABLED Not enabled
2077 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2078 * @pre tethering must be enabled.
2079 * @see tethering_is_enabled()
2080 * @see tethering_enable()
2082 API int tethering_foreach_connected_clients(tethering_h tethering, tethering_type_e type, tethering_connected_client_cb callback, void *user_data)
2084 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2085 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2086 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2087 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2089 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2090 "parameter(tethering) is NULL\n");
2091 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2092 "parameter(callback) is NULL\n");
2093 _retvm_if(__any_tethering_is_enabled(tethering) == false,
2094 TETHERING_ERROR_NOT_ENABLED,
2095 "tethering is not enabled\n");
2097 mobile_ap_type_e interface;
2098 __tethering_h *th = (__tethering_h *)tethering;
2099 __tethering_client_h client = {0, };
2102 gchar *hostname = NULL;
2103 guint timestamp = 0;
2104 GError *error = NULL;
2105 GVariant *result = NULL;
2106 GVariantIter *outer_iter = NULL;
2107 GVariantIter *inner_iter = NULL;
2108 GVariant *station = NULL;
2109 GVariant *value = NULL;
2112 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "get_station_info",
2113 NULL, G_DBUS_CALL_FLAGS_NONE,
2114 -1, th->cancellable, &error);
2116 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
2117 g_variant_get(result, "(a(a{sv}))", &outer_iter);
2118 while (g_variant_iter_loop(outer_iter, "(@a{sv})", &station)) {
2119 g_variant_get(station, "a{sv}", &inner_iter);
2120 while (g_variant_iter_loop(inner_iter, "{sv}", &key, &value)) {
2121 if (g_strcmp0(key, "Type") == 0) {
2122 interface = g_variant_get_int32(value);
2123 if (interface == MOBILE_AP_TYPE_USB)
2124 client.interface = TETHERING_TYPE_USB;
2125 else if (interface == MOBILE_AP_TYPE_WIFI)
2126 client.interface = TETHERING_TYPE_WIFI;
2127 else if (interface == MOBILE_AP_TYPE_BT)
2128 client.interface = TETHERING_TYPE_BT;
2130 ERR("Invalid interface\n");
2132 g_variant_unref(value);
2135 DBG("interface is %d\n", client.interface);
2136 if (client.interface != type && (TETHERING_TYPE_ALL != type)) {
2138 g_variant_unref(value);
2141 } else if (g_strcmp0(key, "IP") == 0) {
2142 g_variant_get(value, "s", &ip);
2143 SDBG("ip is %s\n", ip);
2144 g_strlcpy(client.ip, ip, sizeof(client.ip));
2145 } else if (g_strcmp0(key, "MAC") == 0) {
2146 g_variant_get(value, "s", &mac);
2147 SDBG("mac is %s\n", mac);
2148 g_strlcpy(client.mac, mac, sizeof(client.mac));
2149 } else if (g_strcmp0(key, "Name") == 0) {
2150 g_variant_get(value, "s", &hostname);
2151 SDBG("hsotname is %s\n", hostname);
2153 client.hostname = g_strdup(hostname);
2154 } else if (g_strcmp0(key, "Time") == 0) {
2155 timestamp = g_variant_get_int32(value);
2156 DBG("timestamp is %d\n", timestamp);
2157 client.tm = (time_t)timestamp;
2159 ERR("Key %s not required\n", key);
2165 g_variant_iter_free(inner_iter);
2166 if (callback((tethering_client_h)&client, user_data) == false) {
2167 DBG("iteration is stopped\n");
2168 g_free(client.hostname);
2169 g_variant_iter_free(outer_iter);
2170 g_variant_unref(station);
2171 g_variant_unref(result);
2173 return TETHERING_ERROR_OPERATION_FAILED;
2175 g_free(client.hostname);
2177 g_variant_iter_free(outer_iter);
2178 g_variant_unref(station);
2179 g_variant_unref(result);
2181 return TETHERING_ERROR_NONE;
2186 * @brief Registers the callback function called when tethering is enabled.
2188 * @privlevel platform
2189 * @privilege http://tizen.org/privilege/tethering.admin
2190 * @param[in] tethering The handle of tethering
2191 * @param[in] type The type of tethering
2192 * @param[in] callback The callback function to invoke
2193 * @param[in] user_data The user data to be passed to the callback function
2194 * @retval #TETHERING_ERROR_NONE Successful
2195 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2196 * @see tethering_unset_enabled_cb()
2198 API int tethering_set_enabled_cb(tethering_h tethering, tethering_type_e type, tethering_enabled_cb callback, void *user_data)
2200 INFO("+ type: %d\n", type);
2201 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2202 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2203 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2204 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2206 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2207 "parameter(tethering) is NULL\n");
2208 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2209 "parameter(callback) is NULL\n");
2211 __tethering_h *th = (__tethering_h *)tethering;
2212 tethering_type_e ti;
2214 if (type != TETHERING_TYPE_ALL) {
2215 th->enabled_cb[type] = callback;
2216 th->enabled_user_data[type] = user_data;
2218 return TETHERING_ERROR_NONE;
2221 /* TETHERING_TYPE_ALL */
2222 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2223 th->enabled_cb[ti] = callback;
2224 th->enabled_user_data[ti] = user_data;
2228 return TETHERING_ERROR_NONE;
2233 * @brief Unregisters the callback function called when tethering is disabled.
2235 * @privlevel platform
2236 * @privilege http://tizen.org/privilege/tethering.admin
2237 * @param[in] tethering The handle of tethering
2238 * @param[in] type The type of tethering
2239 * @retval #TETHERING_ERROR_NONE Successful
2240 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2241 * @see tethering_set_enabled_cb()
2243 API int tethering_unset_enabled_cb(tethering_h tethering, tethering_type_e type)
2245 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2246 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2247 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2248 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2250 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2251 "parameter(tethering) is NULL\n");
2253 __tethering_h *th = (__tethering_h *)tethering;
2254 tethering_type_e ti;
2256 if (type != TETHERING_TYPE_ALL) {
2257 th->enabled_cb[type] = NULL;
2258 th->enabled_user_data[type] = NULL;
2260 return TETHERING_ERROR_NONE;
2263 /* TETHERING_TYPE_ALL */
2264 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2265 th->enabled_cb[ti] = NULL;
2266 th->enabled_user_data[ti] = NULL;
2269 return TETHERING_ERROR_NONE;
2274 * @brief Registers the callback function called when tethering is disabled.
2276 * @privlevel platform
2277 * @privilege http://tizen.org/privilege/tethering.admin
2278 * @param[in] tethering The handle of tethering
2279 * @param[in] type The type of tethering
2280 * @param[in] callback The callback function to invoke
2281 * @param[in] user_data The user data to be passed to the callback function
2282 * @retval #TETHERING_ERROR_NONE Successful
2283 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2284 * @see tethering_unset_disabled_cb()
2286 API int tethering_set_disabled_cb(tethering_h tethering, tethering_type_e type, tethering_disabled_cb callback, void *user_data)
2288 INFO("+ type: %d\n", type);
2289 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2290 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2291 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2292 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2294 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2295 "parameter(tethering) is NULL\n");
2296 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2297 "parameter(callback) is NULL\n");
2299 __tethering_h *th = (__tethering_h *)tethering;
2300 tethering_type_e ti;
2302 if (type != TETHERING_TYPE_ALL) {
2303 th->disabled_cb[type] = callback;
2304 th->disabled_user_data[type] = user_data;
2306 return TETHERING_ERROR_NONE;
2309 /* TETHERING_TYPE_ALL */
2310 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2311 th->disabled_cb[ti] = callback;
2312 th->disabled_user_data[ti] = user_data;
2315 return TETHERING_ERROR_NONE;
2320 * @brief Unregisters the callback function called when tethering is disabled.
2322 * @privlevel platform
2323 * @privilege http://tizen.org/privilege/tethering.admin
2324 * @param[in] tethering The handle of tethering
2325 * @param[in] type The type of tethering
2326 * @retval #TETHERING_ERROR_NONE Successful
2327 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2328 * @see tethering_set_disabled_cb()
2330 API int tethering_unset_disabled_cb(tethering_h tethering, tethering_type_e type)
2332 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2333 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2334 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2335 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2337 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2338 "parameter(tethering) is NULL\n");
2340 __tethering_h *th = (__tethering_h *)tethering;
2341 tethering_type_e ti;
2343 if (type != TETHERING_TYPE_ALL) {
2344 th->disabled_cb[type] = NULL;
2345 th->disabled_user_data[type] = NULL;
2347 return TETHERING_ERROR_NONE;
2350 /* TETHERING_TYPE_ALL */
2351 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2352 th->disabled_cb[ti] = NULL;
2353 th->disabled_user_data[ti] = NULL;
2356 return TETHERING_ERROR_NONE;
2361 * @brief Registers the callback function called when the state of connection is changed.
2363 * @privlevel platform
2364 * @privilege http://tizen.org/privilege/tethering.admin
2365 * @param[in] tethering The handle of tethering
2366 * @param[in] type The type of tethering
2367 * @param[in] callback The callback function to invoke
2368 * @param[in] user_data The user data to be passed to the callback function
2369 * @retval #TETHERING_ERROR_NONE Successful
2370 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2371 * @see tethering_unset_connection_state_changed_cb_cb()
2373 API int tethering_set_connection_state_changed_cb(tethering_h tethering, tethering_type_e type, tethering_connection_state_changed_cb callback, void *user_data)
2375 INFO("+ type: %d\n", type);
2376 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2377 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2378 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2379 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2381 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2382 "parameter(tethering) is NULL\n");
2383 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2384 "parameter(callback) is NULL\n");
2386 __tethering_h *th = (__tethering_h *)tethering;
2387 tethering_type_e ti;
2389 if (type != TETHERING_TYPE_ALL) {
2390 th->changed_cb[type] = callback;
2391 th->changed_user_data[type] = user_data;
2393 return TETHERING_ERROR_NONE;
2396 /* TETHERING_TYPE_ALL */
2397 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2398 th->changed_cb[ti] = callback;
2399 th->changed_user_data[ti] = user_data;
2402 return TETHERING_ERROR_NONE;
2407 * @brief Unregisters the callback function called when the state of connection is changed.
2409 * @privlevel platform
2410 * @privilege http://tizen.org/privilege/tethering.admin
2411 * @param[in] tethering The handle of tethering
2412 * @param[in] type The type of tethering
2413 * @retval #TETHERING_ERROR_NONE Successful
2414 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2415 * @see tethering_set_connection_state_changed_cb()
2417 API int tethering_unset_connection_state_changed_cb(tethering_h tethering, tethering_type_e type)
2419 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2420 if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2421 else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2422 else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2424 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2425 "parameter(tethering) is NULL\n");
2427 __tethering_h *th = (__tethering_h *)tethering;
2428 tethering_type_e ti;
2430 if (type != TETHERING_TYPE_ALL) {
2431 th->changed_cb[type] = NULL;
2432 th->changed_user_data[type] = NULL;
2434 return TETHERING_ERROR_NONE;
2437 /* TETHERING_TYPE_ALL */
2438 for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_BT; ti++) {
2439 th->changed_cb[ti] = NULL;
2440 th->changed_user_data[ti] = NULL;
2443 return TETHERING_ERROR_NONE;
2448 * @brief Registers the callback function called when the security type of Wi-Fi tethering is changed.
2450 * @privlevel platform
2451 * @privilege http://tizen.org/privilege/tethering.admin
2452 * @param[in] tethering The handle of tethering
2453 * @param[in] callback The callback function to invoke
2454 * @param[in] user_data The user data to be passed to the callback function
2455 * @retval #TETHERING_ERROR_NONE Successful
2456 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2457 * @see tethering_wifi_unset_security_type_changed_cb()
2459 API int tethering_wifi_set_security_type_changed_cb(tethering_h tethering, tethering_wifi_security_type_changed_cb callback, void *user_data)
2461 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2462 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2464 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2465 "parameter(tethering) is NULL\n");
2466 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2467 "parameter(callback) is NULL\n");
2469 __tethering_h *th = (__tethering_h *)tethering;
2471 th->security_type_changed_cb = callback;
2472 th->security_type_user_data = user_data;
2474 return TETHERING_ERROR_NONE;
2480 * @brief Unregisters the callback function called when the security type of Wi-Fi tethering is changed.
2482 * @privlevel platform
2483 * @privilege http://tizen.org/privilege/tethering.admin
2484 * @param[in] tethering The handle of tethering
2485 * @param[in] type The type of tethering
2486 * @retval #TETHERING_ERROR_NONE Successful
2487 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2488 * @see tethering_wifi_set_security_type_changed_cb()
2490 API int tethering_wifi_unset_security_type_changed_cb(tethering_h tethering)
2492 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2493 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2495 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2496 "parameter(tethering) is NULL\n");
2498 __tethering_h *th = (__tethering_h *)tethering;
2500 th->security_type_changed_cb = NULL;
2501 th->security_type_user_data = NULL;
2503 return TETHERING_ERROR_NONE;
2508 * @brief Registers the callback function called when the visibility of SSID is changed.
2510 * @privlevel platform
2511 * @privilege http://tizen.org/privilege/tethering.admin
2512 * @param[in] tethering The handle of tethering
2513 * @param[in] callback The callback function to invoke
2514 * @param[in] user_data The user data to be passed to the callback function
2515 * @retval #TETHERING_ERROR_NONE Successful
2516 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2517 * @see tethering_wifi_unset_ssid_visibility_changed_cb_cb()
2519 API int tethering_wifi_set_ssid_visibility_changed_cb(tethering_h tethering, tethering_wifi_ssid_visibility_changed_cb callback, void *user_data)
2521 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2522 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2524 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2525 "parameter(tethering) is NULL\n");
2526 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2527 "parameter(callback) is NULL\n");
2529 __tethering_h *th = (__tethering_h *)tethering;
2531 th->ssid_visibility_changed_cb = callback;
2532 th->ssid_visibility_user_data = user_data;
2534 return TETHERING_ERROR_NONE;
2539 * @brief Unregisters the callback function called when the visibility of SSID is changed.
2541 * @privlevel platform
2542 * @privilege http://tizen.org/privilege/tethering.admin
2543 * @param[in] tethering The handle of tethering
2544 * @retval #TETHERING_ERROR_NONE Successful
2545 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2546 * @see tethering_wifi_set_ssid_visibility_changed_cb()
2548 API int tethering_wifi_unset_ssid_visibility_changed_cb(tethering_h tethering)
2550 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2551 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2553 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2554 "parameter(tethering) is NULL\n");
2556 __tethering_h *th = (__tethering_h *)tethering;
2558 th->ssid_visibility_changed_cb = NULL;
2559 th->ssid_visibility_user_data = NULL;
2561 return TETHERING_ERROR_NONE;
2566 * @brief Registers the callback function called when the passphrase of Wi-Fi tethering is changed.
2568 * @privlevel platform
2569 * @privilege http://tizen.org/privilege/tethering.admin
2570 * @param[in] tethering The handle of tethering
2571 * @param[in] callback The callback function to invoke
2572 * @param[in] user_data The user data to be passed to the callback function
2573 * @retval #TETHERING_ERROR_NONE Successful
2574 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2575 * @see tethering_wifi_unset_passphrase_changed_cb()
2577 API int tethering_wifi_set_passphrase_changed_cb(tethering_h tethering, tethering_wifi_passphrase_changed_cb callback, void *user_data)
2579 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2580 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2582 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2583 "parameter(tethering) is NULL\n");
2584 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2585 "parameter(callback) is NULL\n");
2587 __tethering_h *th = (__tethering_h *)tethering;
2589 th->passphrase_changed_cb = callback;
2590 th->passphrase_user_data = user_data;
2592 return TETHERING_ERROR_NONE;
2597 * @brief Unregisters the callback function called when the passphrase of Wi-Fi tethering is changed.
2599 * @privlevel platform
2600 * @privilege http://tizen.org/privilege/tethering.admin
2601 * @param[in] tethering The handle of tethering
2602 * @retval #TETHERING_ERROR_NONE Successful
2603 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2604 * @see tethering_wifi_set_passphrase_changed_cb()
2606 API int tethering_wifi_unset_passphrase_changed_cb(tethering_h tethering)
2608 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2609 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2611 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2612 "parameter(tethering) is NULL\n");
2614 __tethering_h *th = (__tethering_h *)tethering;
2616 th->passphrase_changed_cb = NULL;
2617 th->passphrase_user_data = NULL;
2619 return TETHERING_ERROR_NONE;
2624 * @brief Sets the security type of Wi-Fi tethering.
2626 * @privlevel platform
2627 * @privilege http://tizen.org/privilege/tethering.admin
2628 * @remarks This change is applied next time Wi-Fi tethering is enabled
2629 * @param[in] tethering The handle of tethering
2630 * @param[in] type The security type
2631 * @return 0 on success, otherwise negative error value.
2632 * @retval #TETHERING_ERROR_NONE Successful
2633 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2634 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2635 * @see tethering_wifi_get_security_type()
2637 API int tethering_wifi_set_security_type(tethering_h tethering, tethering_wifi_security_type_e type)
2639 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2640 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2642 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2643 "parameter(tethering) is NULL\n");
2645 __tethering_h *th = (__tethering_h *)tethering;
2646 tethering_error_e ret = TETHERING_ERROR_NONE;
2647 char *sec_str = NULL;
2649 ret = __set_security_type(type);
2650 if (ret == TETHERING_ERROR_NONE) {
2653 case TETHERING_WIFI_SECURITY_TYPE_NONE:
2654 sec_str = TETHERING_WIFI_SECURITY_TYPE_OPEN_STR;
2656 case TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK:
2657 sec_str = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR;
2659 case TETHERING_WIFI_SECURITY_TYPE_WPS:
2660 sec_str = TETHERING_WIFI_SECURITY_TYPE_WPS_STR;
2664 __send_dbus_signal(th->client_bus,
2665 SIGNAL_NAME_SECURITY_TYPE_CHANGED, sec_str);
2672 * @brief Gets the security type of Wi-Fi tethering.
2674 * @privlevel platform
2675 * @privilege http://tizen.org/privilege/tethering.admin
2676 * @param[in] tethering The handle of tethering
2677 * @param[out] type The security type
2678 * @return 0 on success, otherwise negative error value.
2679 * @retval #TETHERING_ERROR_NONE Successful
2680 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2681 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2682 * @see tethering_wifi_set_security_type()
2684 API int tethering_wifi_get_security_type(tethering_h tethering, tethering_wifi_security_type_e *type)
2686 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2687 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2689 _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2690 "parameter(type) is NULL\n");
2692 return __get_security_type(type);
2697 * @brief Sets the SSID (service set identifier).
2699 * @privlevel platform
2700 * @privilege http://tizen.org/privilege/tethering.admin
2701 * @details If SSID is not set, Device name is used as SSID
2702 * @remarks This change is applied next time Wi-Fi tethering is enabled with same @a tethering handle
2703 * @param[in] tethering The handle of tethering
2704 * @param[out] ssid The SSID
2705 * @return 0 on success, otherwise negative error value.
2706 * @retval #TETHERING_ERROR_NONE Successful
2707 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2708 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2710 API int tethering_wifi_set_ssid(tethering_h tethering, const char *ssid)
2712 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2713 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2715 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2716 "parameter(tethering) is NULL\n");
2717 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2718 "parameter(ssid) is NULL\n");
2720 __tethering_h *th = (__tethering_h *)tethering;
2721 char *p_ssid = NULL;
2724 ssid_len = strlen(ssid);
2725 if (ssid_len > TETHERING_WIFI_SSID_MAX_LEN) {
2726 ERR("parameter(ssid) is too long");
2727 return TETHERING_ERROR_INVALID_PARAMETER;
2730 p_ssid = strdup(ssid);
2731 _retvm_if(p_ssid == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2732 "strdup is failed\n");
2738 return TETHERING_ERROR_NONE;
2743 * @brief Gets the SSID (service set identifier).
2745 * @privlevel platform
2746 * @privilege http://tizen.org/privilege/tethering.admin
2747 * @remarks @a ssid must be released with free() by you.
2748 * @param[in] tethering The handle of tethering
2749 * @param[out] ssid The SSID
2750 * @return 0 on success, otherwise negative error value.
2751 * @retval #TETHERING_ERROR_NONE Successful
2752 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2753 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2754 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2756 API int tethering_wifi_get_ssid(tethering_h tethering, char **ssid)
2758 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2759 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2761 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2762 "parameter(tethering) is NULL\n");
2763 _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2764 "parameter(ssid) is NULL\n");
2767 __tethering_h *th = (__tethering_h *)tethering;
2768 char val[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
2770 if (!tethering_is_enabled(NULL, TETHERING_TYPE_WIFI)) {
2771 if (th->ssid != NULL) {
2772 DBG("Private SSID is set\n");
2773 *ssid = strdup(th->ssid);
2775 if (__get_ssid_from_vconf(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
2776 val, sizeof(val)) == false) {
2777 return TETHERING_ERROR_OPERATION_FAILED;
2779 *ssid = strdup(val);
2782 if (__get_ssid_from_vconf(VCONFKEY_MOBILE_HOTSPOT_SSID,
2783 val, sizeof(val)) == false) {
2784 return TETHERING_ERROR_OPERATION_FAILED;
2786 *ssid = strdup(val);
2789 if (*ssid == NULL) {
2790 ERR("strdup is failed\n");
2791 return TETHERING_ERROR_OUT_OF_MEMORY;
2794 return TETHERING_ERROR_NONE;
2799 * @brief Sets the visibility of SSID(service set identifier).
2801 * @privlevel platform
2802 * @privilege http://tizen.org/privilege/tethering.admin
2803 * @details If you set the visibility invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
2804 * @remarks This change is applied next time Wi-Fi tethering is enabled
2805 * @param[in] tethering The handle of tethering
2806 * @param[in] visible The visibility of SSID: (@c true = visible, @c false = invisible)
2807 * @return 0 on success, otherwise negative error value.
2808 * @retval #TETHERING_ERROR_NONE Successful
2809 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2810 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2811 * @see tethering_wifi_get_ssid_visibility()
2813 API int tethering_wifi_set_ssid_visibility(tethering_h tethering, bool visible)
2815 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2816 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2818 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2819 "parameter(tethering) is NULL\n");
2821 __tethering_h *th = (__tethering_h *)tethering;
2822 tethering_error_e ret = TETHERING_ERROR_NONE;
2824 ret = __set_visible(visible);
2825 if (ret == TETHERING_ERROR_NONE) {
2827 __send_dbus_signal(th->client_bus,
2828 SIGNAL_NAME_SSID_VISIBILITY_CHANGED,
2829 visible ? SIGNAL_MSG_SSID_VISIBLE :
2830 SIGNAL_MSG_SSID_HIDE);
2837 * @brief Gets the visibility of SSID(service set identifier).
2839 * @privlevel platform
2840 * @privilege http://tizen.org/privilege/tethering.admin
2841 * @details If the visibility is set invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
2842 * @param[in] tethering The handle of tethering
2843 * @param[out] visible The visibility of SSID: (@c true = visible, @c false = invisible)
2844 * @return 0 on success, otherwise negative error value.
2845 * @retval #TETHERING_ERROR_NONE Successful
2846 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2847 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2848 * @see tethering_wifi_set_ssid_visibility()
2850 API int tethering_wifi_get_ssid_visibility(tethering_h tethering, bool *visible)
2852 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2853 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2855 _retvm_if(visible == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2856 "parameter(visible) is NULL\n");
2858 return __get_visible(visible);
2863 * @brief Sets the passphrase.
2865 * @privlevel platform
2866 * @privilege http://tizen.org/privilege/tethering.admin
2867 * @remarks This change is applied next time Wi-Fi tethering is enabled
2868 * @param[in] tethering The handle of tethering
2869 * @param[in] passphrase The passphrase
2870 * @return 0 on success, otherwise negative error value.
2871 * @retval #TETHERING_ERROR_NONE Successful
2872 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2873 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2874 * @see tethering_wifi_get_passphrase()
2876 API int tethering_wifi_set_passphrase(tethering_h tethering, const char *passphrase)
2878 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2879 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2881 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2882 "parameter(tethering) is NULL\n");
2883 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2884 "parameter(passphrase) is NULL\n");
2886 __tethering_h *th = (__tethering_h *)tethering;
2887 GDBusProxy *proxy = th->client_bus_proxy;
2888 GVariant *parameters;
2889 GError *error = NULL;
2890 int passphrase_len = 0;
2894 passphrase_len = strlen(passphrase);
2895 if (passphrase_len < TETHERING_WIFI_KEY_MIN_LEN ||
2896 passphrase_len > TETHERING_WIFI_KEY_MAX_LEN) {
2897 ERR("parameter(passphrase) is too short or long\n");
2898 return TETHERING_ERROR_INVALID_PARAMETER;
2901 parameters = g_dbus_proxy_call_sync(proxy, "set_wifi_tethering_passphrase",
2902 g_variant_new("(s)", passphrase), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
2906 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
2908 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
2909 ret = TETHERING_ERROR_PERMISSION_DENIED;
2911 ret = TETHERING_ERROR_OPERATION_FAILED;
2913 g_error_free(error);
2918 g_variant_get(parameters, "(u)", &ret);
2919 g_variant_unref(parameters);
2921 if (ret == TETHERING_ERROR_NONE) {
2922 __send_dbus_signal(th->client_bus,
2923 SIGNAL_NAME_PASSPHRASE_CHANGED, NULL);
2932 * @brief Gets the passphrase.
2934 * @privlevel platform
2935 * @privilege http://tizen.org/privilege/tethering.admin
2936 * @remarks @a passphrase must be released with free() by you.
2937 * @param[in] tethering The handle of tethering
2938 * @param[out] passphrase The passphrase
2939 * @return 0 on success, otherwise negative error value.
2940 * @retval #TETHERING_ERROR_NONE Successful
2941 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
2942 * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
2943 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
2944 * @see tethering_wifi_set_passphrase()
2946 API int tethering_wifi_get_passphrase(tethering_h tethering, char **passphrase)
2948 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2949 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2951 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2952 "parameter(tethering) is NULL\n");
2953 _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2954 "parameter(passphrase) is NULL\n");
2956 __tethering_h *th = (__tethering_h *)tethering;
2957 GDBusProxy *proxy = th->client_bus_proxy;
2958 GVariant *parameters;
2959 GError *error = NULL;
2960 unsigned int len = 0;
2961 tethering_error_e ret = TETHERING_ERROR_NONE;
2963 parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_passphrase",
2964 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
2968 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
2970 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
2971 ret = TETHERING_ERROR_PERMISSION_DENIED;
2973 ret = TETHERING_ERROR_OPERATION_FAILED;
2975 g_error_free(error);
2980 if (parameters != NULL) {
2981 g_variant_get(parameters, "(siu)", passphrase, &len, &ret);
2982 g_variant_unref(parameters);
2985 return TETHERING_ERROR_NONE;
2988 API int tethering_wifi_set_channel(tethering_h tethering, int channel)
2990 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2991 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2993 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2994 "parameter(tethering) is NULL\n");
2996 __tethering_h *th = (__tethering_h *)tethering;
2997 th->channel = channel;
2999 return TETHERING_ERROR_NONE;
3002 API int tethering_wifi_get_channel(tethering_h tethering, int *channel)
3004 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3005 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3007 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3008 "parameter(tethering) is NULL\n");
3010 _retvm_if(channel == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3011 "parameter(channel) is NULL\n");
3013 __tethering_h *th = (__tethering_h *)tethering;
3014 *channel = th->channel;
3016 return TETHERING_ERROR_NONE;
3019 API int tethering_wifi_set_mode(tethering_h tethering, tethering_wifi_mode_type_e type)
3021 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3022 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3024 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3025 "parameter(tethering) is NULL\n");
3027 __tethering_h *th = (__tethering_h *)tethering;
3029 th->mode_type = type;
3031 return TETHERING_ERROR_NONE;
3034 API int tethering_wifi_get_mode(tethering_h tethering, tethering_wifi_mode_type_e *type)
3036 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3037 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3039 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3040 "parameter(tethering) is NULL\n");
3041 _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3042 "parameter(type) is NULL\n");
3044 __tethering_h *th = (__tethering_h *)tethering;
3045 *type = th->mode_type;
3047 return TETHERING_ERROR_NONE;
3053 * @brief Reload the settings (SSID / Passphrase / Security type / SSID visibility).
3055 * @privlevel platform
3056 * @privilege http://tizen.org/privilege/tethering.admin
3057 * @remarks Connected devices via Wi-Fi tethering or MobileAP will be disconnected when the settings are reloaded
3058 * @param[in] tethering The handle of tethering
3059 * @param[in] callback The callback function to invoke
3060 * @param[in] user_data The user data to be passed to the callback function
3061 * @return 0 on success, otherwise negative error value.
3062 * @retval #TETHERING_ERROR_NONE Successful
3063 * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
3064 * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
3066 API int tethering_wifi_reload_settings(tethering_h tethering, tethering_wifi_settings_reloaded_cb callback, void *user_data)
3069 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3070 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3072 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3073 "parameter(tethering) is NULL\n");
3074 _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3075 "parameter(callback) is NULL\n");
3077 __tethering_h *th = (__tethering_h *)tethering;
3078 _softap_settings_t set = {"", "", "", 0, false};
3079 GDBusProxy *proxy = th->client_bus_proxy;
3084 if (th->settings_reloaded_cb) {
3085 ERR("Operation in progress\n");
3086 return TETHERING_ERROR_OPERATION_FAILED;
3089 ret = __prepare_wifi_settings(tethering, &set);
3090 if (ret != TETHERING_ERROR_NONE) {
3091 ERR("softap settings initialization failed\n");
3092 return TETHERING_ERROR_OPERATION_FAILED;
3095 th->settings_reloaded_cb = callback;
3096 th->settings_reloaded_user_data = user_data;
3098 g_dbus_proxy_call(proxy, "reload_wifi_settings",
3099 g_variant_new("(sssiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type),
3100 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
3101 (GAsyncReadyCallback) __settings_reloaded_cb, (gpointer)tethering);
3103 return TETHERING_ERROR_NONE;
3106 API int tethering_wifi_set_mac_filter(tethering_h tethering, bool mac_filter)
3108 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3109 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3111 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3112 "parameter(tethering) is NULL\n");
3114 __tethering_h *th = (__tethering_h *)tethering;
3115 th->mac_filter = mac_filter;
3117 return TETHERING_ERROR_NONE;
3120 API int tethering_wifi_get_mac_filter(tethering_h tethering, bool *mac_filter)
3122 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3123 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3125 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3126 "parameter(mac_filter) is NULL\n");
3127 _retvm_if(mac_filter == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3128 "parameter(mac_filter) is NULL\n");
3130 __tethering_h *th = (__tethering_h *)tethering;
3131 *mac_filter = th->mac_filter;
3133 return TETHERING_ERROR_NONE;
3136 static int __add_mac_to_file(const char *filepath, const char *mac)
3139 char line[MAX_BUF_SIZE] = "\0";
3140 bool mac_exist = false;
3143 p_mac = strdup(mac);
3144 if (p_mac == NULL) {
3145 ERR("strdup failed\n");
3146 return TETHERING_ERROR_OUT_OF_MEMORY;
3149 fp = fopen(filepath, "a+");
3151 ERR("fopen is failed\n");
3152 return TETHERING_ERROR_OPERATION_FAILED;
3155 while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
3156 if (strncmp(mac, line, 17) == 0) {
3157 DBG("MAC %s already exist in the list\n", mac);
3164 fprintf(fp, "%s\n", mac);
3166 if ((strcmp(filepath, ALLOWED_LIST) == 0))
3167 allowed_list = g_slist_append(allowed_list, p_mac);
3168 else if ((strcmp(filepath, BLOCKED_LIST) == 0))
3169 blocked_list = g_slist_append(blocked_list, p_mac);
3174 return TETHERING_ERROR_NONE;
3177 static int __remove_mac_from_file(const char *filepath, const char *mac)
3181 char line[MAX_BUF_SIZE] = "\0";
3183 fp = fopen(filepath, "r");
3185 ERR("fopen is failed\n");
3186 return TETHERING_ERROR_OPERATION_FAILED;
3189 fp1 = fopen(TEMP_LIST, "w+");
3192 ERR("fopen is failed\n");
3193 return TETHERING_ERROR_OPERATION_FAILED;
3196 while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
3197 if (strncmp(mac, line, 17) == 0) {
3198 DBG("MAC %s found in the list\n", mac);
3200 if ((strcmp(filepath, ALLOWED_LIST) == 0)) {
3201 GSList *list = NULL;
3202 for (list = allowed_list; list != NULL; list = list->next) {
3203 char *p_mac = (char *)list->data;
3204 if (strncmp(mac, p_mac, strlen(mac)) == 0)
3205 allowed_list = g_slist_remove(allowed_list, p_mac);
3207 } else if ((strcmp(filepath, BLOCKED_LIST) == 0)) {
3208 GSList *list = NULL;
3209 for (list = blocked_list; list != NULL; list = list->next) {
3210 char *p_mac = (char *)list->data;
3211 if (strncmp(mac, p_mac, strlen(mac)) == 0)
3212 blocked_list = g_slist_remove(blocked_list, p_mac);
3216 fprintf(fp1, "%s", line);
3223 if ((strcmp(filepath, ALLOWED_LIST) == 0))
3224 rename(TEMP_LIST, ALLOWED_LIST);
3225 else if ((strcmp(filepath, BLOCKED_LIST) == 0))
3226 rename(TEMP_LIST, BLOCKED_LIST);
3228 return TETHERING_ERROR_NONE;
3231 API int tethering_wifi_add_allowed_mac_list(tethering_h tethering, const char *mac)
3233 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3234 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3236 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3237 "parameter(tethering) is NULL\n");
3238 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3239 "parameter(mac) is NULL\n");
3241 return __add_mac_to_file(ALLOWED_LIST, mac);
3244 API int tethering_wifi_remove_allowed_mac_list(tethering_h tethering, const char *mac)
3246 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3247 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3249 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3250 "parameter(tethering) is NULL\n");
3251 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3252 "parameter(mac) is NULL\n");
3254 return __remove_mac_from_file(ALLOWED_LIST, mac);
3257 API int tethering_wifi_get_allowed_mac_list(tethering_h tethering, void **allowed_mac_list)
3259 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3260 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3262 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3263 "parameter(tethering) is NULL\n");
3264 _retvm_if(allowed_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3265 "parameter(allowed_mac_list) is NULL\n");
3267 *allowed_mac_list = g_slist_copy(allowed_list);
3268 return TETHERING_ERROR_NONE;
3271 API int tethering_wifi_add_blocked_mac_list(tethering_h tethering, const char *mac)
3273 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3274 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3276 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3277 "parameter(tethering) is NULL\n");
3278 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3279 "parameter(mac) is NULL\n");
3281 return __add_mac_to_file(BLOCKED_LIST, mac);
3284 API int tethering_wifi_remove_blocked_mac_list(tethering_h tethering, const char *mac)
3286 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3287 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3289 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3290 "parameter(tethering) is NULL\n");
3291 _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3292 "parameter(mac) is NULL\n");
3294 return __remove_mac_from_file(BLOCKED_LIST, mac);
3297 API int tethering_wifi_get_blocked_mac_list(tethering_h tethering, void **blocked_mac_list)
3299 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3300 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3302 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3303 "parameter(tethering) is NULL\n");
3304 _retvm_if(blocked_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3305 "parameter(blocked_mac_list) is NULL\n");
3307 *blocked_mac_list = g_slist_copy(blocked_list);
3308 return TETHERING_ERROR_NONE;
3311 API int tethering_wifi_enable_dhcp(tethering_h tethering, bool enable)
3313 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3314 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3316 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3317 "parameter(tethering) is NULL\n");
3319 GVariant *parameters;
3320 GError *error = NULL;
3323 __tethering_h *th = (__tethering_h *)tethering;
3325 GDBusProxy *proxy = th->client_bus_proxy;
3327 parameters = g_dbus_proxy_call_sync(proxy, "enable_dhcp",
3328 g_variant_new("(b)", enable),
3329 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3332 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3333 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3334 result = TETHERING_ERROR_PERMISSION_DENIED;
3336 result = TETHERING_ERROR_OPERATION_FAILED;
3338 g_error_free(error);
3339 th->dhcp_enabled = false;
3344 g_variant_get(parameters, "(u)", &result);
3345 g_variant_unref(parameters);
3348 th->dhcp_enabled = true;
3350 th->dhcp_enabled = false;
3352 return TETHERING_ERROR_NONE;
3355 API int tethering_wifi_set_dhcp_range(tethering_h tethering, char *rangestart, char *rangestop)
3357 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3358 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3360 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3361 "parameter(tethering) is NULL\n");
3362 _retvm_if(rangestart == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3363 "parameter(rangestart) is NULL\n");
3364 _retvm_if(rangestop == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3365 "parameter(rangestop) is NULL\n");
3367 GVariant *parameters;
3368 GError *error = NULL;
3371 __tethering_h *th = (__tethering_h *)tethering;
3373 GDBusProxy *proxy = th->client_bus_proxy;
3375 parameters = g_dbus_proxy_call_sync(proxy, "dhcp_range",
3376 g_variant_new("(ss)", rangestart, rangestop),
3377 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3379 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3381 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3382 result = TETHERING_ERROR_PERMISSION_DENIED;
3384 result = TETHERING_ERROR_OPERATION_FAILED;
3386 g_error_free(error);
3387 th->dhcp_enabled = false;
3392 g_variant_get(parameters, "(u)", &result);
3393 g_variant_unref(parameters);
3395 th->dhcp_enabled = true;
3397 return TETHERING_ERROR_NONE;
3400 API int tethering_wifi_is_dhcp_enabled(tethering_h tethering, bool *dhcp_enabled)
3402 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3403 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3405 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3406 "parameter(tethering) is NULL\n");
3407 _retvm_if(dhcp_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3408 "parameter(dhcp_enabled) is NULL\n");
3410 __tethering_h *th = (__tethering_h *)tethering;
3411 *dhcp_enabled = th->dhcp_enabled;
3413 return TETHERING_ERROR_NONE;
3416 API int tethering_wifi_set_txpower(tethering_h tethering, unsigned int txpower)
3418 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3419 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3421 GError *error = NULL;
3423 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3424 "parameter(tethering) is NULL\n");
3425 _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false,
3426 TETHERING_ERROR_NOT_ENABLED,
3427 "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
3428 __tethering_h *th = (__tethering_h *)tethering;
3430 g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_set_txpower",
3431 g_variant_new("(u)", txpower),
3432 G_DBUS_CALL_FLAGS_NONE,
3433 -1, th->cancellable, &error);
3435 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
3436 g_clear_error(&error);
3437 return TETHERING_ERROR_OPERATION_FAILED;
3439 return TETHERING_ERROR_NONE;
3442 API int tethering_wifi_get_txpower(tethering_h tethering, unsigned int *txpower)
3444 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3445 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3447 GError *error = NULL;
3448 GVariant *result = NULL;
3450 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3451 "parameter(tethering) is NULL\n");
3452 _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false,
3453 TETHERING_ERROR_NOT_ENABLED,
3454 "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
3456 __tethering_h *th = (__tethering_h *)tethering;
3458 result = g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_get_txpower",
3460 G_DBUS_CALL_FLAGS_NONE,
3461 -1, th->cancellable, &error);
3463 if (result != NULL) {
3464 g_variant_get(result, "(u)", txpower);
3465 g_variant_unref(result);
3468 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
3469 g_clear_error(&error);
3470 return TETHERING_ERROR_OPERATION_FAILED;
3472 g_clear_error(&error);
3473 return TETHERING_ERROR_NONE;
3476 API int tethering_wifi_set_mtu(tethering_h tethering, unsigned int mtu)
3478 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3479 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3481 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3482 "parameter(tethering) is NULL\n");
3484 GVariant *parameters;
3485 GError *error = NULL;
3488 __tethering_h *th = (__tethering_h *)tethering;
3490 GDBusProxy *proxy = th->client_bus_proxy;
3492 parameters = g_dbus_proxy_call_sync(proxy, "set_mtu",
3493 g_variant_new("(u)", mtu),
3494 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3496 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3498 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3499 result = TETHERING_ERROR_PERMISSION_DENIED;
3501 result = TETHERING_ERROR_OPERATION_FAILED;
3503 g_error_free(error);
3507 g_variant_get(parameters, "(u)", &result);
3509 g_variant_unref(parameters);
3511 return TETHERING_ERROR_NONE;
3514 API int tethering_wifi_change_mac(tethering_h tethering, char *mac)
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(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3522 "parameter(mac) is NULL\n");
3524 GVariant *parameters;
3525 GError *error = NULL;
3528 __tethering_h *th = (__tethering_h *)tethering;
3530 GDBusProxy *proxy = th->client_bus_proxy;
3532 parameters = g_dbus_proxy_call_sync(proxy, "change_mac",
3533 g_variant_new("(s)", mac),
3534 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3536 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3538 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3539 result = TETHERING_ERROR_PERMISSION_DENIED;
3541 result = TETHERING_ERROR_OPERATION_FAILED;
3543 g_error_free(error);
3547 g_variant_get(parameters, "(u)", &result);
3549 g_variant_unref(parameters);
3551 th->change_mac = true;
3553 return TETHERING_ERROR_NONE;
3556 API int tethering_wifi_set_max_connected_device(tethering_h tethering, int max_device)
3558 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3559 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3561 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3562 "parameter(tethering) is NULL\n");
3564 __tethering_h *th = (__tethering_h *)tethering;
3566 th->wifi_max_connected = max_device;
3568 return TETHERING_ERROR_NONE;
3571 API int tethering_wifi_get_max_connected_device(tethering_h tethering, int *max_device)
3573 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3574 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3576 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3577 "parameter(tethering) is NULL\n");
3578 _retvm_if(max_device == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3579 "parameter(max_device) is NULL\n");
3581 __tethering_h *th = (__tethering_h *)tethering;
3583 *max_device = th->wifi_max_connected;
3584 return TETHERING_ERROR_NONE;
3587 API int tethering_wifi_enable_port_forwarding(tethering_h tethering, bool enable)
3589 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3590 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3592 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3593 "parameter(tethering) is NULL\n");
3595 GVariant *parameters;
3596 GError *error = NULL;
3599 __tethering_h *th = (__tethering_h *)tethering;
3601 GDBusProxy *proxy = th->client_bus_proxy;
3603 parameters = g_dbus_proxy_call_sync(proxy, "enable_port_forwarding",
3604 g_variant_new("(b)", enable),
3605 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3607 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3609 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3610 result = TETHERING_ERROR_PERMISSION_DENIED;
3612 result = TETHERING_ERROR_OPERATION_FAILED;
3614 g_error_free(error);
3618 g_variant_get(parameters, "(u)", &result);
3619 g_variant_unref(parameters);
3621 th->port_forwarding = true;
3623 return TETHERING_ERROR_NONE;
3626 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)
3628 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3629 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3631 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3632 "parameter(tethering) is NULL\n");
3633 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3634 "parameter(protocol) is NULL\n");
3636 GVariant *parameters;
3637 GError *error = NULL;
3639 char cmd[MAX_BUF_SIZE] = { 0, };
3642 __tethering_h *th = (__tethering_h *)tethering;
3644 GDBusProxy *proxy = th->client_bus_proxy;
3646 parameters = g_dbus_proxy_call_sync(proxy, "add_port_forwarding_rule",
3647 g_variant_new("(sssisi)", ifname, protocol, org_ip, org_port, final_ip, final_port),
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);
3662 g_variant_unref(parameters);
3664 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);
3668 ERR("strdup failed\n");
3669 return TETHERING_ERROR_OUT_OF_MEMORY;
3672 port_forwarding = g_slist_append(port_forwarding, list);
3674 return TETHERING_ERROR_NONE;
3677 API int tethering_wifi_reset_port_forwarding_rule(tethering_h tethering)
3679 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3680 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3682 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3683 "parameter(tethering) is NULL\n");
3685 GVariant *parameters;
3686 GError *error = NULL;
3689 __tethering_h *th = (__tethering_h *)tethering;
3691 GDBusProxy *proxy = th->client_bus_proxy;
3693 parameters = g_dbus_proxy_call_sync(proxy, "reset_port_forwarding_rule",
3694 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3696 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3698 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3699 result = TETHERING_ERROR_PERMISSION_DENIED;
3701 result = TETHERING_ERROR_OPERATION_FAILED;
3703 g_error_free(error);
3707 g_variant_get(parameters, "(u)", &result);
3709 g_variant_unref(parameters);
3711 return TETHERING_ERROR_NONE;
3714 API int tethering_wifi_is_port_forwarding_enabled(tethering_h tethering, bool* forwarding_enabled)
3716 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3717 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3719 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3720 "parameter(tethering) is NULL\n");
3721 _retvm_if(forwarding_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3722 "parameter(forwarding_enabled) is NULL\n");
3724 __tethering_h *th = (__tethering_h *)tethering;
3726 *forwarding_enabled = th->port_forwarding;
3728 return TETHERING_ERROR_NONE;
3731 API int tethering_wifi_get_port_forwarding_rule(tethering_h tethering, void **port_forwarding_list)
3733 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3734 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3736 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3737 "parameter(tethering) is NULL\n");
3738 _retvm_if(port_forwarding_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3739 "parameter(port_forwarding_list) is NULL\n");
3741 *port_forwarding_list = g_slist_copy(port_forwarding);
3742 return TETHERING_ERROR_NONE;
3745 API int tethering_wifi_enable_port_filtering(tethering_h tethering, bool enable)
3747 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3748 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3750 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3751 "parameter(tethering) is NULL\n");
3753 GVariant *parameters;
3754 GError *error = NULL;
3757 __tethering_h *th = (__tethering_h *)tethering;
3759 GDBusProxy *proxy = th->client_bus_proxy;
3761 parameters = g_dbus_proxy_call_sync(proxy, "enable_port_filtering",
3762 g_variant_new("(b)", enable),
3763 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3765 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3767 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3768 result = TETHERING_ERROR_PERMISSION_DENIED;
3770 result = TETHERING_ERROR_OPERATION_FAILED;
3772 g_error_free(error);
3776 g_variant_get(parameters, "(u)", &result);
3777 g_variant_unref(parameters);
3779 th->port_filtering = true;
3781 return TETHERING_ERROR_NONE;
3784 API int tethering_wifi_add_port_filtering_rule(tethering_h tethering, int port, char *protocol, bool allow)
3786 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3787 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3789 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3790 "parameter(tethering) is NULL\n");
3791 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3792 "parameter(protocol) is NULL\n");
3794 GVariant *parameters;
3795 GError *error = NULL;
3797 char cmd[MAX_BUF_SIZE] = { 0, };
3800 __tethering_h *th = (__tethering_h *)tethering;
3802 GDBusProxy *proxy = th->client_bus_proxy;
3804 parameters = g_dbus_proxy_call_sync(proxy, "add_port_filtering_rule",
3805 g_variant_new("(isb)", port, protocol, allow),
3806 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3808 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3810 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3811 result = TETHERING_ERROR_PERMISSION_DENIED;
3813 result = TETHERING_ERROR_OPERATION_FAILED;
3815 g_error_free(error);
3819 g_variant_get(parameters, "(u)", &result);
3820 g_variant_unref(parameters);
3823 snprintf(cmd, sizeof(cmd), "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_ACCEPT);
3825 snprintf(cmd, sizeof(cmd), "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_DROP);
3831 ERR("strdup failed\n");
3832 return TETHERING_ERROR_OUT_OF_MEMORY;
3835 port_filtering = g_slist_append(port_filtering, list);
3837 return TETHERING_ERROR_NONE;
3840 API int tethering_wifi_add_custom_port_filtering_rule(tethering_h tethering, int port1, int port2, char *protocol, bool allow)
3842 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3843 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3845 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3846 "parameter(tethering) is NULL\n");
3847 _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3848 "parameter(protocol) is NULL\n");
3850 GVariant *parameters;
3851 GError *error = NULL;
3853 char cmd[MAX_BUF_SIZE] = { 0, };
3856 __tethering_h *th = (__tethering_h *)tethering;
3858 GDBusProxy *proxy = th->client_bus_proxy;
3860 parameters = g_dbus_proxy_call_sync(proxy, "add_custom_port_filtering_rule",
3861 g_variant_new("(iisb)", port1, port2, protocol, allow),
3862 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3864 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3866 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3867 result = TETHERING_ERROR_PERMISSION_DENIED;
3869 result = TETHERING_ERROR_OPERATION_FAILED;
3871 g_error_free(error);
3875 g_variant_get(parameters, "(u)", &result);
3876 g_variant_unref(parameters);
3879 snprintf(cmd, sizeof(cmd), "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_ACCEPT);
3881 snprintf(cmd, sizeof(cmd), "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_DROP);
3887 ERR("strdup failed\n");
3888 return TETHERING_ERROR_OUT_OF_MEMORY;
3891 custom_port_filtering = g_slist_append(custom_port_filtering, list);
3893 return TETHERING_ERROR_NONE;
3896 API int tethering_wifi_get_port_filtering_rule(tethering_h tethering, void **port_filtering_list)
3898 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3899 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3901 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3902 "parameter(tethering) is NULL\n");
3903 _retvm_if(port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3904 "parameter(port_filtering_list) is NULL\n");
3906 *port_filtering_list = g_slist_copy(port_filtering);
3907 return TETHERING_ERROR_NONE;
3910 API int tethering_wifi_get_custom_port_filtering_rule(tethering_h tethering, void **custom_port_filtering_list)
3912 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3913 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3915 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3916 "parameter(tethering) is NULL\n");
3917 _retvm_if(custom_port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3918 "parameter(custom_port_filtering_list) is NULL\n");
3920 *custom_port_filtering_list = g_slist_copy(custom_port_filtering);
3921 return TETHERING_ERROR_NONE;
3924 API int tethering_wifi_is_port_filtering_enabled(tethering_h tethering, bool* filtering_enabled)
3926 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3927 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3929 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3930 "parameter(tethering) is NULL\n");
3931 _retvm_if(filtering_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3932 "parameter(filtering_enabled) is NULL\n");
3934 __tethering_h *th = (__tethering_h *)tethering;
3936 *filtering_enabled = th->port_filtering;
3938 return TETHERING_ERROR_NONE;
3941 API int tethering_wifi_set_vpn_passthrough_rule(tethering_h tethering, tethering_vpn_passthrough_type_e type, bool enable)
3943 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3944 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3946 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3947 "parameter(tethering) is NULL\n");
3949 GVariant *parameters;
3950 GError *error = NULL;
3953 __tethering_h *th = (__tethering_h *)tethering;
3955 GDBusProxy *proxy = th->client_bus_proxy;
3957 parameters = g_dbus_proxy_call_sync(proxy, "set_vpn_passthrough_rule",
3958 g_variant_new("(ib)", type, enable),
3959 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3961 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3963 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3964 result = TETHERING_ERROR_PERMISSION_DENIED;
3966 result = TETHERING_ERROR_OPERATION_FAILED;
3968 g_error_free(error);
3972 g_variant_get(parameters, "(u)", &result);
3974 g_variant_unref(parameters);
3976 return TETHERING_ERROR_NONE;
3979 API int tethering_wifi_push_wps_button(tethering_h tethering)
3981 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3982 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3984 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3985 "parameter(tethering) is NULL");
3986 __tethering_h *th = (__tethering_h *)tethering;
3987 GDBusProxy *proxy = th->client_bus_proxy;
3988 GVariant *parameters = NULL;
3990 GError *error = NULL;
3992 parameters = g_dbus_proxy_call_sync(proxy, "push_wps_button",
3993 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3996 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
3998 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3999 ret = TETHERING_ERROR_PERMISSION_DENIED;
4001 ret = TETHERING_ERROR_OPERATION_FAILED;
4003 g_error_free(error);
4007 if (parameters != NULL) {
4008 g_variant_get(parameters, "(u)", &ret);
4009 g_variant_unref(parameters);
4012 return TETHERING_ERROR_NONE;
4015 API int tethering_wifi_set_wps_pin(tethering_h tethering, const char *wps_pin)
4017 CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4018 CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4020 _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4021 "parameter(tethering) is NULL");
4022 __tethering_h *th = (__tethering_h *)tethering;
4023 GDBusProxy *proxy = th->client_bus_proxy;
4024 GVariant *parameters = NULL;
4026 GError *error = NULL;
4028 parameters = g_dbus_proxy_call_sync(proxy, "set_wps_pin",
4029 g_variant_new("(s)", wps_pin), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4032 ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
4034 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4035 ret = TETHERING_ERROR_PERMISSION_DENIED;
4037 ret = TETHERING_ERROR_OPERATION_FAILED;
4039 g_error_free(error);
4043 if (parameters != NULL) {
4044 g_variant_get(parameters, "(u)", &ret);
4045 g_variant_unref(parameters);
4048 return TETHERING_ERROR_NONE;