src/tethering.c

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   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
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  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.
  15 */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <sys/ioctl.h>
  21 #include <sys/socket.h>
  22 #include <netinet/in.h>
  23 #include <net/if.h>
  24 #include <arpa/inet.h>
  25 #include <unistd.h>
  26 #include <dbus/dbus.h>
  27 #include <gio/gio.h>
  28 #include <vconf.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"
  34
  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
  40
  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"
  51
  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;
  57
  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);
  61
  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);
  65
  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);
  69
  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);
  73
  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);
  77
  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);
  81
  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);
  85
  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);
  89
  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);
  93
  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);
  97
  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);
 101
 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);
 105
 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);
 109
 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);
 113
 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} };
 129
 130 static int retry = 0;
 131
 132 static void __send_dbus_signal(GDBusConnection *conn, const char *signal_name, const char *arg)
 133 {
 134         if (conn == NULL || signal_name == NULL)
 135                 return; //LCOV_EXCL_LINE
 136
 137         GVariant *message = NULL;
 138         GError *error = NULL;
 139
 140         if (arg)
 141                 message = g_variant_new("(s)", arg);
 142
 143         g_dbus_connection_emit_signal(conn, NULL, TETHERING_SERVICE_OBJECT_PATH,
 144                                         TETHERING_SERVICE_INTERFACE, signal_name, message, &error);
 145         if (error) {
 146                 ERR("g_dbus_connection_emit_signal is failed because  %s\n", error->message); //LCOV_EXCL_LINE
 147                 g_error_free(error); //LCOV_EXCL_LINE
 148         }
 149         g_variant_unref(message);
 150 }
 151
 152 static bool __any_tethering_is_enabled(tethering_h tethering)
 153 {
 154         if (tethering_is_enabled(tethering, TETHERING_TYPE_USB) ||
 155                         tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) ||
 156                         tethering_is_enabled(tethering, TETHERING_TYPE_BT) ||
 157                         tethering_is_enabled(tethering, TETHERING_TYPE_P2P))
 158                 return true;
 159
 160         return false;
 161 }
 162
 163 static tethering_error_e __set_security_type(const tethering_wifi_security_type_e security_type)
 164 {
 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"); //LCOV_EXCL_LINE
 169                 return TETHERING_ERROR_INVALID_PARAMETER;
 170         }
 171
 172         if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY, security_type) < 0) {
 173                 ERR("vconf_set_int is failed\n"); //LCOV_EXCL_LINE
 174                 return TETHERING_ERROR_OPERATION_FAILED;
 175         }
 176
 177         return TETHERING_ERROR_NONE;
 178 }
 179
 180 static tethering_error_e __get_security_type(tethering_wifi_security_type_e *security_type)
 181 {
 182         if (security_type == NULL) {
 183                 ERR("Invalid param\n"); //LCOV_EXCL_LINE
 184                 return TETHERING_ERROR_INVALID_PARAMETER;
 185         }
 186
 187         if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY,
 188                                 (int *)security_type) < 0) {
 189                 ERR("vconf_get_int is failed\n"); //LCOV_EXCL_LINE
 190                 return TETHERING_ERROR_OPERATION_FAILED;
 191         }
 192
 193         return TETHERING_ERROR_NONE;
 194 }
 195
 196 static bool __get_ssid_from_vconf(const char *path, char *ssid, unsigned int size)
 197 {
 198         if (path == NULL || ssid == NULL || size == 0)
 199                 return false;
 200
 201         char *ptr = NULL;
 202         char *ptr_tmp = NULL;
 203
 204         ptr = vconf_get_str(path);
 205         if (ptr == NULL)
 206                 return false;
 207
 208         if (!g_utf8_validate(ptr, -1, (const char **)&ptr_tmp))
 209                 *ptr_tmp = '\0';
 210
 211         g_strlcpy(ssid, ptr, size);
 212         free(ptr);
 213
 214         return true;
 215 }
 216
 217 static tethering_error_e __set_visible(const bool visible)
 218 {
 219         if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, visible ? 0 : 1) < 0) {
 220                 ERR("vconf_set_int is failed\n"); //LCOV_EXCL_LINE
 221                 return TETHERING_ERROR_OPERATION_FAILED;
 222         }
 223
 224         return TETHERING_ERROR_NONE;
 225 }
 226
 227 static tethering_error_e __get_visible(bool *visible)
 228 {
 229         if (visible == NULL) {
 230                 ERR("Invalid param\n"); //LCOV_EXCL_LINE
 231                 return TETHERING_ERROR_INVALID_PARAMETER;
 232         }
 233
 234         int hide = 0;
 235
 236         if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, &hide) < 0) {
 237                 ERR("vconf_get_int is failed\n"); //LCOV_EXCL_LINE
 238                 return TETHERING_ERROR_OPERATION_FAILED;
 239         }
 240
 241         if (hide)
 242                 *visible = false;
 243         else
 244                 *visible = true;
 245         return TETHERING_ERROR_NONE;
 246 }
 247
 248 static unsigned int __generate_initial_passphrase(char *passphrase, unsigned int size)
 249 {
 250         if (passphrase == NULL ||
 251                         size == 0 || size < TETHERING_WIFI_KEY_MIN_LEN + 1)
 252                 return 0;
 253
 254         guint32 rand_int = 0;
 255         int index = 0;
 256
 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;
 260         }
 261         passphrase[index] = '\0';
 262
 263         return index;
 264 }
 265
 266 static tethering_error_e __get_error(int agent_error)
 267 {
 268         tethering_error_e err = TETHERING_ERROR_NONE;
 269
 270         switch (agent_error) {
 271         case MOBILE_AP_ERROR_NONE:
 272                 err = TETHERING_ERROR_NONE;
 273                 break;
 274
 275         //LCOV_EXCL_START
 276         case MOBILE_AP_ERROR_RESOURCE:
 277                 err = TETHERING_ERROR_OUT_OF_MEMORY;
 278                 break;
 279         //LCOV_EXCL_STOP
 280
 281         case MOBILE_AP_ERROR_INTERNAL:
 282                 err = TETHERING_ERROR_OPERATION_FAILED;
 283                 break;
 284
 285         case MOBILE_AP_ERROR_INVALID_PARAM:
 286                 err = TETHERING_ERROR_INVALID_PARAMETER;
 287                 break;
 288
 289         //LCOV_EXCL_START
 290         case MOBILE_AP_ERROR_ALREADY_ENABLED:
 291                 err = TETHERING_ERROR_OPERATION_FAILED;
 292                 break;
 293
 294         case MOBILE_AP_ERROR_NOT_ENABLED:
 295                 err = TETHERING_ERROR_NOT_ENABLED;
 296                 break;
 297
 298         case MOBILE_AP_ERROR_NET_OPEN:
 299                 err = TETHERING_ERROR_OPERATION_FAILED;
 300                 break;
 301
 302         case MOBILE_AP_ERROR_NET_CLOSE:
 303                 err = TETHERING_ERROR_OPERATION_FAILED;
 304                 break;
 305
 306         case MOBILE_AP_ERROR_DHCP:
 307                 err = TETHERING_ERROR_OPERATION_FAILED;
 308                 break;
 309
 310         case MOBILE_AP_ERROR_IN_PROGRESS:
 311                 err = TETHERING_ERROR_OPERATION_FAILED;
 312                 break;
 313
 314         case MOBILE_AP_ERROR_NOT_PERMITTED:
 315                 err = TETHERING_ERROR_NOT_PERMITTED;
 316                 break;
 317
 318         case MOBILE_AP_ERROR_PERMISSION_DENIED:
 319                 err = TETHERING_ERROR_PERMISSION_DENIED;
 320                 break;
 321         //LCOV_EXCL_STOP
 322         default:
 323                 ERR("Not defined error : %d\n", agent_error);
 324                 err = TETHERING_ERROR_OPERATION_FAILED;
 325                 break;
 326         }
 327
 328         return err;
 329 }
 330
 331 //LCOV_EXCL_START
 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)
 335 {
 336         DBG("+\n");
 337
 338         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 339
 340         __tethering_h *th = (__tethering_h *)user_data;
 341         bool opened = false;
 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;
 346         void *data = NULL;
 347         char *buf = NULL;
 348         char *name = NULL;
 349         char *mac = NULL;
 350         char *ip = NULL;
 351         guint timestamp;
 352
 353         memset(&client, 0, sizeof(__tethering_client_h));
 354         g_variant_get(parameters, "(susssu)", &buf, &ap_type, &ip, &mac, &name, &timestamp);
 355
 356         if (!g_strcmp0(buf, "DhcpConnected")) {
 357                 opened = true;
 358         } else if (!g_strcmp0(buf, "DhcpLeaseDeleted")) {
 359                 opened = false;
 360         } else {
 361                 ERR("Unknown event [%s]\n", buf);
 362                 goto DONE;
 363         }
 364
 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;
 371         else if (ap_type == MOBILE_AP_TYPE_P2P)
 372                 type = TETHERING_TYPE_P2P;
 373         else {
 374                 ERR("Not supported tethering type [%d]\n", ap_type);
 375                 goto DONE;
 376         }
 377
 378         ccb = th->changed_cb[type];
 379         if (ccb == NULL)
 380                 goto DONE;
 381         data = th->changed_user_data[type];
 382
 383         client.interface = type;
 384         g_strlcpy(client.ip, ip, sizeof(client.ip));
 385         g_strlcpy(client.mac, mac, sizeof(client.mac));
 386         if (name != NULL)
 387                 client.hostname = g_strdup(name);
 388         client.tm = (time_t)timestamp;
 389
 390         ccb((tethering_client_h)&client, opened, data);
 391         g_free(client.hostname);
 392 DONE:
 393         g_free(buf);
 394         g_free(ip);
 395         g_free(mac);
 396         g_free(name);
 397         DBG("-\n");
 398 }
 399
 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)
 403 {
 404         DBG("+\n");
 405
 406         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 407
 408         __tethering_h *th = (__tethering_h *)user_data;
 409         tethering_type_e type = 0;
 410         tethering_disabled_cb dcb = NULL;
 411         void *data = NULL;
 412         tethering_disabled_cause_e code = TETHERING_DISABLED_BY_NETWORK_CLOSE;
 413
 414         for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
 415                 dcb = th->disabled_cb[type];
 416                 if (dcb == NULL)
 417                         continue;
 418                 data = th->disabled_user_data[type];
 419
 420                 dcb(TETHERING_ERROR_NONE, type, code, data);
 421         }
 422
 423         DBG("-\n");
 424 }
 425 //LCOV_EXCL_STOP
 426
 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)
 430 {
 431         DBG("+\n");
 432
 433         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 434
 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;
 439         void *data = NULL;
 440
 441         ecb = th->enabled_cb[type];
 442         if (ecb == NULL)
 443                 return;
 444         data = th->enabled_user_data[type];
 445
 446         ecb(TETHERING_ERROR_NONE, type, is_requested, data);
 447         DBG("-\n");
 448 }
 449
 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)
 453 {
 454         DBG("+\n");
 455
 456         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 457
 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;
 462         void *data = NULL;
 463         char *buf = NULL;
 464
 465         dcb = th->disabled_cb[type];
 466         if (dcb == NULL)
 467                 return;
 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;
 474
 475         g_free(buf);
 476         dcb(TETHERING_ERROR_NONE, type, code, data);
 477
 478         DBG("-\n");
 479 }
 480
 481 //LCOV_EXCL_START
 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)
 485 {
 486         DBG("+\n");
 487
 488         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 489
 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;
 494         void *data = NULL;
 495
 496         ecb = th->enabled_cb[type];
 497         if (ecb == NULL)
 498                 return;
 499         data = th->enabled_user_data[type];
 500
 501         ecb(TETHERING_ERROR_NONE, type, is_requested, data);
 502         DBG("-\n");
 503 }
 504
 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)
 508 {
 509         DBG("+\n");
 510
 511         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 512
 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;
 517         void *data = NULL;
 518         char *buf = NULL;
 519
 520         dcb = th->disabled_cb[type];
 521         if (dcb == NULL)
 522                 return;
 523         data = th->disabled_user_data[type];
 524
 525         g_variant_get(parameters, "(s)", &buf);
 526         if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
 527                 code = TETHERING_DISABLED_BY_USB_DISCONNECTION;
 528
 529         dcb(TETHERING_ERROR_NONE, type, code, data);
 530         g_free(buf);
 531         DBG("-\n");
 532 }
 533 //LCOV_EXCL_STOP
 534
 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)
 538 {
 539         DBG("+\n");
 540
 541         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 542
 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;
 547         void *data = NULL;
 548
 549         ecb = th->enabled_cb[type];
 550         if (ecb == NULL)
 551                 return;
 552         data = th->enabled_user_data[type];
 553
 554         ecb(TETHERING_ERROR_NONE, type, is_requested, data);
 555         DBG("-\n");
 556 }
 557
 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)
 561 {
 562         DBG("+\n");
 563
 564         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 565
 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;
 570         void *data = NULL;
 571         char *buf = NULL;
 572
 573         dcb = th->disabled_cb[type];
 574         if (dcb == NULL)
 575                 return;
 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;
 582
 583         dcb(TETHERING_ERROR_NONE, type, code, data);
 584
 585         g_free(buf);
 586         DBG("-\n");
 587 }
 588
 589 //LCOV_EXCL_START
 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)
 593 {
 594         DBG("+\n");
 595
 596         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 597
 598         __tethering_h *th = (__tethering_h *)user_data;
 599         tethering_type_e type = 0;
 600         tethering_disabled_cb dcb = NULL;
 601         void *data = NULL;
 602         tethering_disabled_cause_e code = TETHERING_DISABLED_BY_TIMEOUT;
 603
 604         for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
 605                 dcb = th->disabled_cb[type];
 606                 if (dcb == NULL)
 607                         continue;
 608                 data = th->disabled_user_data[type];
 609
 610                 dcb(TETHERING_ERROR_NONE, type, code, data);
 611         }
 612         DBG("-\n");
 613 }
 614
 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)
 618 {
 619         DBG("+\n");
 620
 621         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 622
 623         __tethering_h *th = (__tethering_h *)user_data;
 624         tethering_type_e type = 0;
 625         tethering_disabled_cb dcb = NULL;
 626         void *data = NULL;
 627         tethering_disabled_cause_e code = TETHERING_DISABLED_BY_LOW_BATTERY;
 628
 629         for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
 630                 dcb = th->disabled_cb[type];
 631                 if (dcb == NULL)
 632                         continue;
 633                 data = th->disabled_user_data[type];
 634
 635                 dcb(TETHERING_ERROR_NONE, type, code, data);
 636         }
 637         DBG("-\n");
 638 }
 639
 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)
 643 {
 644         DBG("+\n");
 645
 646         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 647
 648         __tethering_h *th = (__tethering_h *)user_data;
 649         tethering_type_e type = 0;
 650         tethering_disabled_cb dcb = NULL;
 651         void *data = NULL;
 652         tethering_disabled_cause_e code = TETHERING_DISABLED_BY_FLIGHT_MODE;
 653
 654         for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
 655                 dcb = th->disabled_cb[type];
 656                 if (dcb == NULL)
 657                         continue;
 658                 data = th->disabled_user_data[type];
 659
 660                 dcb(TETHERING_ERROR_NONE, type, code, data);
 661         }
 662         DBG("-\n");
 663 }
 664 //LCOV_EXCL_STOP
 665
 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)
 669
 670 {
 671         DBG("+\n");
 672
 673         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 674         __tethering_h *th = (__tethering_h *)user_data;
 675
 676         tethering_wifi_security_type_changed_cb scb = NULL;
 677         void *data = NULL;
 678         tethering_wifi_security_type_e security_type;
 679         char *buf = NULL;
 680
 681         scb = th->security_type_changed_cb;
 682         if (scb == NULL)
 683                 return;
 684
 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;
 693         else {
 694                 SERR("Unknown type : %s\n", buf); //LCOV_EXCL_LINE
 695                 g_free(buf);
 696                 return;
 697         }
 698         g_free(buf);
 699         scb(security_type, data);
 700
 701         return;
 702 }
 703
 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)
 707 {
 708         DBG("+\n"); //LCOV_EXCL_LINE
 709
 710         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 711         __tethering_h *th = (__tethering_h *)user_data;
 712
 713         tethering_wifi_ssid_visibility_changed_cb scb = NULL;
 714         void *data = NULL;
 715         bool visible = false;
 716         char *buf = NULL;
 717
 718         scb = th->ssid_visibility_changed_cb;
 719         if (scb == NULL) {
 720                 DBG("-\n"); //LCOV_EXCL_LINE
 721                 return;
 722         }
 723         g_variant_get(parameters, "(s)", &buf);
 724         data = th->ssid_visibility_user_data;
 725         if (g_strcmp0(buf, SIGNAL_MSG_SSID_VISIBLE) == 0)
 726                 visible = true;
 727
 728         scb(visible, data);
 729         g_free(buf);
 730         DBG("-\n"); //LCOV_EXCL_LINE
 731 }
 732
 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)
 736 {
 737         DBG("+\n"); //LCOV_EXCL_LINE
 738
 739         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 740         __tethering_h *th = (__tethering_h *)user_data;
 741
 742         tethering_wifi_passphrase_changed_cb pcb = NULL;
 743         void *data = NULL;
 744
 745         pcb = th->passphrase_changed_cb;
 746         if (pcb == NULL)
 747                 return;
 748
 749         data = th->passphrase_user_data;
 750
 751         pcb(data);
 752         DBG("-\n"); //LCOV_EXCL_LINE
 753 }
 754
 755 static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
 756                 gpointer user_data)
 757 {
 758         INFO("+\n"); //LCOV_EXCL_LINE
 759
 760         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 761         GError *g_error = NULL;
 762         GVariant *g_var;
 763         guint info;
 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];
 768
 769         if (!_tethering_check_handle((tethering_h)user_data))
 770                 return;
 771
 772         g_var  = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
 773         if (g_error) {
 774                 //LCOV_EXCL_START
 775                 ERR("DBus error [%s]\n", g_error->message);
 776                 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
 777                                 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
 778                         g_error_free(g_error);
 779                         tethering_enable((tethering_h)th, TETHERING_TYPE_WIFI);
 780                         return;
 781                 } else if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
 782                         error = TETHERING_ERROR_PERMISSION_DENIED;
 783                 else
 784                         error = TETHERING_ERROR_OPERATION_FAILED;
 785                 g_error_free(g_error);
 786                 //LCOV_EXCL_STOP
 787         } else {
 788                 g_variant_get(g_var, "(u)", &info);
 789                 error = __get_error(info);
 790         }
 791         retry = 0;
 792
 793         INFO("cfm event : wifi tethering enable info : %d\n", error); //LCOV_EXCL_LINE
 794
 795         sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
 796                         NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_ON].name,
 797                         TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
 798                         sigs[E_SIGNAL_WIFI_TETHER_ON].cb, (gpointer)th, NULL);
 799
 800         if (!ecb) {
 801                 INFO("-\n"); //LCOV_EXCL_LINE
 802                 return;
 803         }
 804         ecb(error, TETHERING_TYPE_WIFI, true, data);
 805         g_variant_unref(g_var);
 806         INFO("-\n"); //LCOV_EXCL_LINE
 807 }
 808
 809 static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
 810                 gpointer user_data)
 811 {
 812         DBG("+\n"); //LCOV_EXCL_LINE
 813         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 814         GError *g_error = NULL;
 815         GVariant *g_var;
 816         guint info;
 817         tethering_error_e error;
 818
 819         __tethering_h *th = (__tethering_h *)user_data;
 820         tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_BT];
 821         void *data = th->enabled_user_data[TETHERING_TYPE_BT];
 822
 823         if (!_tethering_check_handle((tethering_h)user_data))
 824                 return;
 825
 826         g_var  = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
 827         if (g_error) {
 828                 //LCOV_EXCL_START
 829                 ERR("DBus error [%s]\n", g_error->message);
 830                 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
 831                                 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
 832                         g_error_free(g_error);
 833                         tethering_enable((tethering_h)th, TETHERING_TYPE_BT);
 834                         DBG("-\n");
 835                         return;
 836                 }
 837                 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
 838                         error = TETHERING_ERROR_PERMISSION_DENIED;
 839                 else
 840                         error = TETHERING_ERROR_OPERATION_FAILED;
 841                 g_error_free(g_error);
 842                 //LCOV_EXCL_STOP
 843         } else {
 844                 g_variant_get(g_var, "(u)", &info);
 845                 g_variant_unref(g_var);
 846                 error = __get_error(info);
 847         }
 848         retry = 0;
 849
 850         sigs[E_SIGNAL_BT_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
 851                         NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_ON].name,
 852                         TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
 853                         sigs[E_SIGNAL_BT_TETHER_ON].cb, (gpointer)th, NULL);
 854
 855         if (!ecb) {
 856                 DBG("-\n"); //LCOV_EXCL_LINE
 857                 return;
 858         }
 859
 860         ecb(error, TETHERING_TYPE_BT, true, data);
 861         DBG("-\n");
 862 }
 863
 864 //LCOV_EXCL_START
 865 static void __usb_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
 866                                         gpointer user_data)
 867 {
 868         DBG("+\n");
 869
 870         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 871         __tethering_h *th = (__tethering_h *)user_data;
 872         GError *g_error = NULL;
 873         GVariant *g_var;
 874         guint info;
 875         tethering_error_e error;
 876         tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_USB];
 877         void *data = th->enabled_user_data[TETHERING_TYPE_USB];
 878
 879         if (!_tethering_check_handle((tethering_h)user_data))
 880                 return;
 881
 882         g_var  = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
 883         if (g_error) {
 884                 ERR("DBus error [%s]\n", g_error->message);
 885                 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
 886                                 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
 887                         g_error_free(g_error);
 888                         tethering_enable((tethering_h)th, TETHERING_TYPE_USB);
 889                         DBG("-\n");
 890                         return;
 891                 }
 892                 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
 893                         error = TETHERING_ERROR_PERMISSION_DENIED;
 894                 else
 895                         error = TETHERING_ERROR_OPERATION_FAILED;
 896                 g_error_free(g_error);
 897         } else {
 898                 g_variant_get(g_var, "(u)", &info);
 899                 g_variant_unref(g_var);
 900                 error = __get_error(info);
 901         }
 902         retry = 0;
 903
 904         sigs[E_SIGNAL_USB_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
 905                         NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_ON].name,
 906                         TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
 907                         sigs[E_SIGNAL_USB_TETHER_ON].cb, (gpointer)th, NULL);
 908
 909         if (!ecb) {
 910                 DBG("-\n");
 911                 return;
 912         }
 913
 914         ecb(error, TETHERING_TYPE_USB, true, data);
 915         DBG("-\n");
 916 }
 917
 918 static void __p2p_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
 919                                         gpointer user_data)
 920 {
 921         DBG("+\n");
 922
 923         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 924         __tethering_h *th = (__tethering_h *)user_data;
 925         GError *g_error = NULL;
 926         GVariant *g_var;
 927         guint info;
 928         tethering_error_e error;
 929         tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_P2P];
 930         void *data = th->enabled_user_data[TETHERING_TYPE_P2P];
 931
 932         if (!_tethering_check_handle((tethering_h)user_data))
 933                 return;
 934
 935         g_var  = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
 936         if (g_error) {
 937                 ERR("DBus error [%s]\n", g_error->message);
 938                 if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
 939                                 ++retry < TETHERING_ERROR_RECOVERY_MAX) {
 940                         g_error_free(g_error);
 941                         tethering_enable((tethering_h)th, TETHERING_TYPE_P2P);
 942                         DBG("-\n");
 943                         return;
 944                 }
 945                 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
 946                         error = TETHERING_ERROR_PERMISSION_DENIED;
 947                 else
 948                         error = TETHERING_ERROR_OPERATION_FAILED;
 949                 g_error_free(g_error);
 950         } else {
 951                 g_variant_get(g_var, "(u)", &info);
 952                 g_variant_unref(g_var);
 953                 error = __get_error(info);
 954         }
 955         retry = 0;
 956
 957         if (!ecb) {
 958                 DBG("-\n");
 959                 return;
 960         }
 961
 962         ecb(error, TETHERING_TYPE_P2P, true, data);
 963         DBG("-\n");
 964 }
 965 //LCOV_EXCL_STOP
 966
 967 static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res,
 968                 gpointer user_data)
 969 {
 970         INFO("+\n"); //LCOV_EXCL_LINE
 971
 972         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
 973         GError *g_error = NULL;
 974         GVariant *g_var;
 975         guint info, event_type;
 976         tethering_error_e error;
 977         tethering_type_e type;
 978         tethering_h tethering = (tethering_h)user_data;
 979         __tethering_h *th = (__tethering_h *)tethering;
 980         tethering_disabled_cause_e code = TETHERING_DISABLED_BY_REQUEST;
 981         tethering_disabled_cb dcb = NULL;
 982         void *data = NULL;
 983
 984         if (!_tethering_check_handle((tethering_h)user_data))
 985                 return;
 986
 987         g_var  = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
 988         if (g_error) {
 989                 //LCOV_EXCL_START
 990                 ERR("DBus error [%s]\n", g_error->message);
 991                 g_error_free(g_error);
 992                 return;
 993                 //LCOV_EXCL_STOP
 994         }
 995         g_variant_get(g_var, "(uu)", &event_type, &info);
 996         INFO("cfm event : %d info : %d\n", event_type, info);
 997         g_variant_unref(g_var);
 998         error = __get_error(info);
 999         INFO("cfm event : %d info : %d\n", event_type, error);
1000         switch (event_type) {
1001         case MOBILE_AP_DISABLE_WIFI_TETHERING_CFM:
1002                 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1003                                 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_OFF].name,
1004                                 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1005                                 sigs[E_SIGNAL_WIFI_TETHER_OFF].cb, (gpointer)th, NULL);
1006
1007                 type = TETHERING_TYPE_WIFI;
1008                 dcb = th->disabled_cb[type];
1009                 data = th->disabled_user_data[type];
1010                 if (dcb)
1011                         dcb(error, type, code, data);
1012                 break;
1013
1014         case MOBILE_AP_DISABLE_BT_TETHERING_CFM:
1015                 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1016                                 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_OFF].name,
1017                                 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1018                                 sigs[E_SIGNAL_BT_TETHER_OFF].cb, (gpointer)th, NULL);
1019
1020                 type = TETHERING_TYPE_BT;
1021                 dcb = th->disabled_cb[type];
1022                 data = th->disabled_user_data[type];
1023                 if (dcb)
1024                         dcb(error, type, code, data);
1025                 break;
1026
1027         //LCOV_EXCL_START
1028         case MOBILE_AP_DISABLE_USB_TETHERING_CFM:
1029                 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1030                                 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
1031                                 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1032                                 sigs[E_SIGNAL_USB_TETHER_OFF].cb, (gpointer)th, NULL);
1033
1034                 type = TETHERING_TYPE_USB;
1035                 dcb = th->disabled_cb[type];
1036                 data = th->disabled_user_data[type];
1037                 if (dcb)
1038                         dcb(error, type, code, data);
1039                 break;
1040
1041         case MOBILE_AP_DISABLE_P2P_TETHERING_CFM:
1042                 type = TETHERING_TYPE_P2P;
1043                 dcb = th->disabled_cb[type];
1044                 data = th->disabled_user_data[type];
1045                 if (dcb)
1046                         dcb(error, type, code, data);
1047                 break;
1048
1049         case MOBILE_AP_DISABLE_CFM:
1050
1051                 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1052                                 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_OFF].name,
1053                                 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1054                                 sigs[E_SIGNAL_WIFI_TETHER_OFF].cb, (gpointer)th, NULL);
1055                 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1056                                 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_BT_TETHER_OFF].name,
1057                                 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1058                                 sigs[E_SIGNAL_BT_TETHER_OFF].cb, (gpointer)th, NULL);
1059                 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
1060                                 NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
1061                                 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1062                                 sigs[E_SIGNAL_USB_TETHER_OFF].cb, (gpointer)th, NULL);
1063
1064                 for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
1065                         dcb = th->disabled_cb[type];
1066                         if (dcb == NULL)
1067                                 continue;
1068                         data = th->disabled_user_data[type];
1069
1070                         dcb(error, type, code, data);
1071                 }
1072                 break;
1073
1074         default:
1075                 ERR("Invalid event\n");
1076                 break;
1077         //LCOV_EXCL_STOP
1078         }
1079         INFO("-\n"); //LCOV_EXCL_LINE
1080 }
1081
1082 static void __get_data_usage_cb(GObject *source_object, GAsyncResult *res,
1083                                 gpointer user_data)
1084 {
1085         DBG("+\n");
1086
1087         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1088
1089         GError *g_error = NULL;
1090         GVariant *g_var;
1091         guint event_type;
1092         guint64 tx_bytes, rx_bytes;
1093         __tethering_h *th = (__tethering_h *)user_data;
1094         tethering_error_e tethering_error = TETHERING_ERROR_NONE;
1095         bool flag = false;
1096
1097         g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1098         if (g_error) {
1099                 //LCOV_EXCL_START
1100                 ERR("DBus fail [%s]\n", g_error->message);
1101                 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1102                         tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1103                 else
1104                         tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1105
1106                 flag = true;
1107                 //LCOV_EXCL_STOP
1108         }
1109         if (th->data_usage_cb == NULL) {
1110                 ERR("There is no data_usage_cb\n"); //LCOV_EXCL_LINE
1111                 return;
1112         }
1113         if (flag) {
1114                 th->data_usage_cb(tethering_error, 0LL, 0LL, th->data_usage_user_data);
1115         } else {
1116                 g_variant_get(g_var, "(utt)", &event_type, &tx_bytes, &rx_bytes);
1117                 th->data_usage_cb(TETHERING_ERROR_NONE,
1118                         rx_bytes, tx_bytes, th->data_usage_user_data);
1119                 g_variant_unref(g_var);
1120         }
1121         th->data_usage_cb = NULL;
1122         th->data_usage_user_data = NULL;
1123
1124         DBG("-\n");
1125 }
1126
1127 static void __settings_reloaded_cb(GObject *source_object, GAsyncResult *res,
1128                 gpointer user_data)
1129 {
1130         DBG("+\n");
1131
1132         _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
1133         GError *g_error = NULL;
1134         GVariant *g_var;
1135         guint info;
1136         __tethering_h *th = (__tethering_h *)user_data;
1137         tethering_error_e tethering_error = TETHERING_ERROR_NONE;
1138
1139         g_var  = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error);
1140         if (g_error) {
1141                 ERR("DBus fail [%s]\n", g_error->message); //LCOV_EXCL_LINE
1142                 if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
1143                         tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
1144                 else
1145                         tethering_error = TETHERING_ERROR_OPERATION_FAILED;
1146                 g_error_free(g_error);
1147         }
1148         if (th->settings_reloaded_cb == NULL) {
1149                 DBG("There is no settings_reloaded_cb\n-\n");
1150                 return;
1151         }
1152         g_variant_get(g_var, "(u)", &info);
1153         if (tethering_error == TETHERING_ERROR_NONE)
1154                 tethering_error = __get_error(info);
1155         g_variant_unref(g_var);
1156
1157         th->settings_reloaded_cb(tethering_error,
1158                         th->settings_reloaded_user_data);
1159
1160         th->settings_reloaded_cb = NULL;
1161         th->settings_reloaded_user_data = NULL;
1162         DBG("-\n");
1163 }
1164
1165 static void __connect_signals(tethering_h tethering)
1166 {
1167         DBG("+\n");
1168         _retm_if(tethering == NULL, "parameter(tethering) is NULL\n");
1169
1170         __tethering_h *th = (__tethering_h *)tethering;
1171         GDBusConnection *connection = th->client_bus;
1172         int i = 0;
1173
1174         for (i = E_SIGNAL_NET_CLOSED; i < E_SIGNAL_MAX; i++) {
1175                 sigs[i].sig_id = g_dbus_connection_signal_subscribe(connection,
1176                                 NULL, TETHERING_SERVICE_INTERFACE, sigs[i].name,
1177                                 TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
1178                                 sigs[i].cb, tethering, NULL);
1179         }
1180         DBG("-\n");
1181 }
1182
1183 static void __disconnect_signals(tethering_h tethering)
1184 {
1185         DBG("+\n");
1186
1187         _retm_if(tethering == NULL, "parameter(tethering) is NULL\n");
1188
1189         __tethering_h *th = (__tethering_h *)tethering;
1190         GDBusConnection *connection = th->client_bus;
1191
1192         int i = 0;
1193
1194         for (i = E_SIGNAL_NET_CLOSED; i < E_SIGNAL_MAX; i++)
1195                 g_dbus_connection_signal_unsubscribe(connection, sigs[i].sig_id);
1196         DBG("-\n");
1197 }
1198
1199
1200
1201 static bool __get_intf_name(tethering_type_e type, char *buf, unsigned int len)
1202 {
1203         _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1204
1205         switch (type) {
1206         //LCOV_EXCL_START
1207         case TETHERING_TYPE_USB:
1208                 g_strlcpy(buf, TETHERING_USB_IF, len);
1209                 break;
1210         //LCOV_EXCL_STOP
1211         case TETHERING_TYPE_WIFI:
1212                 g_strlcpy(buf, TETHERING_WIFI_IF, len);
1213                 break;
1214
1215         case TETHERING_TYPE_BT:
1216                 g_strlcpy(buf, TETHERING_BT_IF, len);
1217                 break;
1218
1219         //LCOV_EXCL_START
1220         default:
1221                 ERR("Not supported type : %d\n", type);
1222                 return false;
1223         //LCOV_EXCL_STOP
1224         }
1225         return true;
1226 }
1227
1228 static bool __get_gateway_addr(tethering_type_e type, char *buf, unsigned int len)
1229 {
1230         _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1231
1232         switch (type) {
1233         //LCOV_EXCL_START
1234         case TETHERING_TYPE_USB:
1235                 g_strlcpy(buf, TETHERING_USB_GATEWAY, len);
1236                 break;
1237         //LCOV_EXCL_STOP
1238         case TETHERING_TYPE_WIFI:
1239                 g_strlcpy(buf, TETHERING_WIFI_GATEWAY, len);
1240                 break;
1241
1242         case TETHERING_TYPE_BT:
1243                 g_strlcpy(buf, TETHERING_BT_GATEWAY, len);
1244                 break;
1245         //LCOV_EXCL_START
1246         default:
1247                 ERR("Not supported type : %d\n", type);
1248                 return false;
1249         //LCOV_EXCL_STOP
1250         }
1251         return true;
1252 }
1253
1254 static int __get_common_ssid(char *ssid, unsigned int size)
1255 {
1256         if (ssid == NULL) {
1257                 ERR("ssid is null\n"); //LCOV_EXCL_LINE
1258                 return TETHERING_ERROR_INVALID_PARAMETER;
1259         }
1260
1261         char *ptr = NULL;
1262         char *ptr_tmp = NULL;
1263
1264         ptr = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
1265         if (ptr == NULL) {
1266                 ERR("vconf_get_str is failed and set default ssid");
1267                 g_strlcpy(ssid, TETHERING_DEFAULT_SSID, size);
1268         } else
1269                 g_strlcpy(ssid, ptr, size);
1270
1271         free(ptr);
1272
1273         if (!g_utf8_validate(ssid, -1, (const char **)&ptr_tmp))
1274                 *ptr_tmp = '\0';
1275
1276         return TETHERING_ERROR_NONE;
1277 }
1278
1279 static bool __get_wifi_mode_type(tethering_wifi_mode_type_e type, char **buf)
1280 {
1281         _retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
1282
1283         switch (type) {
1284         case TETHERING_WIFI_MODE_TYPE_B:
1285                 *buf = g_strdup("b");
1286                 break;
1287         case TETHERING_WIFI_MODE_TYPE_G:
1288                 *buf = g_strdup("g");
1289                 break;
1290         case TETHERING_WIFI_MODE_TYPE_A:
1291                 *buf = g_strdup("a");
1292                 break;
1293         case TETHERING_WIFI_MODE_TYPE_AD:
1294                 *buf = g_strdup("ad");
1295                 break;
1296         default:
1297                 ERR("Not supported type : %d\n", type);
1298                 return false;
1299         }
1300         return true;
1301 }
1302
1303 static int __prepare_wifi_settings(tethering_h tethering, _softap_settings_t *set)
1304 {
1305         INFO("+\n");
1306
1307         __tethering_h *th = (__tethering_h *)tethering;
1308         tethering_error_e ret = TETHERING_ERROR_NONE;
1309         char *ptr = NULL;
1310
1311         if (th == NULL || set == NULL) {
1312                 ERR("null parameter\n-\n"); //LCOV_EXCL_LINE
1313                 return TETHERING_ERROR_INVALID_PARAMETER;
1314         }
1315
1316         if (th->ssid == NULL)
1317                 __get_common_ssid(set->ssid, sizeof(set->ssid));
1318         else
1319                 g_strlcpy(set->ssid, th->ssid, sizeof(set->ssid));
1320
1321         ret = __get_security_type(&set->sec_type);
1322         if (ret != TETHERING_ERROR_NONE)
1323                 set->sec_type = th->sec_type;
1324
1325         ret = __get_visible(&set->visibility);
1326         if (ret != TETHERING_ERROR_NONE)
1327                 set->visibility = th->visibility;
1328
1329         set->mac_filter = th->mac_filter;
1330         set->max_connected = th->wifi_max_connected;
1331         set->channel = th->channel;
1332
1333         __get_wifi_mode_type(th->mode_type, &ptr);
1334         if (ptr == NULL) {
1335                 g_strlcpy(set->mode, "", sizeof(set->mode));
1336         } else {
1337                 g_strlcpy(set->mode, ptr, sizeof(set->mode));
1338                 free(ptr);
1339         }
1340
1341         if (set->sec_type == TETHERING_WIFI_SECURITY_TYPE_NONE) {
1342                 g_strlcpy(set->key, "", sizeof(set->key));
1343         } else {
1344                 GDBusProxy *proxy = th->client_bus_proxy;
1345                 GVariant *parameters;
1346                 GError *error = NULL;
1347                 char *passphrase = NULL;
1348                 unsigned int len = 0;
1349
1350                 parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_passphrase",
1351                                 NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
1352
1353                 if (error) {
1354                         //LCOV_EXCL_START
1355                         ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
1356
1357                         if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
1358                                 ret = TETHERING_ERROR_PERMISSION_DENIED;
1359                         else
1360                                 ret = TETHERING_ERROR_OPERATION_FAILED;
1361
1362                         g_error_free(error);
1363                         return ret;
1364                         //LCOV_EXCL_STOP
1365                 }
1366
1367                 if (parameters != NULL) {
1368                         g_variant_get(parameters, "(siu)", &passphrase, &len, &ret);
1369                         g_variant_unref(parameters);
1370                 }
1371
1372                 g_strlcpy(set->key, passphrase, sizeof(set->key));
1373         }
1374
1375         INFO("ssid: %s security: %d mode: %s channel: %d visibility: %s\n",
1376                  set->ssid, set->sec_type, set->mode, set->channel,
1377                  (set->visibility) ? "true" : "false");
1378         INFO("-\n");
1379         return TETHERING_ERROR_NONE;
1380 }
1381
1382 static bool __check_precondition(tethering_type_e type)
1383 {
1384         int dnet_status = 0;
1385         int cellular_state = 0;
1386
1387         /* data network through cellular */
1388         vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &cellular_state);
1389         if (cellular_state == VCONFKEY_NETWORK_CELLULAR_ON) {
1390                 INFO("Data Network can be connected later");
1391                 return TRUE;
1392         }
1393
1394         /* data network status */
1395         vconf_get_int(VCONFKEY_NETWORK_STATUS, &dnet_status);
1396         if ((dnet_status == VCONFKEY_NETWORK_WIFI
1397                         && type != TETHERING_TYPE_WIFI)
1398                 || dnet_status == VCONFKEY_NETWORK_ETHERNET)
1399                 return TRUE;
1400
1401         ERR("Network is not available!");
1402         return FALSE;
1403 }
1404
1405 /**
1406  * @internal
1407  * @brief  Creates the handle of tethering.
1408  * @since_tizen 2.3
1409  * @privlevel platform
1410  * @privilege http://tizen.org/privilege/tethering.admin
1411  * @remarks  The @a tethering must be released tethering_destroy() by you.
1412  * @param[out]  tethering  A handle of a new mobile ap handle on success
1413  * @return  0 on success, otherwise a negative error value.
1414  * @retval  #TETHERING_ERROR_NONE  Successful
1415  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
1416  * @retval  #TETHERING_ERROR_OUT_OF_MEMORY  Out of memory
1417  * @retval  #TETHERING_ERROR_NOT_SUPPORT_API  API is not supported
1418  * @see  tethering_destroy()
1419  */
1420 API int tethering_create(tethering_h *tethering)
1421 {
1422         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1423         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1424                         "parameter(tethering) is NULL\n");
1425         INFO("+\n");
1426
1427         __tethering_h *th = NULL;
1428         GError *error = NULL;
1429         char ssid[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
1430
1431         th = (__tethering_h *)malloc(sizeof(__tethering_h));
1432
1433         _retvm_if(th == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
1434                         "malloc is failed\n");
1435         memset(th, 0x00, sizeof(__tethering_h));
1436         th->sec_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK;
1437         th->visibility = true;
1438         th->mac_filter = false;
1439         th->channel = TETHERING_WIFI_CHANNEL;
1440         th->mode_type = TETHERING_WIFI_MODE_TYPE_G;
1441         th->wifi_max_connected = TETHERING_WIFI_MAX_STA;
1442
1443         if (__generate_initial_passphrase(th->passphrase,
1444                         sizeof(th->passphrase)) == 0) {
1445                 //LCOV_EXCL_START
1446                 ERR("random passphrase generation failed\n");
1447                 free(th);
1448                 return TETHERING_ERROR_OPERATION_FAILED;
1449                 //LCOV_EXCL_STOP
1450         }
1451
1452         if (__get_common_ssid(ssid, sizeof(ssid)) != TETHERING_ERROR_NONE) {
1453                 //LCOV_EXCL_START
1454                 ERR("common ssid get failed\n");
1455                 free(th);
1456                 return TETHERING_ERROR_OPERATION_FAILED;
1457                 //LCOV_EXCL_STOP
1458         }
1459
1460 #if !GLIB_CHECK_VERSION(2, 36, 0)
1461         g_type_init();
1462 #endif
1463         GCancellable *cancellable = g_cancellable_new();
1464         th->client_bus = g_bus_get_sync(DBUS_BUS_SYSTEM, cancellable, &error);
1465         if (error) {
1466                 //LCOV_EXCL_START
1467                 ERR("Couldn't connect to the System bus[%s]", error->message);
1468                 g_error_free(error);
1469                 g_cancellable_cancel(cancellable);
1470                 g_object_unref(cancellable);
1471                 free(th);
1472                 return TETHERING_ERROR_OPERATION_FAILED;
1473                 //LCOV_EXCL_STOP
1474         }
1475         th->cancellable = cancellable;
1476
1477         th->client_bus_proxy = g_dbus_proxy_new_sync(th->client_bus, G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION,
1478                         NULL, TETHERING_SERVICE_NAME, TETHERING_SERVICE_OBJECT_PATH,
1479                         TETHERING_SERVICE_INTERFACE, th->cancellable, &error);
1480         if (!th->client_bus_proxy) {
1481                 //LCOV_EXCL_START
1482                 if (error)
1483                         ERR("Couldn't create the proxy object because of %s\n", error->message);
1484                 g_cancellable_cancel(th->cancellable);
1485                 g_object_unref(th->cancellable);
1486                 g_object_unref(th->client_bus);
1487                 free(th);
1488                 return TETHERING_ERROR_OPERATION_FAILED;
1489                 //LCOV_EXCL_STOP
1490         }
1491
1492         __connect_signals((tethering_h)th);
1493
1494         *tethering = (tethering_h)th;
1495         _tethering_add_handle(th);
1496         INFO("Tethering Handle : %p\n", th);
1497         INFO("-\n");
1498         return TETHERING_ERROR_NONE;
1499 }
1500
1501 /**
1502  * @internal
1503  * @brief  Destroys the handle of tethering.
1504  * @since_tizen 2.3
1505  * @privlevel platform
1506  * @privilege http://tizen.org/privilege/tethering.admin
1507  * @param[in]  tethering  The handle of tethering
1508  * @return  0 on success, otherwise a negative error value.
1509  * @retval  #TETHERING_ERROR_NONE  Successful
1510  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
1511  * @see  tethering_create()
1512  */
1513 API int tethering_destroy(tethering_h tethering)
1514 {
1515         INFO("+\n");
1516         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1517         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1518                         "parameter(tethering) is NULL\n");
1519
1520         __tethering_h *th = (__tethering_h *)tethering;
1521
1522         INFO("Tethering Handle : %p\n", th);
1523
1524         __disconnect_signals(tethering);
1525         _tethering_remove_handle(th);
1526
1527         if (th->ssid)
1528                 free(th->ssid);
1529
1530         g_object_unref(th->cancellable);
1531         g_object_unref(th->client_bus_proxy);
1532         g_object_unref(th->client_bus);
1533         memset(th, 0x00, sizeof(__tethering_h));
1534
1535         free(th);
1536
1537         INFO("-\n");
1538         return TETHERING_ERROR_NONE;
1539 }
1540
1541 /**
1542  * @internal
1543  * @brief Enables the tethering, asynchronously.
1544  * @since_tizen 2.3
1545  * @privlevel platform
1546  * @privilege http://tizen.org/privilege/tethering.admin
1547  * @param[in]  tethering  The handle of tethering
1548  * @param[in]  type  The type of tethering
1549  * @return 0 on success, otherwise negative error value.
1550  * @retval  #TETHERING_ERROR_NONE  Successful
1551  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
1552  * @post tethering_enabled_cb() will be invoked.
1553  * @see  tethering_is_enabled()
1554  * @see  tethering_disable()
1555  */
1556 API int tethering_enable(tethering_h tethering, tethering_type_e type)
1557 {
1558         INFO("+ type :  %d\n", type);
1559         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1560         if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1561         else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1562         else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1563
1564         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1565                         "parameter(tethering) is NULL\n");
1566
1567         tethering_error_e ret = TETHERING_ERROR_NONE;
1568         __tethering_h *th = (__tethering_h *)tethering;
1569         GDBusProxy *proxy = th->client_bus_proxy;
1570         GDBusConnection *connection = th->client_bus;
1571
1572         g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
1573
1574         if (__check_precondition(type) == FALSE) {
1575                 //LCOV_EXCL_START
1576                 INFO("-\n");
1577                 return TETHERING_ERROR_OPERATION_FAILED;
1578                 //LCOV_EXCL_STOP
1579         }
1580
1581         switch (type) {
1582         //LCOV_EXCL_START
1583         case TETHERING_TYPE_USB:
1584                 g_dbus_connection_signal_unsubscribe(connection,
1585                                 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1586
1587                 g_dbus_proxy_call(proxy, "enable_usb_tethering", NULL,
1588                                 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1589                                 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1590                 break;
1591         //LCOV_EXCL_STOP
1592
1593         case TETHERING_TYPE_WIFI: {
1594                 _softap_settings_t set = {"", "", "", 0, false};
1595
1596                 ret = __prepare_wifi_settings(tethering, &set);
1597                 if (ret != TETHERING_ERROR_NONE) {
1598                         //LCOV_EXCL_START
1599                         ERR("softap settings initialization failed\n");
1600                         DBG("-\n");
1601                         return TETHERING_ERROR_OPERATION_FAILED;
1602                         //LCOV_EXCL_STOP
1603                 }
1604                 g_dbus_connection_signal_unsubscribe(connection,
1605                                 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1606
1607                 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1608                                 g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, TETHERING_ADDRESS_FAMILY_IPV4),
1609                                 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1610                                 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1611                 break;
1612         }
1613
1614         case TETHERING_TYPE_BT:
1615                 g_dbus_connection_signal_unsubscribe(connection,
1616                                 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1617
1618                 g_dbus_proxy_call(proxy, "enable_bt_tethering",
1619                                 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1620                                 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1621                                 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1622
1623                 break;
1624
1625         //LCOV_EXCL_START
1626         case TETHERING_TYPE_P2P: {
1627                 _softap_settings_t p2p_set = {"", "", "", 0, false};
1628                 ret = __prepare_wifi_settings(tethering, &p2p_set);
1629                 if (ret != TETHERING_ERROR_NONE) {
1630                         ERR("p2p settings initialization failed\n");
1631                         DBG("-\n");
1632                         return TETHERING_ERROR_OPERATION_FAILED;
1633                 }
1634
1635                 g_dbus_proxy_call(proxy, "enable_p2p_tethering",
1636                                 g_variant_new("(ssi)", p2p_set.ssid, p2p_set.key, p2p_set.channel),
1637                                 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1638                                 (GAsyncReadyCallback) __p2p_enabled_cfm_cb, (gpointer)tethering);
1639                 break;
1640         }
1641
1642         case TETHERING_TYPE_ALL: {
1643                 _softap_settings_t set = {"", "", "", 0, false};
1644
1645                 ret = __prepare_wifi_settings(tethering, &set);
1646                 if (ret != TETHERING_ERROR_NONE) {
1647                         ERR("softap settings initialization failed\n");
1648                         return TETHERING_ERROR_OPERATION_FAILED;
1649                 }
1650
1651                 /* TETHERING_TYPE_USB */
1652                 g_dbus_connection_signal_unsubscribe(connection,
1653                                 sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
1654
1655                 g_dbus_proxy_call(proxy, "enable_usb_tethering", NULL,
1656                                 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1657                                 (GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
1658
1659                 /* TETHERING_TYPE_WIFI */
1660                 g_dbus_connection_signal_unsubscribe(connection,
1661                                 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1662
1663                 g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1664                                 g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode,
1665                                 set.channel, set.visibility, set.mac_filter, set.max_connected,
1666                                 set.sec_type, TETHERING_ADDRESS_FAMILY_IPV4),
1667                                 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1668                                 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1669
1670                 /* TETHERING_TYPE_BT */
1671                 g_dbus_connection_signal_unsubscribe(connection,
1672                                 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1673
1674                 g_dbus_proxy_call(proxy, "enable_bt_tethering",
1675                                 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1676                                 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1677                                 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1678                 break;
1679         }
1680         default:
1681                 ERR("Unknown type : %d\n", type);
1682
1683                 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1684
1685                 DBG("-\n");
1686                 return TETHERING_ERROR_INVALID_PARAMETER;
1687         }
1688         //LCOV_EXCL_STOP
1689
1690         g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1691         INFO("-\n");
1692         return TETHERING_ERROR_NONE;
1693 }
1694
1695 API int tethering_ipv6_enable(tethering_h tethering, tethering_type_e type)
1696 {
1697         DBG("+ type :  %d\n", type);
1698         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1699         if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1700         else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1701         else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1702
1703         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1704                         "parameter(tethering) is NULL\n");
1705
1706         __tethering_h *th = (__tethering_h *)tethering;
1707         GDBusProxy *proxy = th->client_bus_proxy;
1708         GDBusConnection *connection = th->client_bus;
1709         int ret = 0;
1710
1711         g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
1712
1713         if (__check_precondition(type) == FALSE) {
1714                 //LCOV_EXCL_START
1715                 DBG("-\n");
1716                 return TETHERING_ERROR_OPERATION_FAILED;
1717                 //LCOV_EXCL_STOP
1718         }
1719
1720         switch (type) {
1721         case TETHERING_TYPE_WIFI: {
1722                 _softap_settings_t set = {"", "", "", 0, false, false, 0, 0};
1723
1724                 ret = __prepare_wifi_settings(tethering, &set);
1725                 if (ret != TETHERING_ERROR_NONE) {
1726                         ERR("softap settings initialization failed\n");
1727                         DBG("-\n");
1728                         return TETHERING_ERROR_OPERATION_FAILED;
1729                 }
1730                 g_dbus_connection_signal_unsubscribe(connection,
1731                                 sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
1732                         g_dbus_proxy_call(proxy, "enable_wifi_tethering",
1733                                 g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, TETHERING_ADDRESS_FAMILY_IPV6),
1734                                 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1735                                 (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
1736                 break;
1737          }
1738         case TETHERING_TYPE_BT: {
1739                 g_dbus_connection_signal_unsubscribe(connection,
1740                                 sigs[E_SIGNAL_BT_TETHER_ON].sig_id);
1741
1742                 /* For TEST */
1743                 g_dbus_proxy_call(proxy, "enable_bt_tethering", g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1744                                 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1745                                 (GAsyncReadyCallback) __bt_enabled_cfm_cb, (gpointer)tethering);
1746
1747                 break;
1748         }
1749
1750         default: {
1751                 ERR("Unknown type : %d\n", type);
1752
1753                 g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1754
1755                 DBG("-\n");
1756                 return TETHERING_ERROR_INVALID_PARAMETER;
1757         }
1758         }
1759
1760         g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
1761         DBG("-\n");
1762         return TETHERING_ERROR_NONE;
1763 }
1764
1765 API int tethering_ipv6_disable(tethering_h tethering, tethering_type_e type)
1766 {
1767         DBG("+ type :  %d\n", type);
1768         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1769         if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1770         else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1771         else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1772
1773         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1774                         "parameter(tethering) is NULL\n");
1775
1776         __tethering_h *th = (__tethering_h *)tethering;
1777         GDBusProxy *proxy = th->client_bus_proxy;
1778         GDBusConnection *connection = th->client_bus;
1779
1780         switch (type) {
1781         case TETHERING_TYPE_WIFI:
1782                 DBG("Disable wifi tethering..");
1783                 g_dbus_connection_signal_unsubscribe(connection,
1784                                 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1785
1786                 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1787                                 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1788                                 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1789                                 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1790                 break;
1791         case TETHERING_TYPE_BT:
1792                 g_dbus_connection_signal_unsubscribe(connection,
1793                                 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1794
1795                 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1796                                 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV6),
1797                                 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1798                                 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1799                 break;
1800
1801         default:
1802                 ERR("Not supported tethering type [%d]\n", type);
1803                 DBG("-\n");
1804                 return TETHERING_ERROR_INVALID_PARAMETER;
1805         }
1806         DBG("-\n");
1807         return TETHERING_ERROR_NONE;
1808 }
1809 /**
1810  * @internal
1811  * @brief Disables the tethering, asynchronously.
1812  * @since_tizen 2.3
1813  * @privlevel platform
1814  * @privilege http://tizen.org/privilege/tethering.admin
1815  * @param[in]  tethering  The handle of tethering
1816  * @param[in]  type  The type of tethering
1817  * @return 0 on success, otherwise negative error value.
1818  * @retval  #TETHERING_ERROR_NONE  Successful
1819  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
1820  * @post tethering_disabled_cb() will be invoked.
1821  * @see  tethering_is_enabled()
1822  * @see  tethering_enable()
1823  */
1824 API int tethering_disable(tethering_h tethering, tethering_type_e type)
1825 {
1826         INFO("+ type :  %d\n", type);
1827         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1828         if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
1829         else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1830         else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
1831
1832         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1833                         "parameter(tethering) is NULL\n");
1834
1835         __tethering_h *th = (__tethering_h *)tethering;
1836         GDBusProxy *proxy = th->client_bus_proxy;
1837         GDBusConnection *connection = th->client_bus;
1838
1839         switch (type) {
1840         //LCOV_EXCL_START
1841         case TETHERING_TYPE_USB:
1842                 g_dbus_connection_signal_unsubscribe(connection,
1843                                 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1844
1845                 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1846                                 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1847                                 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1848
1849                 break;
1850         //LCOV_EXCL_STOP
1851
1852         case TETHERING_TYPE_WIFI:
1853
1854                 g_dbus_connection_signal_unsubscribe(connection,
1855                                 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1856
1857                 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1858                                 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1859                                 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1860                                 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1861                 break;
1862
1863         case TETHERING_TYPE_BT:
1864
1865                 g_dbus_connection_signal_unsubscribe(connection,
1866                                 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1867
1868                 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1869                                 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1870                                 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1871                                 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1872                 break;
1873
1874         //LCOV_EXCL_START
1875         case TETHERING_TYPE_P2P:
1876                 g_dbus_proxy_call(proxy, "disable_p2p_tethering",
1877                                 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1878                                 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1879                 break;
1880
1881         case TETHERING_TYPE_ALL:
1882                 g_dbus_connection_signal_unsubscribe(connection,
1883                                 sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
1884
1885                 g_dbus_proxy_call(proxy, "disable_usb_tethering",
1886                                 NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1887                                 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1888
1889                 g_dbus_connection_signal_unsubscribe(connection,
1890                                 sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
1891
1892                 g_dbus_proxy_call(proxy, "disable_wifi_tethering",
1893                                 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1894                                 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1895                                 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1896
1897                 g_dbus_connection_signal_unsubscribe(connection,
1898                                 sigs[E_SIGNAL_BT_TETHER_OFF].sig_id);
1899
1900                 g_dbus_proxy_call(proxy, "disable_bt_tethering",
1901                                 g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
1902                                 G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
1903                                 (GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
1904                 break;
1905
1906         default:
1907                 ERR("Not supported tethering type [%d]\n", type);
1908                 DBG("-\n");
1909                 return TETHERING_ERROR_INVALID_PARAMETER;
1910         //LCOV_EXCL_STOP
1911         }
1912         INFO("-\n");
1913         return TETHERING_ERROR_NONE;
1914 }
1915
1916 /**
1917  * @internal
1918  * @brief  Checks whetehr the tethering is enabled or not.
1919  * @since_tizen 2.3
1920  * @privlevel platform
1921  * @privilege http://tizen.org/privilege/tethering.admin
1922  * @param[in]  tethering  The handle of tethering
1923  * @param[in]  type  The type of tethering
1924  * @return  @c true if tethering is enabled, \n @c false if tethering is disabled.
1925  */
1926 API bool tethering_is_enabled(tethering_h tethering, tethering_type_e type)
1927 {
1928         INFO("+ type :  %d\n", type);
1929         int is_on = 0;
1930         int vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_NONE;
1931
1932         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1933
1934         if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &is_on) != 0)
1935                 return FALSE;
1936
1937         switch (type) {
1938         case TETHERING_TYPE_USB:
1939                 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_USB;
1940                 break;
1941
1942         case TETHERING_TYPE_WIFI:
1943                 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI;
1944                 break;
1945
1946         case TETHERING_TYPE_BT:
1947                 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_BT;
1948                 break;
1949
1950         case TETHERING_TYPE_P2P:
1951                 vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_P2P;
1952                 break;
1953
1954         default:
1955                 ERR("Not supported type : %d\n", type);
1956                 break;
1957         }
1958         INFO("- enabled:  %s\n", (is_on & vconf_type) ? "true" : "false");
1959         return is_on & vconf_type ? true : false;
1960 }
1961
1962 /**
1963  * @internal
1964  * @brief  Gets the MAC address of local device as "FC:A1:3E:D6:B1:B1".
1965  * @since_tizen 2.3
1966  * @privlevel platform
1967  * @privilege http://tizen.org/privilege/tethering.admin
1968  * @remarks @a mac_address must be released with free() by you.
1969  * @param[in]  tethering  The handle of tethering
1970  * @param[in]  type  The type of tethering
1971  * @param[out]  mac_address  The MAC address
1972  * @return  0 on success, otherwise a negative error value.
1973  * @retval  #TETHERING_ERROR_NONE  Successful
1974  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
1975  * @retval  #TETHERING_ERROR_OUT_OF_MEMORY  Out of memory
1976  * @retval  #TETHERING_ERROR_OPERATION_FAILED  Operation failed
1977  * @retval  #TETHERING_ERROR_NOT_ENABLED  Not enabled
1978  * @pre  tethering must be enabled.
1979  * @see  tethering_is_enabled()
1980  * @see  tethering_enable()
1981  */
1982 API int tethering_get_mac_address(tethering_h tethering, tethering_type_e type, char **mac_address)
1983 {
1984         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
1985         if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE); //LCOV_EXCL_LINE
1986         else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
1987         else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE); //LCOV_EXCL_LINE
1988
1989         _retvm_if(tethering_is_enabled(tethering, type) == false,
1990                         TETHERING_ERROR_NOT_ENABLED,
1991                         "tethering type[%d] is not enabled\n", type);
1992         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1993                         "parameter(tethering) is NULL\n");
1994         _retvm_if(mac_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
1995                         "parameter(mac_address) is NULL\n");
1996
1997         struct ifreq ifr;
1998         int s = 0;
1999         char *macbuf = NULL;
2000
2001         _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
2002                         TETHERING_ERROR_OPERATION_FAILED,
2003                         "getting interface name is failed\n");
2004
2005         s = socket(AF_INET, SOCK_DGRAM, 0);
2006         _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
2007                         "getting socket is failed\n");
2008         if (ioctl(s, SIOCGIFHWADDR, &ifr) < 0) {
2009                 //LCOV_EXCL_START
2010                 ERR("getting mac is failed\n");
2011                 close(s);
2012                 return TETHERING_ERROR_OPERATION_FAILED;
2013                 //LCOV_EXCL_STOP
2014         }
2015         close(s);
2016
2017         macbuf = (char *)malloc(TETHERING_STR_INFO_LEN);
2018         _retvm_if(macbuf == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2019                         "Not enough memory\n");
2020         snprintf(macbuf, TETHERING_STR_INFO_LEN, "%02X:%02X:%02X:%02X:%02X:%02X",
2021                         (unsigned char)ifr.ifr_hwaddr.sa_data[0],
2022                         (unsigned char)ifr.ifr_hwaddr.sa_data[1],
2023                         (unsigned char)ifr.ifr_hwaddr.sa_data[2],
2024                         (unsigned char)ifr.ifr_hwaddr.sa_data[3],
2025                         (unsigned char)ifr.ifr_hwaddr.sa_data[4],
2026                         (unsigned char)ifr.ifr_hwaddr.sa_data[5]);
2027
2028         *mac_address = macbuf;
2029
2030         return TETHERING_ERROR_NONE;
2031 }
2032
2033 /**
2034  * @internal
2035  * @brief Gets the name of network interface. For example, usb0.
2036  * @since_tizen 2.3
2037  * @privlevel platform
2038  * @privilege http://tizen.org/privilege/tethering.admin
2039  * @remarks @a interface_name must be released with free() by you.
2040  * @param[in]  tethering  The handle of tethering
2041  * @param[in]  type  The type of tethering
2042  * @param[out]  interface_name  The name of network interface
2043  * @return 0 on success, otherwise negative error value.
2044  * @retval  #TETHERING_ERROR_NONE  Successful
2045  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2046  * @retval  #TETHERING_ERROR_OUT_OF_MEMORY  Out of memory
2047  * @retval  #TETHERING_ERROR_OPERATION_FAILED  Operation failed
2048  * @retval  #TETHERING_ERROR_NOT_ENABLED  Not enabled
2049  * @pre  tethering must be enabled.
2050  * @see  tethering_is_enabled()
2051  * @see  tethering_enable()
2052  */
2053 API int tethering_get_network_interface_name(tethering_h tethering, tethering_type_e type, char **interface_name)
2054 {
2055         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2056         if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2057         else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2058         else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2059
2060         _retvm_if(tethering_is_enabled(tethering, type) == false,
2061                         TETHERING_ERROR_NOT_ENABLED,
2062                         "tethering type[%d] is not enabled\n", type);
2063         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2064                         "parameter(tethering) is NULL\n");
2065         _retvm_if(interface_name == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2066                         "parameter(interface_name) is NULL\n");
2067
2068         char intf[TETHERING_STR_INFO_LEN] = {0, };
2069
2070         _retvm_if(!__get_intf_name(type, intf, sizeof(intf)),
2071                         TETHERING_ERROR_OPERATION_FAILED,
2072                         "getting interface name is failed\n");
2073         *interface_name = strdup(intf);
2074         _retvm_if(*interface_name == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2075                         "Not enough memory\n");
2076
2077         return TETHERING_ERROR_NONE;
2078 }
2079
2080 /**
2081  * @internal
2082  * @brief Gets the local IP address.
2083  * @since_tizen 2.3
2084  * @privlevel platform
2085  * @privilege http://tizen.org/privilege/tethering.admin
2086  * @remarks @a ip_address must be released with free() by you.
2087  * @param[in]  tethering  The handle of tethering
2088  * @param[in]  type  The type of tethering
2089  * @param[in]  address_family  The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2090  * @param[out]  ip_address  The local IP address
2091  * @return 0 on success, otherwise negative error value.
2092  * @retval  #TETHERING_ERROR_NONE  Successful
2093  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2094  * @retval  #TETHERING_ERROR_OUT_OF_MEMORY  Out of memory
2095  * @retval  #TETHERING_ERROR_OPERATION_FAILED  Operation failed
2096  * @retval  #TETHERING_ERROR_NOT_ENABLED  Not enabled
2097  * @pre  tethering must be enabled.
2098  * @see  tethering_is_enabled()
2099  * @see  tethering_enable()
2100  */
2101 API int tethering_get_ip_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **ip_address)
2102 {
2103         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2104         if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE); //LCOV_EXCL_LINE
2105         else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2106         else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE); //LCOV_EXCL_LINE
2107
2108         _retvm_if(tethering_is_enabled(tethering, type) == false,
2109                         TETHERING_ERROR_NOT_ENABLED,
2110                         "tethering type[%d] is not enabled\n", type);
2111         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2112                         "parameter(tethering) is NULL\n");
2113         _retvm_if(ip_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2114                         "parameter(ip_address) is NULL\n");
2115
2116         struct ifreq ifr;
2117         int s = 0;
2118         char *ipbuf = NULL;
2119
2120         _retvm_if(!__get_intf_name(type, ifr.ifr_name, sizeof(ifr.ifr_name)),
2121                         TETHERING_ERROR_OPERATION_FAILED,
2122                         "getting interface name is failed\n");
2123
2124         s = socket(AF_INET, SOCK_DGRAM, 0);
2125         _retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
2126                         "getting socket is failed\n");
2127         if (ioctl(s, SIOCGIFADDR, &ifr) < 0) {
2128                 ERR("ioctl is failed\n");
2129                 close(s);
2130                 return TETHERING_ERROR_OPERATION_FAILED;
2131         }
2132         close(s);
2133
2134         ipbuf = inet_ntoa(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr);
2135         *ip_address = strdup(ipbuf);
2136         _retvm_if(*ip_address == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2137                         "Not enough memory\n");
2138
2139         return TETHERING_ERROR_NONE;
2140 }
2141
2142 /**
2143  * @internal
2144  * @brief Gets the Gateway address.
2145  * @since_tizen 2.3
2146  * @privlevel platform
2147  * @privilege http://tizen.org/privilege/tethering.admin
2148  * @remarks @a gateway_address must be released with free() by you.
2149  * @param[in]  tethering  The handle of tethering
2150  * @param[in]  type  The type of tethering
2151  * @param[in]  address_family  The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2152  * @param[out]  gateway_address  The local IP address
2153  * @return 0 on success, otherwise negative error value.
2154  * @retval  #TETHERING_ERROR_NONE  Successful
2155  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2156  * @retval  #TETHERING_ERROR_OUT_OF_MEMORY  Out of memory
2157  * @retval  #TETHERING_ERROR_OPERATION_FAILED  Operation failed
2158  * @retval  #TETHERING_ERROR_NOT_ENABLED  Not enabled
2159  * @pre  tethering must be enabled.
2160  * @see  tethering_is_enabled()
2161  * @see  tethering_enable()
2162  */
2163 API int tethering_get_gateway_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **gateway_address)
2164 {
2165         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2166         if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2167         else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2168         else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2169
2170         _retvm_if(tethering_is_enabled(tethering, type) == false,
2171                         TETHERING_ERROR_NOT_ENABLED,
2172                         "tethering type[%d] is not enabled\n", type);
2173         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2174                         "parameter(tethering) is NULL\n");
2175         _retvm_if(gateway_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2176                         "parameter(gateway_address) is NULL\n");
2177
2178         char gateway_buf[TETHERING_STR_INFO_LEN] = {0, };
2179
2180         _retvm_if(!__get_gateway_addr(type, gateway_buf, sizeof(gateway_buf)),
2181                         TETHERING_ERROR_OPERATION_FAILED,
2182                         "getting gateway address is failed\n");
2183
2184         *gateway_address = strdup(gateway_buf);
2185
2186         return TETHERING_ERROR_NONE;
2187 }
2188
2189 /**
2190  * @internal
2191  * @brief Gets the Subnet Mask.
2192  * @since_tizen 2.3
2193  * @privlevel platform
2194  * @privilege http://tizen.org/privilege/tethering.admin
2195  * @remarks @a subnet_mask must be released with free() by you.
2196  * @param[in]  tethering  The handle of tethering
2197  * @param[in]  type  The type of tethering
2198  * @param[in]  address_family  The address family of IP address. Currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported.
2199  * @param[out]  subnet_mask  The local IP address
2200  * @return 0 on success, otherwise negative error value.
2201  * @retval  #TETHERING_ERROR_NONE  Successful
2202  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2203  * @retval  #TETHERING_ERROR_OUT_OF_MEMORY  Out of memory
2204  * @retval  #TETHERING_ERROR_OPERATION_FAILED  Operation failed
2205  * @retval  #TETHERING_ERROR_NOT_ENABLED  Not enabled
2206  * @pre  tethering must be enabled.
2207  * @see  tethering_is_enabled()
2208  * @see  tethering_enable()
2209  */
2210 API int tethering_get_subnet_mask(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **subnet_mask)
2211 {
2212         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2213         if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2214         else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2215         else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2216
2217         _retvm_if(tethering_is_enabled(tethering, type) == false,
2218                         TETHERING_ERROR_NOT_ENABLED,
2219                         "tethering is not enabled\n");
2220         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2221                         "parameter(tethering) is NULL\n");
2222         _retvm_if(subnet_mask == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2223                         "parameter(subnet_mask) is NULL\n");
2224
2225         *subnet_mask = strdup(TETHERING_SUBNET_MASK);
2226         _retvm_if(*subnet_mask == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2227                         "Not enough memory\n");
2228
2229         return TETHERING_ERROR_NONE;
2230 }
2231
2232 /**
2233  * @internal
2234  * @brief Gets the data usage.
2235  * @since_tizen 2.3
2236  * @privlevel platform
2237  * @privilege http://tizen.org/privilege/tethering.admin
2238  * @param[in]  tethering  The handle of tethering
2239  * @param[out]  usage  The data usage
2240  * @return 0 on success, otherwise negative error value.
2241  * @retval  #TETHERING_ERROR_NONE  Successful
2242  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2243  * @retval  #TETHERING_ERROR_OPERATION_FAILED  Operation failed
2244  * @retval  #TETHERING_ERROR_NOT_ENABLED  Not enabled
2245  * @pre  tethering must be enabled.
2246  * @see  tethering_is_enabled()
2247  * @see  tethering_enable()
2248  */
2249 API int tethering_get_data_usage(tethering_h tethering, tethering_data_usage_cb callback, void *user_data)
2250 {
2251         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2252
2253         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2254                         "parameter(tethering) is NULL\n");
2255         _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2256                         "parameter(callback) is NULL\n");
2257         _retvm_if(__any_tethering_is_enabled(tethering) == false,
2258                         TETHERING_ERROR_NOT_ENABLED,
2259                         "tethering is not enabled\n");
2260
2261         __tethering_h *th = (__tethering_h *)tethering;
2262         GDBusProxy *proxy = th->client_bus_proxy;
2263
2264         th->data_usage_cb = callback;
2265         th->data_usage_user_data = user_data;
2266
2267         g_dbus_proxy_call(proxy, "get_data_packet_usage",
2268                         NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
2269                         (GAsyncReadyCallback) __get_data_usage_cb, (gpointer)tethering);
2270
2271         return TETHERING_ERROR_NONE;
2272 }
2273
2274 /**
2275  * @internal
2276  * @brief Gets the client which is connected by tethering "type".
2277  * @since_tizen 2.3
2278  * @privlevel platform
2279  * @privilege http://tizen.org/privilege/tethering.admin
2280  * @param[in]  tethering  The handle of tethering
2281  * @param[in]  type  The type of tethering
2282  * @param[in]  callback  The callback function to invoke
2283  * @param[in]  user_data  The user data to be passed to the callback function
2284  * @retval  #TETHERING_ERROR_NONE  Successful
2285  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2286  * @retval  #TETHERING_ERROR_NOT_ENABLED  Not enabled
2287  * @retval  #TETHERING_ERROR_OPERATION_FAILED  Operation failed
2288  * @pre  tethering must be enabled.
2289  * @see  tethering_is_enabled()
2290  * @see  tethering_enable()
2291  */
2292 API int tethering_foreach_connected_clients(tethering_h tethering, tethering_type_e type, tethering_connected_client_cb callback, void *user_data)
2293 {
2294         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2295         if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2296         else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2297         else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2298
2299         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2300                         "parameter(tethering) is NULL\n");
2301         _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2302                         "parameter(callback) is NULL\n");
2303         _retvm_if(__any_tethering_is_enabled(tethering) == false,
2304                         TETHERING_ERROR_NOT_ENABLED,
2305                         "tethering is not enabled\n");
2306
2307         mobile_ap_type_e interface;
2308         __tethering_h *th = (__tethering_h *)tethering;
2309         __tethering_client_h client = {0, };
2310         gchar *ip = NULL;
2311         gchar *mac = NULL;
2312         gchar *hostname = NULL;
2313         guint timestamp = 0;
2314         GError *error = NULL;
2315         GVariant *result = NULL;
2316         GVariantIter *outer_iter = NULL;
2317         GVariantIter *inner_iter = NULL;
2318         GVariant *station = NULL;
2319         GVariant *value = NULL;
2320         gchar *key = NULL;
2321
2322         result = g_dbus_proxy_call_sync(th->client_bus_proxy, "get_station_info",
2323                         NULL, G_DBUS_CALL_FLAGS_NONE,
2324                         -1, th->cancellable, &error);
2325         if (error)
2326                 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message); //LCOV_EXCL_LINE
2327         g_variant_get(result, "(a(a{sv}))", &outer_iter);
2328         //LCOV_EXCL_START
2329         while (g_variant_iter_loop(outer_iter, "(@a{sv})", &station)) {
2330                 g_variant_get(station, "a{sv}", &inner_iter);
2331                 while (g_variant_iter_loop(inner_iter, "{sv}", &key, &value)) {
2332                         if (g_strcmp0(key, "Type") == 0) {
2333                                 interface = g_variant_get_int32(value);
2334                                 if (interface == MOBILE_AP_TYPE_USB)
2335                                         client.interface = TETHERING_TYPE_USB;
2336                                 else if (interface == MOBILE_AP_TYPE_WIFI)
2337                                         client.interface = TETHERING_TYPE_WIFI;
2338                                 else if (interface == MOBILE_AP_TYPE_BT)
2339                                         client.interface = TETHERING_TYPE_BT;
2340                                 else if (interface == MOBILE_AP_TYPE_P2P)
2341                                         client.interface = TETHERING_TYPE_P2P;
2342                                 else {
2343                                         ERR("Invalid interface\n");
2344                                         g_free(key);
2345                                         g_variant_unref(value);
2346                                         break;
2347                                 }
2348                                 DBG("interface is %d\n", client.interface);
2349                                 if (client.interface != type && (TETHERING_TYPE_ALL != type)) {
2350                                         g_free(key);
2351                                         g_variant_unref(value);
2352                                         break;
2353                                 }
2354                         } else if (g_strcmp0(key, "IP") == 0) {
2355                                 g_variant_get(value, "s", &ip);
2356                                 SDBG("ip is %s\n", ip);
2357                                 g_strlcpy(client.ip, ip, sizeof(client.ip));
2358                         } else if (g_strcmp0(key, "MAC") == 0) {
2359                                 g_variant_get(value, "s", &mac);
2360                                 SDBG("mac is %s\n", mac);
2361                                 g_strlcpy(client.mac, mac, sizeof(client.mac));
2362                         } else if (g_strcmp0(key, "Name") == 0) {
2363                                 g_variant_get(value, "s", &hostname);
2364                                 SDBG("hsotname is %s\n", hostname);
2365                                 if (hostname)
2366                                         client.hostname = g_strdup(hostname);
2367                         } else if (g_strcmp0(key, "Time") == 0) {
2368                                 timestamp = g_variant_get_int32(value);
2369                                 DBG("timestamp is %d\n", timestamp);
2370                                 client.tm = (time_t)timestamp;
2371                         } else {
2372                                 ERR("Key %s not required\n", key);
2373                         }
2374                 }
2375                 g_free(hostname);
2376                 g_free(ip);
2377                 g_free(mac);
2378
2379                 hostname = NULL;
2380                 ip = NULL;
2381                 mac = NULL;
2382
2383                 g_variant_iter_free(inner_iter);
2384                 if (callback((tethering_client_h)&client, user_data) == false) {
2385                         DBG("iteration is stopped\n");
2386                         g_free(client.hostname);
2387                         client.hostname = NULL;
2388                         g_variant_iter_free(outer_iter);
2389                         g_variant_unref(station);
2390                         g_variant_unref(result);
2391                         DBG("-\n");
2392                         return TETHERING_ERROR_OPERATION_FAILED;
2393                 }
2394                 g_free(client.hostname);
2395                 client.hostname = NULL;
2396         }
2397         //LCOV_EXCL_STOP
2398         g_variant_iter_free(outer_iter);
2399         g_variant_unref(station);
2400         g_variant_unref(result);
2401         DBG("-\n");
2402         return TETHERING_ERROR_NONE;
2403 }
2404
2405 /**
2406  * @internal
2407  * @brief Registers the callback function called when tethering is enabled.
2408  * @since_tizen 2.3
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  * @param[in]  callback  The callback function to invoke
2414  * @param[in]  user_data  The user data to be passed to the callback function
2415  * @retval  #TETHERING_ERROR_NONE  Successful
2416  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2417  * @see  tethering_unset_enabled_cb()
2418  */
2419 API int tethering_set_enabled_cb(tethering_h tethering, tethering_type_e type, tethering_enabled_cb callback, void *user_data)
2420 {
2421         INFO("+ type: %d\n", type);
2422         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2423         if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2424         else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2425         else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2426
2427         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2428                         "parameter(tethering) is NULL\n");
2429         _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2430                         "parameter(callback) is NULL\n");
2431
2432         __tethering_h *th = (__tethering_h *)tethering;
2433         tethering_type_e ti;
2434
2435         if (type != TETHERING_TYPE_ALL) {
2436                 th->enabled_cb[type] = callback;
2437                 th->enabled_user_data[type] = user_data;
2438
2439                 return TETHERING_ERROR_NONE;
2440         }
2441
2442         /* TETHERING_TYPE_ALL */
2443         for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2444                 th->enabled_cb[ti] = callback;
2445                 th->enabled_user_data[ti] = user_data;
2446         }
2447
2448         INFO("-\n");
2449         return TETHERING_ERROR_NONE;
2450 }
2451
2452 /**
2453  * @internal
2454  * @brief Unregisters the callback function called when tethering is disabled.
2455  * @since_tizen 2.3
2456  * @privlevel platform
2457  * @privilege http://tizen.org/privilege/tethering.admin
2458  * @param[in]  tethering  The handle of tethering
2459  * @param[in]  type  The type of tethering
2460  * @retval  #TETHERING_ERROR_NONE  Successful
2461  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2462  * @see  tethering_set_enabled_cb()
2463  */
2464 API int tethering_unset_enabled_cb(tethering_h tethering, tethering_type_e type)
2465 {
2466         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2467         if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2468         else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2469         else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2470
2471         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2472                         "parameter(tethering) is NULL\n");
2473
2474         __tethering_h *th = (__tethering_h *)tethering;
2475         tethering_type_e ti;
2476
2477         if (type != TETHERING_TYPE_ALL) {
2478                 th->enabled_cb[type] = NULL;
2479                 th->enabled_user_data[type] = NULL;
2480
2481                 return TETHERING_ERROR_NONE;
2482         }
2483
2484         /* TETHERING_TYPE_ALL */
2485         for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2486                 th->enabled_cb[ti] = NULL;
2487                 th->enabled_user_data[ti] = NULL;
2488         }
2489
2490         return TETHERING_ERROR_NONE;
2491 }
2492
2493 /**
2494  * @internal
2495  * @brief Registers the callback function called when tethering is disabled.
2496  * @since_tizen 2.3
2497  * @privlevel platform
2498  * @privilege http://tizen.org/privilege/tethering.admin
2499  * @param[in]  tethering  The handle of tethering
2500  * @param[in]  type  The type of tethering
2501  * @param[in]  callback  The callback function to invoke
2502  * @param[in]  user_data  The user data to be passed to the callback function
2503  * @retval  #TETHERING_ERROR_NONE  Successful
2504  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2505  * @see  tethering_unset_disabled_cb()
2506  */
2507 API int tethering_set_disabled_cb(tethering_h tethering, tethering_type_e type, tethering_disabled_cb callback, void *user_data)
2508 {
2509         INFO("+ type: %d\n", type);
2510         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2511         if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2512         else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2513         else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2514
2515         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2516                         "parameter(tethering) is NULL\n");
2517         _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2518                         "parameter(callback) is NULL\n");
2519
2520         __tethering_h *th = (__tethering_h *)tethering;
2521         tethering_type_e ti;
2522
2523         if (type != TETHERING_TYPE_ALL) {
2524                 th->disabled_cb[type] = callback;
2525                 th->disabled_user_data[type] = user_data;
2526
2527                 return TETHERING_ERROR_NONE;
2528         }
2529
2530         /* TETHERING_TYPE_ALL */
2531         for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2532                 th->disabled_cb[ti] = callback;
2533                 th->disabled_user_data[ti] = user_data;
2534         }
2535         INFO("-\n");
2536         return TETHERING_ERROR_NONE;
2537 }
2538
2539 /**
2540  * @internal
2541  * @brief Unregisters the callback function called when tethering is disabled.
2542  * @since_tizen 2.3
2543  * @privlevel platform
2544  * @privilege http://tizen.org/privilege/tethering.admin
2545  * @param[in]  tethering  The handle of tethering
2546  * @param[in]  type  The type of tethering
2547  * @retval  #TETHERING_ERROR_NONE  Successful
2548  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2549  * @see  tethering_set_disabled_cb()
2550  */
2551 API int tethering_unset_disabled_cb(tethering_h tethering, tethering_type_e type)
2552 {
2553         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2554         if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2555         else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2556         else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2557
2558         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2559                         "parameter(tethering) is NULL\n");
2560
2561         __tethering_h *th = (__tethering_h *)tethering;
2562         tethering_type_e ti;
2563
2564         if (type != TETHERING_TYPE_ALL) {
2565                 th->disabled_cb[type] = NULL;
2566                 th->disabled_user_data[type] = NULL;
2567
2568                 return TETHERING_ERROR_NONE;
2569         }
2570
2571         /* TETHERING_TYPE_ALL */
2572         for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2573                 th->disabled_cb[ti] = NULL;
2574                 th->disabled_user_data[ti] = NULL;
2575         }
2576
2577         return TETHERING_ERROR_NONE;
2578 }
2579
2580 /**
2581  * @internal
2582  * @brief Registers the callback function called when the state of connection is changed.
2583  * @since_tizen 2.3
2584  * @privlevel platform
2585  * @privilege http://tizen.org/privilege/tethering.admin
2586  * @param[in]  tethering  The handle of tethering
2587  * @param[in]  type  The type of tethering
2588  * @param[in]  callback  The callback function to invoke
2589  * @param[in]  user_data  The user data to be passed to the callback function
2590  * @retval  #TETHERING_ERROR_NONE  Successful
2591  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2592  * @see  tethering_unset_connection_state_changed_cb_cb()
2593  */
2594 API int tethering_set_connection_state_changed_cb(tethering_h tethering, tethering_type_e type, tethering_connection_state_changed_cb callback, void *user_data)
2595 {
2596         INFO("+ type: %d\n", type);
2597         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2598         if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2599         else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2600         else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2601
2602         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2603                         "parameter(tethering) is NULL\n");
2604         _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2605                         "parameter(callback) is NULL\n");
2606
2607         __tethering_h *th = (__tethering_h *)tethering;
2608         tethering_type_e ti;
2609
2610         if (type != TETHERING_TYPE_ALL) {
2611                 th->changed_cb[type] = callback;
2612                 th->changed_user_data[type] = user_data;
2613
2614                 return TETHERING_ERROR_NONE;
2615         }
2616
2617         /* TETHERING_TYPE_ALL */
2618         for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2619                 th->changed_cb[ti] = callback;
2620                 th->changed_user_data[ti] = user_data;
2621         }
2622         INFO("-\n");
2623         return TETHERING_ERROR_NONE;
2624 }
2625
2626 /**
2627  * @internal
2628  * @brief Unregisters the callback function called when the state of connection is changed.
2629  * @since_tizen 2.3
2630  * @privlevel platform
2631  * @privilege http://tizen.org/privilege/tethering.admin
2632  * @param[in]  tethering  The handle of tethering
2633  * @param[in]  type  The type of tethering
2634  * @retval  #TETHERING_ERROR_NONE  Successful
2635  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2636  * @see  tethering_set_connection_state_changed_cb()
2637  */
2638 API int tethering_unset_connection_state_changed_cb(tethering_h tethering, tethering_type_e type)
2639 {
2640         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2641         if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
2642         else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2643         else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
2644
2645         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2646                         "parameter(tethering) is NULL\n");
2647
2648         __tethering_h *th = (__tethering_h *)tethering;
2649         tethering_type_e ti;
2650
2651         if (type != TETHERING_TYPE_ALL) {
2652                 th->changed_cb[type] = NULL;
2653                 th->changed_user_data[type] = NULL;
2654
2655                 return TETHERING_ERROR_NONE;
2656         }
2657
2658         /* TETHERING_TYPE_ALL */
2659         for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
2660                 th->changed_cb[ti] = NULL;
2661                 th->changed_user_data[ti] = NULL;
2662         }
2663
2664         return TETHERING_ERROR_NONE;
2665 }
2666
2667 /**
2668  * @internal
2669  * @brief Registers the callback function called when the security type of Wi-Fi tethering is changed.
2670  * @since_tizen 2.3
2671  * @privlevel platform
2672  * @privilege http://tizen.org/privilege/tethering.admin
2673  * @param[in]  tethering  The handle of tethering
2674  * @param[in]  callback  The callback function to invoke
2675  * @param[in]  user_data  The user data to be passed to the callback function
2676  * @retval  #TETHERING_ERROR_NONE  Successful
2677  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2678  * @see  tethering_wifi_unset_security_type_changed_cb()
2679  */
2680 API int tethering_wifi_set_security_type_changed_cb(tethering_h tethering, tethering_wifi_security_type_changed_cb callback, void *user_data)
2681 {
2682         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2683         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2684
2685         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2686                         "parameter(tethering) is NULL\n");
2687         _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2688                         "parameter(callback) is NULL\n");
2689
2690         __tethering_h *th = (__tethering_h *)tethering;
2691
2692         th->security_type_changed_cb = callback;
2693         th->security_type_user_data = user_data;
2694
2695         return TETHERING_ERROR_NONE;
2696
2697 }
2698
2699 /**
2700  * @internal
2701  * @brief Unregisters the callback function called when the security type of Wi-Fi tethering is changed.
2702  * @since_tizen 2.3
2703  * @privlevel platform
2704  * @privilege http://tizen.org/privilege/tethering.admin
2705  * @param[in]  tethering  The handle of tethering
2706  * @param[in]  type  The type of tethering
2707  * @retval  #TETHERING_ERROR_NONE  Successful
2708  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2709  * @see  tethering_wifi_set_security_type_changed_cb()
2710  */
2711 API int tethering_wifi_unset_security_type_changed_cb(tethering_h tethering)
2712 {
2713         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2714         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2715
2716         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2717                         "parameter(tethering) is NULL\n");
2718
2719         __tethering_h *th = (__tethering_h *)tethering;
2720
2721         th->security_type_changed_cb = NULL;
2722         th->security_type_user_data = NULL;
2723
2724         return TETHERING_ERROR_NONE;
2725 }
2726
2727 /**
2728  * @internal
2729  * @brief Registers the callback function called when the visibility of SSID is changed.
2730  * @since_tizen 2.3
2731  * @privlevel platform
2732  * @privilege http://tizen.org/privilege/tethering.admin
2733  * @param[in]  tethering  The handle of tethering
2734  * @param[in]  callback  The callback function to invoke
2735  * @param[in]  user_data  The user data to be passed to the callback function
2736  * @retval  #TETHERING_ERROR_NONE  Successful
2737  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2738  * @see  tethering_wifi_unset_ssid_visibility_changed_cb_cb()
2739  */
2740 API int tethering_wifi_set_ssid_visibility_changed_cb(tethering_h tethering, tethering_wifi_ssid_visibility_changed_cb callback, void *user_data)
2741 {
2742         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2743         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2744
2745         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2746                         "parameter(tethering) is NULL\n");
2747         _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2748                         "parameter(callback) is NULL\n");
2749
2750         __tethering_h *th = (__tethering_h *)tethering;
2751
2752         th->ssid_visibility_changed_cb = callback;
2753         th->ssid_visibility_user_data = user_data;
2754
2755         return TETHERING_ERROR_NONE;
2756 }
2757
2758 /**
2759  * @internal
2760  * @brief Unregisters the callback function called when the visibility of SSID is changed.
2761  * @since_tizen 2.3
2762  * @privlevel platform
2763  * @privilege http://tizen.org/privilege/tethering.admin
2764  * @param[in]  tethering  The handle of tethering
2765  * @retval  #TETHERING_ERROR_NONE  Successful
2766  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2767  * @see  tethering_wifi_set_ssid_visibility_changed_cb()
2768  */
2769 API int tethering_wifi_unset_ssid_visibility_changed_cb(tethering_h tethering)
2770 {
2771         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2772         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2773
2774         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2775                         "parameter(tethering) is NULL\n");
2776
2777         __tethering_h *th = (__tethering_h *)tethering;
2778
2779         th->ssid_visibility_changed_cb = NULL;
2780         th->ssid_visibility_user_data = NULL;
2781
2782         return TETHERING_ERROR_NONE;
2783 }
2784
2785 /**
2786  * @internal
2787  * @brief Registers the callback function called when the passphrase of Wi-Fi tethering is changed.
2788  * @since_tizen 2.3
2789  * @privlevel platform
2790  * @privilege http://tizen.org/privilege/tethering.admin
2791  * @param[in]  tethering  The handle of tethering
2792  * @param[in]  callback  The callback function to invoke
2793  * @param[in]  user_data  The user data to be passed to the callback function
2794  * @retval  #TETHERING_ERROR_NONE  Successful
2795  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2796  * @see  tethering_wifi_unset_passphrase_changed_cb()
2797  */
2798 API int tethering_wifi_set_passphrase_changed_cb(tethering_h tethering, tethering_wifi_passphrase_changed_cb callback, void *user_data)
2799 {
2800         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2801         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2802
2803         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2804                         "parameter(tethering) is NULL\n");
2805         _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2806                         "parameter(callback) is NULL\n");
2807
2808         __tethering_h *th = (__tethering_h *)tethering;
2809
2810         th->passphrase_changed_cb = callback;
2811         th->passphrase_user_data = user_data;
2812
2813         return TETHERING_ERROR_NONE;
2814 }
2815
2816 /**
2817  * @internal
2818  * @brief Unregisters the callback function called when the passphrase of Wi-Fi tethering is changed.
2819  * @since_tizen 2.3
2820  * @privlevel platform
2821  * @privilege http://tizen.org/privilege/tethering.admin
2822  * @param[in]  tethering  The handle of tethering
2823  * @retval  #TETHERING_ERROR_NONE  Successful
2824  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2825  * @see  tethering_wifi_set_passphrase_changed_cb()
2826  */
2827 API int tethering_wifi_unset_passphrase_changed_cb(tethering_h tethering)
2828 {
2829         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2830         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2831
2832         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2833                         "parameter(tethering) is NULL\n");
2834
2835         __tethering_h *th = (__tethering_h *)tethering;
2836
2837         th->passphrase_changed_cb = NULL;
2838         th->passphrase_user_data = NULL;
2839
2840         return TETHERING_ERROR_NONE;
2841 }
2842
2843 /**
2844  * @internal
2845  * @brief Sets the security type of Wi-Fi tethering.
2846  * @since_tizen 2.3
2847  * @privlevel platform
2848  * @privilege http://tizen.org/privilege/tethering.admin
2849  * @remarks This change is applied next time Wi-Fi tethering is enabled
2850  * @param[in]  tethering  The handle of tethering
2851  * @param[in]  type  The security type
2852  * @return 0 on success, otherwise negative error value.
2853  * @retval  #TETHERING_ERROR_NONE  Successful
2854  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2855  * @retval  #TETHERING_ERROR_OPERATION_FAILED  Operation failed
2856  * @see  tethering_wifi_get_security_type()
2857  */
2858 API int tethering_wifi_set_security_type(tethering_h tethering, tethering_wifi_security_type_e type)
2859 {
2860         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2861         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2862
2863         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2864                         "parameter(tethering) is NULL\n");
2865
2866         __tethering_h *th = (__tethering_h *)tethering;
2867         tethering_error_e ret = TETHERING_ERROR_NONE;
2868         char *sec_str = NULL;
2869
2870         ret = __set_security_type(type);
2871         if (ret == TETHERING_ERROR_NONE) {
2872
2873                 switch (type) {
2874                 case TETHERING_WIFI_SECURITY_TYPE_NONE:
2875                         sec_str = TETHERING_WIFI_SECURITY_TYPE_OPEN_STR;
2876                         break;
2877                 case TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK:
2878                         sec_str = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK_STR;
2879                         break;
2880                 case TETHERING_WIFI_SECURITY_TYPE_WPS:
2881                         sec_str = TETHERING_WIFI_SECURITY_TYPE_WPS_STR;
2882                         break;
2883                 }
2884
2885                 __send_dbus_signal(th->client_bus,
2886                                 SIGNAL_NAME_SECURITY_TYPE_CHANGED, sec_str);
2887         }
2888         return ret;
2889 }
2890
2891 /**
2892  * @internal
2893  * @brief Gets the security type of Wi-Fi tethering.
2894  * @since_tizen 2.3
2895  * @privlevel platform
2896  * @privilege http://tizen.org/privilege/tethering.admin
2897  * @param[in]  tethering  The handle of tethering
2898  * @param[out]  type  The security type
2899  * @return 0 on success, otherwise negative error value.
2900  * @retval  #TETHERING_ERROR_NONE  Successful
2901  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2902  * @retval  #TETHERING_ERROR_OPERATION_FAILED  Operation failed
2903  * @see  tethering_wifi_set_security_type()
2904  */
2905 API int tethering_wifi_get_security_type(tethering_h tethering, tethering_wifi_security_type_e *type)
2906 {
2907         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2908         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2909
2910         _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2911                         "parameter(type) is NULL\n");
2912
2913         return __get_security_type(type);
2914 }
2915
2916 /**
2917  * @internal
2918  * @brief Sets the SSID (service set identifier).
2919  * @since_tizen 2.3
2920  * @privlevel platform
2921  * @privilege http://tizen.org/privilege/tethering.admin
2922  * @details If SSID is not set, Device name is used as SSID
2923  * @remarks This change is applied next time Wi-Fi tethering is enabled with same @a tethering handle
2924  * @param[in]  tethering  The handle of tethering
2925  * @param[out]  ssid  The SSID
2926  * @return 0 on success, otherwise negative error value.
2927  * @retval  #TETHERING_ERROR_NONE  Successful
2928  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2929  * @retval  #TETHERING_ERROR_OUT_OF_MEMORY  Out of memory
2930  */
2931 API int tethering_wifi_set_ssid(tethering_h tethering, const char *ssid)
2932 {
2933         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2934         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2935
2936         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2937                         "parameter(tethering) is NULL\n");
2938         _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2939                         "parameter(ssid) is NULL\n");
2940
2941         __tethering_h *th = (__tethering_h *)tethering;
2942         char *p_ssid = NULL;
2943         int ssid_len = 0;
2944
2945         ssid_len = strlen(ssid);
2946         if (ssid_len > TETHERING_WIFI_SSID_MAX_LEN) {
2947                 ERR("parameter(ssid) is too long");
2948                 return TETHERING_ERROR_INVALID_PARAMETER;
2949         }
2950
2951         p_ssid = strdup(ssid);
2952         _retvm_if(p_ssid == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
2953                         "strdup is failed\n");
2954
2955         if (th->ssid)
2956                 free(th->ssid);
2957         th->ssid = p_ssid;
2958
2959         return TETHERING_ERROR_NONE;
2960 }
2961
2962 /**
2963  * @internal
2964  * @brief Gets the SSID (service set identifier).
2965  * @since_tizen 2.3
2966  * @privlevel platform
2967  * @privilege http://tizen.org/privilege/tethering.admin
2968  * @remarks @a ssid must be released with free() by you.
2969  * @param[in]  tethering  The handle of tethering
2970  * @param[out]  ssid  The SSID
2971  * @return 0 on success, otherwise negative error value.
2972  * @retval  #TETHERING_ERROR_NONE  Successful
2973  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
2974  * @retval  #TETHERING_ERROR_OUT_OF_MEMORY  Out of memory
2975  * @retval  #TETHERING_ERROR_OPERATION_FAILED  Operation failed
2976  */
2977 API int tethering_wifi_get_ssid(tethering_h tethering, char **ssid)
2978 {
2979         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
2980         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
2981
2982         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2983                         "parameter(tethering) is NULL\n");
2984         _retvm_if(ssid == NULL, TETHERING_ERROR_INVALID_PARAMETER,
2985                         "parameter(ssid) is NULL\n");
2986         DBG("+\n");
2987
2988         __tethering_h *th = (__tethering_h *)tethering;
2989         char val[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
2990
2991         if (!tethering_is_enabled(NULL, TETHERING_TYPE_WIFI)) {
2992                 if (th->ssid != NULL) {
2993                         DBG("Private SSID is set\n");
2994                         *ssid = strdup(th->ssid);
2995                 } else {
2996                         if (__get_ssid_from_vconf(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
2997                                                 val, sizeof(val)) == false) {
2998                                 return TETHERING_ERROR_OPERATION_FAILED;
2999                         }
3000                         *ssid = strdup(val);
3001                 }
3002         } else {
3003                 if (__get_ssid_from_vconf(VCONFKEY_MOBILE_HOTSPOT_SSID,
3004                                         val, sizeof(val)) == false) {
3005                         return TETHERING_ERROR_OPERATION_FAILED;
3006                 }
3007                 *ssid = strdup(val);
3008         }
3009
3010         if (*ssid == NULL) {
3011                 ERR("strdup is failed\n"); //LCOV_EXCL_LINE
3012                 return TETHERING_ERROR_OUT_OF_MEMORY;
3013         }
3014
3015         return TETHERING_ERROR_NONE;
3016 }
3017
3018 /**
3019  * @internal
3020  * @brief Sets the visibility of SSID(service set identifier).
3021  * @since_tizen 2.3
3022  * @privlevel platform
3023  * @privilege http://tizen.org/privilege/tethering.admin
3024  * @details If you set the visibility invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
3025  * @remarks This change is applied next time Wi-Fi tethering is enabled
3026  * @param[in]  tethering  The handle of tethering
3027  * @param[in]  visible  The visibility of SSID: (@c true = visible, @c false = invisible)
3028  * @return 0 on success, otherwise negative error value.
3029  * @retval  #TETHERING_ERROR_NONE  Successful
3030  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
3031  * @retval  #TETHERING_ERROR_OPERATION_FAILED  Operation failed
3032  * @see  tethering_wifi_get_ssid_visibility()
3033  */
3034 API int tethering_wifi_set_ssid_visibility(tethering_h tethering, bool visible)
3035 {
3036         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3037         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3038
3039         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3040                         "parameter(tethering) is NULL\n");
3041
3042         __tethering_h *th = (__tethering_h *)tethering;
3043         tethering_error_e ret = TETHERING_ERROR_NONE;
3044
3045         ret = __set_visible(visible);
3046         if (ret == TETHERING_ERROR_NONE) {
3047                 __send_dbus_signal(th->client_bus,
3048                                 SIGNAL_NAME_SSID_VISIBILITY_CHANGED,
3049                                 visible ? SIGNAL_MSG_SSID_VISIBLE :
3050                                 SIGNAL_MSG_SSID_HIDE);
3051         }
3052         return ret;
3053 }
3054
3055 /**
3056  * @internal
3057  * @brief Gets the visibility of SSID(service set identifier).
3058  * @since_tizen 2.3
3059  * @privlevel platform
3060  * @privilege http://tizen.org/privilege/tethering.admin
3061  * @details If the visibility is set invisible, then the SSID of this device is hidden. So, Wi-Fi scan can't find your device.
3062  * @param[in]  tethering  The handle of tethering
3063  * @param[out]  visible  The visibility of SSID: (@c true = visible, @c false = invisible)
3064  * @return 0 on success, otherwise negative error value.
3065  * @retval  #TETHERING_ERROR_NONE  Successful
3066  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
3067  * @retval  #TETHERING_ERROR_OPERATION_FAILED  Operation failed
3068  * @see  tethering_wifi_set_ssid_visibility()
3069  */
3070 API int tethering_wifi_get_ssid_visibility(tethering_h tethering, bool *visible)
3071 {
3072         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3073         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3074
3075         _retvm_if(visible == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3076                         "parameter(visible) is NULL\n");
3077
3078         return __get_visible(visible);
3079 }
3080
3081 /**
3082  * @internal
3083  * @brief Sets the passphrase.
3084  * @since_tizen 2.3
3085  * @privlevel platform
3086  * @privilege http://tizen.org/privilege/tethering.admin
3087  * @remarks This change is applied next time Wi-Fi tethering is enabled
3088  * @param[in]  tethering  The handle of tethering
3089  * @param[in]  passphrase  The passphrase
3090  * @return 0 on success, otherwise negative error value.
3091  * @retval  #TETHERING_ERROR_NONE  Successful
3092  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
3093  * @retval  #TETHERING_ERROR_OPERATION_FAILED  Operation failed
3094  * @see  tethering_wifi_get_passphrase()
3095  */
3096 API int tethering_wifi_set_passphrase(tethering_h tethering, const char *passphrase)
3097 {
3098         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3099         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3100
3101         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3102                         "parameter(tethering) is NULL\n");
3103         _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3104                         "parameter(passphrase) is NULL\n");
3105
3106         __tethering_h *th = (__tethering_h *)tethering;
3107         GDBusProxy *proxy = th->client_bus_proxy;
3108         GVariant *parameters;
3109         GError *error = NULL;
3110         int passphrase_len = 0;
3111         int ret = 0;
3112
3113         DBG("+");
3114         passphrase_len = strlen(passphrase);
3115         if (passphrase_len < TETHERING_WIFI_KEY_MIN_LEN ||
3116                         passphrase_len > TETHERING_WIFI_KEY_MAX_LEN) {
3117                 ERR("parameter(passphrase) is too short or long\n");
3118                 return TETHERING_ERROR_INVALID_PARAMETER;
3119         }
3120
3121         parameters = g_dbus_proxy_call_sync(proxy, "set_wifi_tethering_passphrase",
3122                         g_variant_new("(s)", passphrase), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3123
3124         if (error) {
3125                 //LCOV_EXCL_START
3126                 ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
3127
3128                 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3129                         ret = TETHERING_ERROR_PERMISSION_DENIED;
3130                 else
3131                         ret = TETHERING_ERROR_OPERATION_FAILED;
3132
3133                 g_error_free(error);
3134                 return ret;
3135                 //LCOV_EXCL_STOP
3136         }
3137
3138         g_variant_get(parameters, "(u)", &ret);
3139         g_variant_unref(parameters);
3140
3141         if (ret == TETHERING_ERROR_NONE) {
3142                 __send_dbus_signal(th->client_bus,
3143                                 SIGNAL_NAME_PASSPHRASE_CHANGED, NULL);
3144         }
3145
3146         DBG("-");
3147         return ret;
3148 }
3149
3150 /**
3151  * @internal
3152  * @brief Gets the passphrase.
3153  * @since_tizen 2.3
3154  * @privlevel platform
3155  * @privilege http://tizen.org/privilege/tethering.admin
3156  * @remarks @a passphrase must be released with free() by you.
3157  * @param[in]  tethering  The handle of tethering
3158  * @param[out]  passphrase  The passphrase
3159  * @return 0 on success, otherwise negative error value.
3160  * @retval  #TETHERING_ERROR_NONE  Successful
3161  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
3162  * @retval  #TETHERING_ERROR_OUT_OF_MEMORY  Out of memory
3163  * @retval  #TETHERING_ERROR_OPERATION_FAILED  Operation failed
3164  * @see  tethering_wifi_set_passphrase()
3165  */
3166 API int tethering_wifi_get_passphrase(tethering_h tethering, char **passphrase)
3167 {
3168         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3169         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3170
3171         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3172                         "parameter(tethering) is NULL\n");
3173         _retvm_if(passphrase == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3174                         "parameter(passphrase) is NULL\n");
3175
3176         __tethering_h *th = (__tethering_h *)tethering;
3177         GDBusProxy *proxy = th->client_bus_proxy;
3178         GVariant *parameters;
3179         GError *error = NULL;
3180         unsigned int len = 0;
3181         tethering_error_e ret = TETHERING_ERROR_NONE;
3182
3183         parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_passphrase",
3184                         NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3185
3186         if (error) {
3187                 //LCOV_EXCL_START
3188                 ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
3189
3190                 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3191                         ret = TETHERING_ERROR_PERMISSION_DENIED;
3192                 else
3193                         ret = TETHERING_ERROR_OPERATION_FAILED;
3194
3195                 g_error_free(error);
3196                 return ret;
3197                 //LCOV_EXCL_STOP
3198         }
3199
3200         if (parameters != NULL) {
3201                 g_variant_get(parameters, "(siu)", passphrase, &len, &ret);
3202                 g_variant_unref(parameters);
3203         }
3204
3205         return TETHERING_ERROR_NONE;
3206 }
3207
3208 API int tethering_wifi_set_channel(tethering_h tethering, int channel)
3209 {
3210         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3211         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3212
3213         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3214                         "parameter(tethering) is NULL\n");
3215
3216         __tethering_h *th = (__tethering_h *)tethering;
3217         th->channel = channel;
3218
3219         return TETHERING_ERROR_NONE;
3220 }
3221
3222 API int tethering_wifi_get_channel(tethering_h tethering, int *channel)
3223 {
3224         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3225         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3226
3227         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3228                         "parameter(tethering) is NULL\n");
3229
3230         _retvm_if(channel == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3231                         "parameter(channel) is NULL\n");
3232
3233         __tethering_h *th = (__tethering_h *)tethering;
3234         *channel = th->channel;
3235
3236         return TETHERING_ERROR_NONE;
3237 }
3238
3239 API int tethering_wifi_set_mode(tethering_h tethering, tethering_wifi_mode_type_e type)
3240 {
3241         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3242         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3243
3244         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3245                         "parameter(tethering) is NULL\n");
3246
3247         __tethering_h *th = (__tethering_h *)tethering;
3248
3249         th->mode_type = type;
3250
3251         return TETHERING_ERROR_NONE;
3252 }
3253
3254 API int tethering_wifi_get_mode(tethering_h tethering, tethering_wifi_mode_type_e *type)
3255 {
3256         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3257         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3258
3259         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3260                         "parameter(tethering) is NULL\n");
3261         _retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3262                         "parameter(type) is NULL\n");
3263
3264         __tethering_h *th = (__tethering_h *)tethering;
3265         *type = th->mode_type;
3266
3267         return TETHERING_ERROR_NONE;
3268 }
3269
3270
3271 /**
3272  * @internal
3273  * @brief Reload the settings (SSID / Passphrase / Security type / SSID visibility).
3274  * @since_tizen 2.3
3275  * @privlevel platform
3276  * @privilege http://tizen.org/privilege/tethering.admin
3277  * @remarks Connected devices via Wi-Fi tethering or MobileAP will be disconnected when the settings are reloaded
3278  * @param[in]  tethering  The handle of tethering
3279  * @param[in]  callback  The callback function to invoke
3280  * @param[in]  user_data  The user data to be passed to the callback function
3281  * @return 0 on success, otherwise negative error value.
3282  * @retval  #TETHERING_ERROR_NONE  Successful
3283  * @retval  #TETHERING_ERROR_INVALID_PARAMETER  Invalid parameter
3284  * @retval  #TETHERING_ERROR_OPERATION_FAILED  Operation failed
3285  */
3286 API int tethering_wifi_reload_settings(tethering_h tethering, tethering_wifi_settings_reloaded_cb callback, void *user_data)
3287
3288 {
3289         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3290         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3291
3292         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3293                         "parameter(tethering) is NULL\n");
3294         _retvm_if(callback == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3295                         "parameter(callback) is NULL\n");
3296
3297         __tethering_h *th = (__tethering_h *)tethering;
3298         _softap_settings_t set = {"", "", "", 0, false};
3299         GDBusProxy *proxy = th->client_bus_proxy;
3300         int ret = 0;
3301
3302         DBG("+\n");
3303
3304         if (th->settings_reloaded_cb) {
3305                 ERR("Operation in progress\n"); //LCOV_EXCL_LINE
3306                 return TETHERING_ERROR_OPERATION_FAILED;
3307         }
3308
3309         ret = __prepare_wifi_settings(tethering, &set);
3310         if (ret != TETHERING_ERROR_NONE) {
3311                 ERR("softap settings initialization failed\n"); //LCOV_EXCL_LINE
3312                 return TETHERING_ERROR_OPERATION_FAILED;
3313         }
3314
3315         th->settings_reloaded_cb = callback;
3316         th->settings_reloaded_user_data = user_data;
3317
3318         g_dbus_proxy_call(proxy, "reload_wifi_settings",
3319                         g_variant_new("(sssiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type),
3320                         G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
3321                         (GAsyncReadyCallback) __settings_reloaded_cb, (gpointer)tethering);
3322
3323         return TETHERING_ERROR_NONE;
3324 }
3325
3326 API int tethering_wifi_set_mac_filter(tethering_h tethering, bool mac_filter)
3327 {
3328         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3329         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3330
3331         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3332                         "parameter(tethering) is NULL\n");
3333
3334         __tethering_h *th = (__tethering_h *)tethering;
3335         th->mac_filter = mac_filter;
3336
3337         return TETHERING_ERROR_NONE;
3338 }
3339
3340 API int tethering_wifi_get_mac_filter(tethering_h tethering, bool *mac_filter)
3341 {
3342         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3343         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3344
3345         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3346                         "parameter(mac_filter) is NULL\n");
3347         _retvm_if(mac_filter == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3348                         "parameter(mac_filter) is NULL\n");
3349
3350         __tethering_h *th = (__tethering_h *)tethering;
3351         *mac_filter = th->mac_filter;
3352
3353         return TETHERING_ERROR_NONE;
3354 }
3355
3356 static int __add_mac_to_file(const char *filepath, const char *mac)
3357 {
3358         FILE *fp = NULL;
3359         char line[MAX_BUF_SIZE] = "\0";
3360         bool mac_exist = false;
3361         char *p_mac = NULL;
3362
3363         p_mac = strdup(mac);
3364         if (p_mac == NULL) {
3365                 ERR("strdup failed\n"); //LCOV_EXCL_LINE
3366                 return TETHERING_ERROR_OUT_OF_MEMORY;
3367         }
3368
3369         fp = fopen(filepath, "a+");
3370         if (!fp) {
3371                 ERR("fopen is failed\n"); //LCOV_EXCL_LINE
3372                 return TETHERING_ERROR_OPERATION_FAILED;
3373         }
3374
3375         while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
3376                 if (strncmp(mac, line, 17) == 0) {
3377                         DBG("MAC %s already exist in the list\n", mac); //LCOV_EXCL_LINE
3378                         mac_exist = true;
3379                         break;
3380                 }
3381         }
3382
3383         if (!mac_exist) {
3384                 fprintf(fp, "%s\n", mac);
3385
3386                 if ((strcmp(filepath, ALLOWED_LIST) == 0))
3387                         allowed_list = g_slist_append(allowed_list, p_mac);
3388                 else if ((strcmp(filepath, BLOCKED_LIST) == 0))
3389                         blocked_list = g_slist_append(blocked_list, p_mac);
3390         }
3391
3392         fclose(fp);
3393
3394         return TETHERING_ERROR_NONE;
3395 }
3396
3397 static int __remove_mac_from_file(const char *filepath, const char *mac)
3398 {
3399         FILE *fp = NULL;
3400         FILE *fp1 = NULL;
3401         char line[MAX_BUF_SIZE] = "\0";
3402
3403         fp = fopen(filepath, "r");
3404         if (!fp) {
3405                 ERR("fopen is failed\n");
3406                 return TETHERING_ERROR_OPERATION_FAILED;
3407         }
3408
3409         fp1 = fopen(TEMP_LIST, "w+");
3410         if (!fp1) {
3411                 fclose(fp);
3412                 ERR("fopen is failed\n");
3413                 return TETHERING_ERROR_OPERATION_FAILED;
3414         }
3415
3416         while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
3417                 if (strncmp(mac, line, 17) == 0) {
3418                         DBG("MAC %s found in the list\n", mac);
3419
3420                         if ((strcmp(filepath, ALLOWED_LIST) == 0)) {
3421                                 GSList *list = NULL;
3422                                 for (list = allowed_list; list != NULL; list = list->next) {
3423                                         char *p_mac = (char *)list->data;
3424                                         if (strncmp(mac, p_mac, strlen(mac)) == 0)
3425                                                 allowed_list = g_slist_remove(allowed_list, p_mac);
3426                                 }
3427                         } else if ((strcmp(filepath, BLOCKED_LIST) == 0)) {
3428                                 GSList *list = NULL;
3429                                 for (list = blocked_list; list != NULL; list = list->next) {
3430                                         char *p_mac = (char *)list->data;
3431                                         if (strncmp(mac, p_mac, strlen(mac)) == 0)
3432                                                 blocked_list = g_slist_remove(blocked_list, p_mac);
3433                                 }
3434                         }
3435                 } else {
3436                         fprintf(fp1, "%s", line);
3437                 }
3438         }
3439
3440         fclose(fp);
3441         fclose(fp1);
3442
3443         if ((strcmp(filepath, ALLOWED_LIST) == 0)) {
3444                 if (rename(TEMP_LIST, ALLOWED_LIST) != 0) {
3445                         ERR("rename is failed (%s -> %s)", TEMP_LIST, ALLOWED_LIST);
3446                         return TETHERING_ERROR_OPERATION_FAILED;
3447                 }
3448         } else if ((strcmp(filepath, BLOCKED_LIST) == 0)) {
3449                 if (rename(TEMP_LIST, BLOCKED_LIST) != 0) {
3450                         ERR("rename is failed (%s -> %s)", TEMP_LIST, BLOCKED_LIST);
3451                         return TETHERING_ERROR_OPERATION_FAILED;
3452                 }
3453         }
3454
3455         return TETHERING_ERROR_NONE;
3456 }
3457
3458 API int tethering_wifi_add_allowed_mac_list(tethering_h tethering, const char *mac)
3459 {
3460         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3461         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3462
3463         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3464                         "parameter(tethering) is NULL\n");
3465         _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3466                         "parameter(mac) is NULL\n");
3467
3468         return __add_mac_to_file(ALLOWED_LIST, mac);
3469 }
3470
3471 API int tethering_wifi_remove_allowed_mac_list(tethering_h tethering, const char *mac)
3472 {
3473         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3474         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3475
3476         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3477                         "parameter(tethering) is NULL\n");
3478         _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3479                         "parameter(mac) is NULL\n");
3480
3481         return __remove_mac_from_file(ALLOWED_LIST, mac);
3482 }
3483
3484 API int tethering_wifi_get_allowed_mac_list(tethering_h tethering, void **allowed_mac_list)
3485 {
3486         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3487         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3488
3489         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3490                         "parameter(tethering) is NULL\n");
3491         _retvm_if(allowed_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3492                         "parameter(allowed_mac_list) is NULL\n");
3493
3494         *allowed_mac_list = g_slist_copy(allowed_list);
3495         return TETHERING_ERROR_NONE;
3496 }
3497
3498 API int tethering_wifi_add_blocked_mac_list(tethering_h tethering, const char *mac)
3499 {
3500         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3501         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3502
3503         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3504                         "parameter(tethering) is NULL\n");
3505         _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3506                         "parameter(mac) is NULL\n");
3507
3508         return __add_mac_to_file(BLOCKED_LIST, mac);
3509 }
3510
3511 API int tethering_wifi_remove_blocked_mac_list(tethering_h tethering, const char *mac)
3512 {
3513         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3514         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3515
3516         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3517                         "parameter(tethering) is NULL\n");
3518         _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3519                         "parameter(mac) is NULL\n");
3520
3521         return __remove_mac_from_file(BLOCKED_LIST, mac);
3522 }
3523
3524 API int tethering_wifi_get_blocked_mac_list(tethering_h tethering, void **blocked_mac_list)
3525 {
3526         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3527         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3528
3529         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3530                         "parameter(tethering) is NULL\n");
3531         _retvm_if(blocked_mac_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3532                         "parameter(blocked_mac_list) is NULL\n");
3533
3534         *blocked_mac_list = g_slist_copy(blocked_list);
3535         return TETHERING_ERROR_NONE;
3536 }
3537
3538 API int tethering_wifi_enable_dhcp(tethering_h tethering, bool enable)
3539 {
3540         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3541         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3542
3543         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3544                         "parameter(tethering) is NULL\n");
3545
3546         GVariant *parameters;
3547         GError *error = NULL;
3548         guint result;
3549
3550         __tethering_h *th = (__tethering_h *)tethering;
3551
3552         GDBusProxy *proxy = th->client_bus_proxy;
3553
3554         parameters = g_dbus_proxy_call_sync(proxy, "enable_dhcp",
3555                         g_variant_new("(b)", enable),
3556                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3557
3558         if (error) {
3559                 //LCOV_EXCL_START
3560                 ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
3561                 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3562                         result = TETHERING_ERROR_PERMISSION_DENIED;
3563                 else
3564                         result = TETHERING_ERROR_OPERATION_FAILED;
3565
3566                 g_error_free(error);
3567                 th->dhcp_enabled = false;
3568
3569                 return result;
3570                 //LCOV_EXCL_STOP
3571         }
3572
3573         g_variant_get(parameters, "(u)", &result);
3574         g_variant_unref(parameters);
3575
3576         if (enable)
3577                 th->dhcp_enabled = true;
3578         else
3579                 th->dhcp_enabled = false;
3580
3581         return TETHERING_ERROR_NONE;
3582 }
3583
3584 API int tethering_wifi_set_dhcp_range(tethering_h tethering, char *rangestart, char *rangestop)
3585 {
3586         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3587         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3588
3589         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3590                         "parameter(tethering) is NULL\n");
3591         _retvm_if(rangestart == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3592                         "parameter(rangestart) is NULL\n");
3593         _retvm_if(rangestop == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3594                         "parameter(rangestop) is NULL\n");
3595
3596         GVariant *parameters;
3597         GError *error = NULL;
3598         guint result;
3599
3600         __tethering_h *th = (__tethering_h *)tethering;
3601
3602         GDBusProxy *proxy = th->client_bus_proxy;
3603
3604         parameters = g_dbus_proxy_call_sync(proxy, "dhcp_range",
3605                         g_variant_new("(ss)", rangestart, rangestop),
3606                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3607         if (error) {
3608                 //LCOV_EXCL_START
3609                 ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
3610
3611                 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3612                         result = TETHERING_ERROR_PERMISSION_DENIED;
3613                 else
3614                         result = TETHERING_ERROR_OPERATION_FAILED;
3615
3616                 g_error_free(error);
3617                 th->dhcp_enabled = false;
3618
3619                 return result;
3620                 //LCOV_EXCL_STOP
3621         }
3622
3623         g_variant_get(parameters, "(u)", &result);
3624         g_variant_unref(parameters);
3625
3626         th->dhcp_enabled = true;
3627
3628         return TETHERING_ERROR_NONE;
3629 }
3630
3631 API int tethering_wifi_is_dhcp_enabled(tethering_h tethering, bool *dhcp_enabled)
3632 {
3633         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3634         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3635
3636         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3637                         "parameter(tethering) is NULL\n");
3638         _retvm_if(dhcp_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3639                         "parameter(dhcp_enabled) is NULL\n");
3640
3641         __tethering_h *th = (__tethering_h *)tethering;
3642         *dhcp_enabled = th->dhcp_enabled;
3643
3644         return TETHERING_ERROR_NONE;
3645 }
3646
3647 API int tethering_wifi_set_txpower(tethering_h tethering, unsigned int txpower)
3648 {
3649         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3650         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3651
3652         GError *error = NULL;
3653
3654         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3655                         "parameter(tethering) is NULL\n");
3656         _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false,
3657                         TETHERING_ERROR_NOT_ENABLED,
3658                         "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
3659         __tethering_h *th = (__tethering_h *)tethering;
3660
3661         g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_set_txpower",
3662                         g_variant_new("(u)", txpower),
3663                         G_DBUS_CALL_FLAGS_NONE,
3664                         -1, th->cancellable, &error);
3665         if (error) {
3666                 //LCOV_EXCL_START
3667                 ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
3668                 g_clear_error(&error);
3669                 return TETHERING_ERROR_OPERATION_FAILED;
3670                 //LCOV_EXCL_STOP
3671         }
3672         return TETHERING_ERROR_NONE;
3673 }
3674
3675 API int tethering_wifi_get_txpower(tethering_h tethering, unsigned int *txpower)
3676 {
3677         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3678         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3679
3680         GError *error = NULL;
3681         GVariant *result = NULL;
3682
3683         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3684                         "parameter(tethering) is NULL\n");
3685         _retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false,
3686                         TETHERING_ERROR_NOT_ENABLED,
3687                         "tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
3688
3689         __tethering_h *th = (__tethering_h *)tethering;
3690
3691         result = g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_get_txpower",
3692                         NULL,
3693                         G_DBUS_CALL_FLAGS_NONE,
3694                         -1, th->cancellable, &error);
3695
3696         if (result != NULL) {
3697                 g_variant_get(result, "(u)", txpower);
3698                 g_variant_unref(result);
3699         } else {
3700                 //LCOV_EXCL_START
3701                 if (error)
3702                         ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
3703                 g_clear_error(&error);
3704                 return TETHERING_ERROR_OPERATION_FAILED;
3705                 //LCOV_EXCL_STOP
3706         }
3707         g_clear_error(&error);
3708         return TETHERING_ERROR_NONE;
3709 }
3710
3711 API int tethering_wifi_set_mtu(tethering_h tethering, unsigned int mtu)
3712 {
3713         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3714         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3715
3716         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3717                         "parameter(tethering) is NULL\n");
3718
3719         GVariant *parameters;
3720         GError *error = NULL;
3721         guint result;
3722
3723         __tethering_h *th = (__tethering_h *)tethering;
3724
3725         GDBusProxy *proxy = th->client_bus_proxy;
3726
3727         parameters = g_dbus_proxy_call_sync(proxy, "set_mtu",
3728                         g_variant_new("(u)", mtu),
3729                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3730         if (error) {
3731                 //LCOV_EXCL_START
3732                 ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
3733
3734                 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3735                         result = TETHERING_ERROR_PERMISSION_DENIED;
3736                 else
3737                         result = TETHERING_ERROR_OPERATION_FAILED;
3738
3739                 g_error_free(error);
3740                 return result;
3741                 //LCOV_EXCL_STOP
3742         }
3743
3744         g_variant_get(parameters, "(u)", &result);
3745
3746         g_variant_unref(parameters);
3747
3748         return TETHERING_ERROR_NONE;
3749 }
3750
3751 API int tethering_wifi_change_mac(tethering_h tethering, char *mac)
3752 {
3753         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3754         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3755
3756         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3757                         "parameter(tethering) is NULL\n");
3758         _retvm_if(mac == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3759                         "parameter(mac) is NULL\n");
3760
3761         GVariant *parameters;
3762         GError *error = NULL;
3763         guint result;
3764
3765         __tethering_h *th = (__tethering_h *)tethering;
3766
3767         GDBusProxy *proxy = th->client_bus_proxy;
3768
3769         parameters = g_dbus_proxy_call_sync(proxy, "change_mac",
3770                         g_variant_new("(s)", mac),
3771                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3772         if (error) {
3773                 //LCOV_EXCL_START
3774                 ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
3775
3776                 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3777                         result = TETHERING_ERROR_PERMISSION_DENIED;
3778                 else
3779                         result = TETHERING_ERROR_OPERATION_FAILED;
3780
3781                 g_error_free(error);
3782                 return result;
3783                 //LCOV_EXCL_STOP
3784         }
3785
3786         g_variant_get(parameters, "(u)", &result);
3787         g_variant_unref(parameters);
3788
3789         if (result == MOBILE_AP_ERROR_NOT_PERMITTED)
3790                 return TETHERING_ERROR_NOT_SUPPORT_API;
3791
3792         return TETHERING_ERROR_NONE;
3793 }
3794
3795 API int tethering_wifi_set_max_connected_device(tethering_h tethering, int max_device)
3796 {
3797         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3798         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3799
3800         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3801                         "parameter(tethering) is NULL\n");
3802
3803         __tethering_h *th = (__tethering_h *)tethering;
3804
3805         th->wifi_max_connected = max_device;
3806
3807         return TETHERING_ERROR_NONE;
3808 }
3809
3810 API int tethering_wifi_get_max_connected_device(tethering_h tethering, int *max_device)
3811 {
3812         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3813         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3814
3815         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3816                         "parameter(tethering) is NULL\n");
3817         _retvm_if(max_device == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3818                         "parameter(max_device) is NULL\n");
3819
3820         __tethering_h *th = (__tethering_h *)tethering;
3821
3822         *max_device = th->wifi_max_connected;
3823         return TETHERING_ERROR_NONE;
3824 }
3825
3826 API int tethering_wifi_enable_port_forwarding(tethering_h tethering, bool enable)
3827 {
3828         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3829         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3830
3831         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3832                         "parameter(tethering) is NULL\n");
3833
3834         GVariant *parameters;
3835         GError *error = NULL;
3836         guint result;
3837
3838         __tethering_h *th = (__tethering_h *)tethering;
3839
3840         GDBusProxy *proxy = th->client_bus_proxy;
3841
3842         parameters = g_dbus_proxy_call_sync(proxy, "enable_port_forwarding",
3843                         g_variant_new("(b)", enable),
3844                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3845         if (error) {
3846                 //LCOV_EXCL_START
3847                 ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
3848
3849                 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3850                         result = TETHERING_ERROR_PERMISSION_DENIED;
3851                 else
3852                         result = TETHERING_ERROR_OPERATION_FAILED;
3853
3854                 g_error_free(error);
3855                 return result;
3856                 //LCOV_EXCL_STOP
3857         }
3858
3859         g_variant_get(parameters, "(u)", &result);
3860         g_variant_unref(parameters);
3861
3862         th->port_forwarding = true;
3863
3864         return TETHERING_ERROR_NONE;
3865 }
3866
3867 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)
3868 {
3869         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3870         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3871
3872         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3873                         "parameter(tethering) is NULL\n");
3874         _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3875                         "parameter(protocol) is NULL\n");
3876
3877         GVariant *parameters;
3878         GError *error = NULL;
3879         guint result;
3880         char cmd[MAX_BUF_SIZE] = { 0, };
3881         char *list = NULL;
3882
3883         __tethering_h *th = (__tethering_h *)tethering;
3884
3885         GDBusProxy *proxy = th->client_bus_proxy;
3886
3887         parameters = g_dbus_proxy_call_sync(proxy, "add_port_forwarding_rule",
3888                         g_variant_new("(sssisi)", ifname, protocol, org_ip, org_port, final_ip, final_port),
3889                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3890         if (error) {
3891                 //LCOV_EXCL_START
3892                 ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
3893
3894                 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3895                         result = TETHERING_ERROR_PERMISSION_DENIED;
3896                 else
3897                         result = TETHERING_ERROR_OPERATION_FAILED;
3898
3899                 g_error_free(error);
3900                 return result;
3901                 //LCOV_EXCL_STOP
3902         }
3903
3904         g_variant_get(parameters, "(u)", &result);
3905         g_variant_unref(parameters);
3906
3907         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);
3908
3909         list = strdup(cmd);
3910         if (list == NULL) {
3911                 ERR("strdup failed\n"); //LCOV_EXCL_LINE
3912                 return TETHERING_ERROR_OUT_OF_MEMORY;
3913         }
3914
3915         port_forwarding = g_slist_append(port_forwarding, list);
3916
3917         return TETHERING_ERROR_NONE;
3918 }
3919
3920 API int tethering_wifi_reset_port_forwarding_rule(tethering_h tethering)
3921 {
3922         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3923         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3924
3925         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3926                         "parameter(tethering) is NULL\n");
3927
3928         GVariant *parameters;
3929         GError *error = NULL;
3930         guint result;
3931
3932         __tethering_h *th = (__tethering_h *)tethering;
3933
3934         GDBusProxy *proxy = th->client_bus_proxy;
3935
3936         parameters = g_dbus_proxy_call_sync(proxy, "reset_port_forwarding_rule",
3937                         NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
3938         if (error) {
3939                 //LCOV_EXCL_START
3940                 ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
3941
3942                 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
3943                         result = TETHERING_ERROR_PERMISSION_DENIED;
3944                 else
3945                         result = TETHERING_ERROR_OPERATION_FAILED;
3946
3947                 g_error_free(error);
3948                 return result;
3949                 //LCOV_EXCL_STOP
3950         }
3951
3952         g_variant_get(parameters, "(u)", &result);
3953
3954         g_variant_unref(parameters);
3955
3956         return TETHERING_ERROR_NONE;
3957 }
3958
3959 API int tethering_wifi_is_port_forwarding_enabled(tethering_h tethering, bool* forwarding_enabled)
3960 {
3961         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3962         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3963
3964         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3965                         "parameter(tethering) is NULL\n");
3966         _retvm_if(forwarding_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3967                         "parameter(forwarding_enabled) is NULL\n");
3968
3969         __tethering_h *th = (__tethering_h *)tethering;
3970
3971         *forwarding_enabled = th->port_forwarding;
3972
3973         return TETHERING_ERROR_NONE;
3974 }
3975
3976 API int tethering_wifi_get_port_forwarding_rule(tethering_h tethering, void **port_forwarding_list)
3977 {
3978         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3979         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3980
3981         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3982                         "parameter(tethering) is NULL\n");
3983         _retvm_if(port_forwarding_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3984                         "parameter(port_forwarding_list) is NULL\n");
3985
3986         *port_forwarding_list = g_slist_copy(port_forwarding);
3987         return TETHERING_ERROR_NONE;
3988 }
3989
3990 API int tethering_wifi_enable_port_filtering(tethering_h tethering, bool enable)
3991 {
3992         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
3993         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
3994
3995         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
3996                         "parameter(tethering) is NULL\n");
3997
3998         GVariant *parameters;
3999         GError *error = NULL;
4000         guint result;
4001
4002         __tethering_h *th = (__tethering_h *)tethering;
4003
4004         GDBusProxy *proxy = th->client_bus_proxy;
4005
4006         parameters = g_dbus_proxy_call_sync(proxy, "enable_port_filtering",
4007                         g_variant_new("(b)", enable),
4008                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4009         if (error) {
4010                 //LCOV_EXCL_START
4011                 ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
4012
4013                 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4014                         result = TETHERING_ERROR_PERMISSION_DENIED;
4015                 else
4016                         result = TETHERING_ERROR_OPERATION_FAILED;
4017
4018                 g_error_free(error);
4019                 return result;
4020                 //LCOV_EXCL_STOP
4021         }
4022
4023         g_variant_get(parameters, "(u)", &result);
4024         g_variant_unref(parameters);
4025
4026         th->port_filtering = true;
4027
4028         return TETHERING_ERROR_NONE;
4029 }
4030
4031 API int tethering_wifi_add_port_filtering_rule(tethering_h tethering, int port, char *protocol, bool allow)
4032 {
4033         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4034         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4035
4036         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4037                         "parameter(tethering) is NULL\n");
4038         _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4039                         "parameter(protocol) is NULL\n");
4040
4041         GVariant *parameters;
4042         GError *error = NULL;
4043         guint result;
4044         char cmd[MAX_BUF_SIZE] = { 0, };
4045         char *list = NULL;
4046
4047         __tethering_h *th = (__tethering_h *)tethering;
4048
4049         GDBusProxy *proxy = th->client_bus_proxy;
4050
4051         parameters = g_dbus_proxy_call_sync(proxy, "add_port_filtering_rule",
4052                         g_variant_new("(isb)", port, protocol, allow),
4053                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4054         if (error) {
4055                 //LCOV_EXCL_START
4056                 ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
4057
4058                 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4059                         result = TETHERING_ERROR_PERMISSION_DENIED;
4060                 else
4061                         result = TETHERING_ERROR_OPERATION_FAILED;
4062
4063                 g_error_free(error);
4064                 return result;
4065                 //LCOV_EXCL_STOP
4066         }
4067
4068         g_variant_get(parameters, "(u)", &result);
4069         g_variant_unref(parameters);
4070
4071         if (allow)
4072                 snprintf(cmd, sizeof(cmd), "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_ACCEPT);
4073         else
4074                 snprintf(cmd, sizeof(cmd), "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_DROP);
4075
4076         DBG("cmd:%s", cmd);
4077
4078         list = strdup(cmd);
4079         if (list == NULL) {
4080                 ERR("strdup failed\n"); //LCOV_EXCL_LINE
4081                 return TETHERING_ERROR_OUT_OF_MEMORY;
4082         }
4083
4084         port_filtering = g_slist_append(port_filtering, list);
4085
4086         return TETHERING_ERROR_NONE;
4087 }
4088
4089 API int tethering_wifi_add_custom_port_filtering_rule(tethering_h tethering, int port1, int port2, char *protocol, bool allow)
4090 {
4091         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4092         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4093
4094         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4095                         "parameter(tethering) is NULL\n");
4096         _retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4097                         "parameter(protocol) is NULL\n");
4098
4099         GVariant *parameters;
4100         GError *error = NULL;
4101         guint result;
4102         char cmd[MAX_BUF_SIZE] = { 0, };
4103         char *list = NULL;
4104
4105         __tethering_h *th = (__tethering_h *)tethering;
4106
4107         GDBusProxy *proxy = th->client_bus_proxy;
4108
4109         parameters = g_dbus_proxy_call_sync(proxy, "add_custom_port_filtering_rule",
4110                         g_variant_new("(iisb)", port1, port2, protocol, allow),
4111                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4112         if (error) {
4113                 //LCOV_EXCL_START
4114                 ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
4115
4116                 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4117                         result = TETHERING_ERROR_PERMISSION_DENIED;
4118                 else
4119                         result = TETHERING_ERROR_OPERATION_FAILED;
4120
4121                 g_error_free(error);
4122                 return result;
4123                 //LCOV_EXCL_STOP
4124         }
4125
4126         g_variant_get(parameters, "(u)", &result);
4127         g_variant_unref(parameters);
4128
4129         if (allow)
4130                 snprintf(cmd, sizeof(cmd), "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_ACCEPT);
4131         else
4132                 snprintf(cmd, sizeof(cmd), "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_DROP);
4133
4134         DBG("cmd:%s", cmd);
4135
4136         list = strdup(cmd);
4137         if (list == NULL) {
4138                 ERR("strdup failed\n"); //LCOV_EXCL_LINE
4139                 return TETHERING_ERROR_OUT_OF_MEMORY;
4140         }
4141
4142         custom_port_filtering = g_slist_append(custom_port_filtering, list);
4143
4144         return TETHERING_ERROR_NONE;
4145 }
4146
4147 API int tethering_wifi_get_port_filtering_rule(tethering_h tethering, void **port_filtering_list)
4148 {
4149         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4150         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4151
4152         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4153                         "parameter(tethering) is NULL\n");
4154         _retvm_if(port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4155                         "parameter(port_filtering_list) is NULL\n");
4156
4157         *port_filtering_list = g_slist_copy(port_filtering);
4158         return TETHERING_ERROR_NONE;
4159 }
4160
4161 API int tethering_wifi_get_custom_port_filtering_rule(tethering_h tethering, void **custom_port_filtering_list)
4162 {
4163         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4164         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4165
4166         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4167                         "parameter(tethering) is NULL\n");
4168         _retvm_if(custom_port_filtering_list == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4169                         "parameter(custom_port_filtering_list) is NULL\n");
4170
4171         *custom_port_filtering_list = g_slist_copy(custom_port_filtering);
4172         return TETHERING_ERROR_NONE;
4173 }
4174
4175 API int tethering_wifi_is_port_filtering_enabled(tethering_h tethering, bool* filtering_enabled)
4176 {
4177         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4178         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4179
4180         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4181                         "parameter(tethering) is NULL\n");
4182         _retvm_if(filtering_enabled == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4183                         "parameter(filtering_enabled) is NULL\n");
4184
4185         __tethering_h *th = (__tethering_h *)tethering;
4186
4187         *filtering_enabled = th->port_filtering;
4188
4189         return TETHERING_ERROR_NONE;
4190 }
4191
4192 API int tethering_wifi_set_vpn_passthrough_rule(tethering_h tethering, tethering_vpn_passthrough_type_e type, bool enable)
4193 {
4194         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4195         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4196
4197         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4198                         "parameter(tethering) is NULL\n");
4199
4200         GVariant *parameters;
4201         GError *error = NULL;
4202         guint result;
4203
4204         __tethering_h *th = (__tethering_h *)tethering;
4205
4206         GDBusProxy *proxy = th->client_bus_proxy;
4207
4208         parameters = g_dbus_proxy_call_sync(proxy, "set_vpn_passthrough_rule",
4209                         g_variant_new("(ib)", type, enable),
4210                         G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4211         if (error) {
4212                 //LCOV_EXCL_START
4213                 ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
4214
4215                 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4216                         result = TETHERING_ERROR_PERMISSION_DENIED;
4217                 else
4218                         result = TETHERING_ERROR_OPERATION_FAILED;
4219
4220                 g_error_free(error);
4221                 return result;
4222                 //LCOV_EXCL_STOP
4223         }
4224
4225         g_variant_get(parameters, "(u)", &result);
4226
4227         g_variant_unref(parameters);
4228
4229         return TETHERING_ERROR_NONE;
4230 }
4231
4232 API int tethering_wifi_push_wps_button(tethering_h tethering)
4233 {
4234         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4235         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4236
4237         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4238                         "parameter(tethering) is NULL");
4239         __tethering_h *th = (__tethering_h *)tethering;
4240         GDBusProxy *proxy = th->client_bus_proxy;
4241         GVariant *parameters = NULL;
4242         int ret = 0;
4243         GError *error = NULL;
4244
4245         parameters = g_dbus_proxy_call_sync(proxy, "push_wps_button",
4246                         NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4247
4248         if (error) {
4249                 //LCOV_EXCL_START
4250                 ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
4251
4252                 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4253                         ret = TETHERING_ERROR_PERMISSION_DENIED;
4254                 else
4255                         ret = TETHERING_ERROR_OPERATION_FAILED;
4256
4257                 g_error_free(error);
4258                 return ret;
4259                 //LCOV_EXCL_STOP
4260         }
4261
4262         if (parameters != NULL) {
4263                 g_variant_get(parameters, "(u)", &ret);
4264                 g_variant_unref(parameters);
4265         }
4266
4267         return TETHERING_ERROR_NONE;
4268 }
4269
4270 API int tethering_wifi_set_wps_pin(tethering_h tethering, const char *wps_pin)
4271 {
4272         CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
4273         CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
4274
4275         _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
4276                         "parameter(tethering) is NULL");
4277         __tethering_h *th = (__tethering_h *)tethering;
4278         GDBusProxy *proxy = th->client_bus_proxy;
4279         GVariant *parameters = NULL;
4280         int ret = 0;
4281         GError *error = NULL;
4282
4283         parameters = g_dbus_proxy_call_sync(proxy, "set_wps_pin",
4284                         g_variant_new("(s)", wps_pin), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
4285
4286         if (error) {
4287                 //LCOV_EXCL_START
4288                 ERR("g_dbus_proxy_call_sync failed because  %s\n", error->message);
4289
4290                 if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
4291                         ret = TETHERING_ERROR_PERMISSION_DENIED;
4292                 else
4293                         ret = TETHERING_ERROR_OPERATION_FAILED;
4294
4295                 g_error_free(error);
4296                 return ret;
4297                 //LCOV_EXCL_STOP
4298         }
4299
4300         if (parameters != NULL) {
4301                 g_variant_get(parameters, "(u)", &ret);
4302                 g_variant_unref(parameters);
4303         }
4304
4305         return TETHERING_ERROR_NONE;
4306 }
4307
4308