src/connection.c

   1 /*
   2  * Copyright (c) 2011-2013 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 <glib.h>
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <vconf/vconf.h>
  22 #include <system_info.h>
  23
  24 #include "net_connection_private.h"
  25
  26 static GSList *conn_handle_list = NULL;
  27 static int tv_profile = -1; // Unknown
  28
  29 //LCOV_EXCL_START
  30 static int __connection_convert_net_state(int status)
  31 {
  32         switch (status) {
  33         case VCONFKEY_NETWORK_CELLULAR:
  34                 return CONNECTION_TYPE_CELLULAR;
  35         case VCONFKEY_NETWORK_WIFI:
  36                 return CONNECTION_TYPE_WIFI;
  37         case VCONFKEY_NETWORK_ETHERNET:
  38                 return CONNECTION_TYPE_ETHERNET;
  39         case VCONFKEY_NETWORK_BLUETOOTH:
  40                 return CONNECTION_TYPE_BT;
  41         case VCONFKEY_NETWORK_DEFAULT_PROXY:
  42                 return CONNECTION_TYPE_NET_PROXY;
  43         default:
  44                 return CONNECTION_TYPE_DISCONNECTED;
  45         }
  46 }
  47
  48 static int __connection_convert_cellular_state(int status)
  49 {
  50         switch (status) {
  51         case VCONFKEY_NETWORK_CELLULAR_ON:
  52                 return CONNECTION_CELLULAR_STATE_AVAILABLE;
  53         case VCONFKEY_NETWORK_CELLULAR_3G_OPTION_OFF:
  54                 return CONNECTION_CELLULAR_STATE_CALL_ONLY_AVAILABLE;
  55         case VCONFKEY_NETWORK_CELLULAR_ROAMING_OFF:
  56                 return CONNECTION_CELLULAR_STATE_ROAMING_OFF;
  57         case VCONFKEY_NETWORK_CELLULAR_FLIGHT_MODE:
  58                 return CONNECTION_CELLULAR_STATE_FLIGHT_MODE;
  59         default:
  60                 return CONNECTION_CELLULAR_STATE_OUT_OF_SERVICE;
  61         }
  62 }
  63
  64 static bool __connection_check_handle_validity(connection_h connection)
  65 {
  66         bool ret = false;
  67
  68         if (connection == NULL)
  69                 return false;
  70
  71         if (g_slist_find(conn_handle_list, connection) != NULL)
  72                 ret = true;
  73
  74         return ret;
  75 }
  76
  77 bool _connection_check_handle_validity(connection_h connection)
  78 {
  79         return __connection_check_handle_validity(connection);
  80 }
  81
  82 static int __connection_set_type_changed_callback(connection_handle_s *conn_handle,
  83                         void *callback, void *user_data)
  84 {
  85         conn_handle->type_changed_user_data = user_data;
  86         conn_handle->type_changed_callback = callback;
  87
  88         return CONNECTION_ERROR_NONE;
  89 }
  90
  91 static int __connection_set_ip_changed_callback(connection_handle_s *conn_handle,
  92                         void *callback, void *user_data)
  93 {
  94         conn_handle->ip_changed_user_data = user_data;
  95         conn_handle->ip_changed_callback = callback;
  96
  97         return CONNECTION_ERROR_NONE;
  98 }
  99
 100 static int __connection_set_proxy_changed_callback(connection_handle_s *conn_handle,
 101                         void *callback, void *user_data)
 102 {
 103         conn_handle->proxy_changed_user_data = user_data;
 104         conn_handle->proxy_changed_callback = callback;
 105
 106         return CONNECTION_ERROR_NONE;
 107 }
 108
 109 static int __connection_set_ethernet_cable_state_changed_cb(connection_handle_s *conn_handle,
 110                         void *callback, void *user_data)
 111 {
 112         conn_handle->ethernet_cable_state_changed_callback = callback;
 113         conn_handle->ethernet_cable_state_changed_user_data = user_data;
 114
 115         return CONNECTION_ERROR_NONE;
 116 }
 117
 118 static int __connection_set_default_cellular_service_profile_callback(connection_handle_s *conn_handle,
 119                         void *callback, void *user_data)
 120 {
 121         conn_handle->set_default_callback = callback;
 122         conn_handle->set_default_user_data = user_data;
 123
 124         return CONNECTION_ERROR_NONE;
 125 }
 126
 127 static int __connection_open_profile_set_callback(connection_handle_s *conn_handle,
 128                         void *callback, void *user_data)
 129 {
 130         conn_handle->opened_callback = callback;
 131         conn_handle->opened_user_data = user_data;
 132
 133         return CONNECTION_ERROR_NONE;
 134 }
 135
 136 static int __connection_close_profile_set_callback(connection_handle_s *conn_handle,
 137                         void *callback, void *user_data)
 138 {
 139         conn_handle->closed_callback = callback;
 140         conn_handle->closed_user_data = user_data;
 141
 142         return CONNECTION_ERROR_NONE;
 143 }
 144
 145 static int __connection_reset_profile_set_callback(connection_handle_s *conn_handle,
 146                         void *callback, void *user_data)
 147 {
 148         conn_handle->reset_callback = callback;
 149         conn_handle->reset_user_data = user_data;
 150
 151         return CONNECTION_ERROR_NONE;
 152 }
 153 //LCOV_EXCL_STOP
 154
 155 /* Connection Manager ********************************************************/
 156 EXPORT_API int connection_create(connection_h *connection)
 157 {
 158         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 159
 160         int rv;
 161
 162         if (connection == NULL || __connection_check_handle_validity(*connection)) {
 163                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 164                 return CONNECTION_ERROR_INVALID_PARAMETER;
 165         }
 166
 167         *connection = g_try_malloc0(sizeof(connection_handle_s));
 168         if (*connection != NULL)
 169                 CONNECTION_LOG(CONNECTION_INFO, "New handle created[%p]", *connection);
 170         else
 171                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 172
 173         rv = _connection_libnet_init(*connection);
 174         if (rv == NET_ERR_ACCESS_DENIED) {
 175                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 176                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 177         } else if (rv != NET_ERR_NONE) {
 178                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create connection[%d]", rv); //LCOV_EXCL_LINE
 179                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 180         }
 181
 182         conn_handle_list = g_slist_prepend(conn_handle_list, *connection);
 183
 184         return CONNECTION_ERROR_NONE;
 185 }
 186
 187 EXPORT_API int connection_destroy(connection_h connection)
 188 {
 189         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 190
 191         if (!(__connection_check_handle_validity(connection))) {
 192                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 193                 return CONNECTION_ERROR_INVALID_PARAMETER;
 194         }
 195
 196         CONNECTION_LOG(CONNECTION_INFO, "Destroy handle: %p", connection);
 197
 198         __connection_set_type_changed_callback(connection, NULL, NULL);
 199         __connection_set_ip_changed_callback(connection, NULL, NULL);
 200         __connection_set_proxy_changed_callback(connection, NULL, NULL);
 201         __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
 202         _connection_libnet_deinit(connection);
 203
 204         conn_handle_list = g_slist_remove(conn_handle_list, connection);
 205
 206         g_free(connection);
 207         connection = NULL;
 208
 209         return CONNECTION_ERROR_NONE;
 210 }
 211
 212 EXPORT_API int connection_create_cs(int tid, connection_h *connection)
 213 {
 214         int rv;
 215
 216         rv = connection_create(connection);
 217         if (rv == CONNECTION_ERROR_NONE)
 218                 _connection_set_cs_tid(tid, *connection);
 219
 220         return rv;
 221 }
 222
 223 EXPORT_API int connection_destroy_cs(int tid, connection_h connection)
 224 {
 225         int rv;
 226
 227         _connection_unset_cs_tid(tid, connection);
 228         rv = connection_destroy(connection);
 229
 230         return rv;
 231 }
 232
 233 EXPORT_API int connection_get_type(connection_h connection, connection_type_e* type)
 234 {
 235         int rv = 0;
 236         int status = 0;
 237
 238         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 239
 240         if (type == NULL || !(__connection_check_handle_validity(connection))) {
 241                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 242                 return CONNECTION_ERROR_INVALID_PARAMETER;
 243         }
 244
 245         rv = vconf_get_int(VCONFKEY_NETWORK_STATUS, &status);
 246         if (rv != VCONF_OK) {
 247                 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed = %d", status); //LCOV_EXCL_LINE
 248                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 249         }
 250
 251         CONNECTION_LOG(CONNECTION_INFO, "Connected Network = %d", status);
 252
 253         *type = __connection_convert_net_state(status);
 254
 255         return CONNECTION_ERROR_NONE;
 256 }
 257
 258 EXPORT_API int connection_get_ip_address(connection_h connection,
 259                                 connection_address_family_e address_family, char** ip_address)
 260 {
 261         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 262
 263         if (ip_address == NULL || !(__connection_check_handle_validity(connection))) {
 264                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 265                 return CONNECTION_ERROR_INVALID_PARAMETER;
 266         }
 267
 268         switch (address_family) {
 269         case CONNECTION_ADDRESS_FAMILY_IPV4:
 270                 *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP);
 271                 break;
 272         case CONNECTION_ADDRESS_FAMILY_IPV6:
 273                 *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP6);
 274                 break;
 275         default:
 276                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 277                 return CONNECTION_ERROR_INVALID_PARAMETER;
 278         }
 279
 280         if (*ip_address == NULL) {
 281                 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE
 282                 return CONNECTION_ERROR_OPERATION_FAILED;//LCOV_EXCL_LINE
 283         }
 284
 285         return CONNECTION_ERROR_NONE;
 286 }
 287
 288 EXPORT_API int connection_get_proxy(connection_h connection,
 289                                 connection_address_family_e address_family, char** proxy)
 290 {
 291         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 292
 293         if (proxy == NULL || !(__connection_check_handle_validity(connection))) {
 294                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 295                 return CONNECTION_ERROR_INVALID_PARAMETER;
 296         }
 297
 298         switch (address_family) {
 299         case CONNECTION_ADDRESS_FAMILY_IPV4:
 300         case CONNECTION_ADDRESS_FAMILY_IPV6:
 301                 *proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
 302                 break;
 303         default:
 304                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 305                 return CONNECTION_ERROR_INVALID_PARAMETER;
 306         }
 307
 308         if (*proxy == NULL) {
 309                 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE
 310                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 311         }
 312
 313         return CONNECTION_ERROR_NONE;
 314 }
 315
 316 EXPORT_API int connection_get_mac_address(connection_h connection, connection_type_e type, char** mac_addr)
 317 {
 318         FILE *fp;
 319         char buf[CONNECTION_MAC_INFO_LENGTH + 1];
 320
 321         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE, ETHERNET_FEATURE);
 322
 323         if (type == CONNECTION_TYPE_WIFI)
 324                 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 325         else if (type == CONNECTION_TYPE_ETHERNET) //LCOV_EXCL_LINE
 326                 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE); //LCOV_EXCL_LINE
 327
 328         if (mac_addr == NULL || !(__connection_check_handle_validity(connection))) {
 329                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 330                 return CONNECTION_ERROR_INVALID_PARAMETER;
 331         }
 332
 333         switch (type) {
 334         case CONNECTION_TYPE_WIFI:
 335                 if (__builtin_expect(tv_profile == -1, 0)) {
 336                         char *profileName;
 337                         system_info_get_platform_string("http://tizen.org/feature/profile", &profileName);
 338                         if (*profileName == 't' || *profileName == 'T')
 339                                 tv_profile = 1;
 340                         else
 341                                 tv_profile = 0;
 342                         free(profileName);
 343                 }
 344                 if (tv_profile == 1) {
 345                         fp = fopen(WIFI_MAC_INFO_FILE, "r");
 346                         if (fp == NULL) {
 347                                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", WIFI_MAC_INFO_FILE); //LCOV_EXCL_LINE
 348                                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 349                         }
 350
 351                         if (fgets(buf, sizeof(buf), fp) == NULL) {
 352                                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", WIFI_MAC_INFO_FILE); //LCOV_EXCL_LINE
 353                                 fclose(fp); //LCOV_EXCL_LINE
 354                                 return CONNECTION_ERROR_OPERATION_FAILED;
 355                         }
 356
 357                         CONNECTION_LOG(CONNECTION_INFO, "%s : %s", WIFI_MAC_INFO_FILE, buf);
 358
 359                         *mac_addr = (char *)malloc(CONNECTION_MAC_INFO_LENGTH + 1);
 360                         if (*mac_addr == NULL) {
 361                                 CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed"); //LCOV_EXCL_LINE
 362                                 fclose(fp); //LCOV_EXCL_LINE
 363                                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 364                         }
 365                         g_strlcpy(*mac_addr, buf, CONNECTION_MAC_INFO_LENGTH + 1);
 366                         fclose(fp);
 367                 } else {
 368                         *mac_addr = vconf_get_str(VCONFKEY_WIFI_BSSID_ADDRESS);
 369
 370                         if (*mac_addr == NULL) {
 371                                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get vconf from %s", VCONFKEY_WIFI_BSSID_ADDRESS); //LCOV_EXCL_LINE
 372                                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 373                         }
 374                 }
 375                 break;
 376         //LCOV_EXCL_START
 377         case CONNECTION_TYPE_ETHERNET:
 378                 fp = fopen(ETHERNET_MAC_INFO_FILE, "r");
 379                 if (fp == NULL) {
 380                         CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", ETHERNET_MAC_INFO_FILE);
 381                         return CONNECTION_ERROR_OUT_OF_MEMORY;
 382                 }
 383
 384                 if (fgets(buf, sizeof(buf), fp) == NULL) {
 385                         CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", ETHERNET_MAC_INFO_FILE);
 386                         fclose(fp);
 387                         return CONNECTION_ERROR_OPERATION_FAILED;
 388                 }
 389
 390                 CONNECTION_LOG(CONNECTION_INFO, "%s : %s", ETHERNET_MAC_INFO_FILE, buf);
 391
 392                 *mac_addr = (char *)malloc(CONNECTION_MAC_INFO_LENGTH + 1);
 393                 if (*mac_addr == NULL) {
 394                         CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed");
 395                         fclose(fp);
 396                         return CONNECTION_ERROR_OUT_OF_MEMORY;
 397                 }
 398
 399                 g_strlcpy(*mac_addr, buf, CONNECTION_MAC_INFO_LENGTH + 1);
 400                 fclose(fp);
 401
 402                 break;
 403         //LCOV_EXCL_STOP
 404         default:
 405                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 406                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 407         }
 408
 409         /* Checking Invalid MAC Address */
 410         if ((strcmp(*mac_addr, "00:00:00:00:00:00") == 0) ||
 411                         (strcmp(*mac_addr, "ff:ff:ff:ff:ff:ff") == 0)) {
 412                 CONNECTION_LOG(CONNECTION_ERROR, "MAC Address(%s) is invalid", *mac_addr); //LCOV_EXCL_LINE
 413                 return CONNECTION_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
 414         }
 415
 416         CONNECTION_LOG(CONNECTION_INFO, "MAC Address %s", *mac_addr);
 417
 418         return CONNECTION_ERROR_NONE;
 419 }
 420
 421
 422 EXPORT_API int connection_is_metered_network(connection_h connection, bool* is_metered)
 423 {
 424         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 425
 426         if (is_metered == NULL || !(__connection_check_handle_validity(connection))) {
 427                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 428                 return CONNECTION_ERROR_INVALID_PARAMETER;
 429         }
 430
 431         int rv = _connection_libnet_get_metered_state(connection, is_metered);
 432         if (rv != CONNECTION_ERROR_NONE) {
 433                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get metered state[%d]", rv); //LCOV_EXCL_LINE
 434                 return rv; //LCOV_EXCL_LINE
 435         }
 436
 437         CONNECTION_LOG(CONNECTION_INFO, "metered state: %s", is_metered ? "true" : "false");
 438         return CONNECTION_ERROR_NONE;
 439 }
 440
 441
 442 EXPORT_API int connection_get_cellular_state(connection_h connection, connection_cellular_state_e* state)
 443 {
 444         int rv = 0;
 445         int status = 0;
 446         int cellular_state = 0;
 447 #if defined TIZEN_DUALSIM_ENABLE
 448         int sim_id = 0;
 449 #endif
 450
 451         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 452
 453         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 454                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 455                 return CONNECTION_ERROR_INVALID_PARAMETER;
 456         }
 457
 458         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &status);
 459         if (rv != VCONF_OK) {
 460                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
 461                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 462         }
 463
 464         CONNECTION_LOG(CONNECTION_INFO, "Cellular: %d", status);
 465         *state = __connection_convert_cellular_state(status);
 466
 467         if (*state == CONNECTION_CELLULAR_STATE_AVAILABLE) {
 468 #if defined TIZEN_DUALSIM_ENABLE
 469                 rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id);
 470                 if (rv != VCONF_OK) {
 471                         CONNECTION_LOG(CONNECTION_ERROR,
 472                                         "Failed to get default subscriber id", sim_id);
 473                         return CONNECTION_ERROR_OPERATION_FAILED;
 474                 }
 475
 476                 switch (sim_id) {
 477                 case CONNECTION_CELLULAR_SUBSCRIBER_1:
 478 #endif
 479                         rv = vconf_get_int(VCONFKEY_DNET_STATE, &cellular_state);
 480 #if defined TIZEN_DUALSIM_ENABLE
 481                         break;
 482
 483                 case CONNECTION_CELLULAR_SUBSCRIBER_2:
 484                         rv = vconf_get_int(VCONFKEY_DNET_STATE2, &cellular_state);
 485                         break;
 486
 487                 default:
 488                         CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
 489                         return CONNECTION_ERROR_OPERATION_FAILED;
 490                 }
 491 #endif
 492                 if (rv != VCONF_OK) {
 493                         CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
 494                         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 495                 }
 496         }
 497
 498         CONNECTION_LOG(CONNECTION_INFO, "Cellular state: %d", cellular_state);
 499
 500         if (cellular_state == VCONFKEY_DNET_NORMAL_CONNECTED ||
 501                         cellular_state == VCONFKEY_DNET_SECURE_CONNECTED ||
 502                         cellular_state == VCONFKEY_DNET_TRANSFER)
 503                 *state = CONNECTION_CELLULAR_STATE_CONNECTED;
 504
 505         return CONNECTION_ERROR_NONE;
 506 }
 507
 508 EXPORT_API int connection_get_wifi_state(connection_h connection, connection_wifi_state_e* state)
 509 {
 510         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 511
 512         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 513                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 514                 return CONNECTION_ERROR_INVALID_PARAMETER;
 515         }
 516
 517         int rv = _connection_libnet_get_wifi_state(connection, state);
 518         if (rv != CONNECTION_ERROR_NONE) {
 519                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get Wi-Fi state[%d]", rv); //LCOV_EXCL_LINE
 520                 return rv; //LCOV_EXCL_LINE
 521         }
 522
 523         CONNECTION_LOG(CONNECTION_INFO, "Wi-Fi state: %d", *state);
 524
 525         return CONNECTION_ERROR_NONE;
 526 }
 527
 528 //LCOV_EXCL_START
 529 EXPORT_API int connection_get_ethernet_state(connection_h connection, connection_ethernet_state_e *state)
 530 {
 531         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 532
 533         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 534                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 535                 return CONNECTION_ERROR_INVALID_PARAMETER;
 536         }
 537
 538         return _connection_libnet_get_ethernet_state(connection, state);
 539 }
 540
 541 EXPORT_API int connection_get_ethernet_cable_state(connection_h connection, connection_ethernet_cable_state_e *state)
 542 {
 543         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 544
 545         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 546                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 547                 return CONNECTION_ERROR_INVALID_PARAMETER;
 548         }
 549
 550         return _connection_libnet_get_ethernet_cable_state(connection, state);
 551 }
 552
 553 EXPORT_API int connection_set_ethernet_cable_state_chaged_cb(connection_h connection,
 554                           connection_ethernet_cable_state_chaged_cb callback, void *user_data)
 555 {
 556         DEPRECATED_LOG(__FUNCTION__, "connection_set_ethernet_cable_state_changed_cb");
 557         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 558
 559         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 560                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 561                 return CONNECTION_ERROR_INVALID_PARAMETER;
 562         }
 563
 564         DEPRECATED_LOG("connection_ethernet_cable_state_chaged_cb",
 565                         "connection_ethernet_cable_state_changed_cb");
 566
 567         return __connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data);
 568 }
 569
 570 EXPORT_API int connection_unset_ethernet_cable_state_chaged_cb(connection_h connection)
 571 {
 572         DEPRECATED_LOG(__FUNCTION__, "connection_unset_ethernet_cable_state_changed_cb");
 573         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 574
 575         if (!(__connection_check_handle_validity(connection))) {
 576                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 577                 return CONNECTION_ERROR_INVALID_PARAMETER;
 578         }
 579
 580         return __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
 581 }
 582
 583 EXPORT_API int connection_set_ethernet_cable_state_changed_cb(connection_h connection,
 584                           connection_ethernet_cable_state_changed_cb callback, void *user_data)
 585 {
 586         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 587
 588         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 589                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 590                 return CONNECTION_ERROR_INVALID_PARAMETER;
 591         }
 592
 593         return __connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data);
 594 }
 595
 596 EXPORT_API int connection_unset_ethernet_cable_state_changed_cb(connection_h connection)
 597 {
 598         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 599
 600         if (!(__connection_check_handle_validity(connection))) {
 601                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 602                 return CONNECTION_ERROR_INVALID_PARAMETER;
 603         }
 604
 605         return __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
 606 }
 607 //LCOV_EXCL_STOP
 608
 609 EXPORT_API int connection_get_bt_state(connection_h connection, connection_bt_state_e *state)
 610 {
 611         CHECK_FEATURE_SUPPORTED(TETHERING_BLUETOOTH_FEATURE);
 612
 613         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 614                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 615                 return CONNECTION_ERROR_INVALID_PARAMETER;
 616         }
 617
 618         return _connection_libnet_get_bluetooth_state(connection, state);
 619 }
 620
 621 EXPORT_API int connection_set_type_changed_cb(connection_h connection,
 622                                         connection_type_changed_cb callback, void* user_data)
 623 {
 624         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 625
 626         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 627                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 628                 return CONNECTION_ERROR_INVALID_PARAMETER;
 629         }
 630
 631         return __connection_set_type_changed_callback(connection, callback, user_data);
 632 }
 633
 634 EXPORT_API int connection_unset_type_changed_cb(connection_h connection)
 635 {
 636         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 637
 638         if (!(__connection_check_handle_validity(connection))) {
 639                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 640                 return CONNECTION_ERROR_INVALID_PARAMETER;
 641         }
 642
 643         return __connection_set_type_changed_callback(connection, NULL, NULL);
 644 }
 645
 646 EXPORT_API int connection_set_ip_address_changed_cb(connection_h connection,
 647                                 connection_address_changed_cb callback, void* user_data)
 648 {
 649         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 650
 651         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 652                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 653                 return CONNECTION_ERROR_INVALID_PARAMETER;
 654         }
 655
 656         return __connection_set_ip_changed_callback(connection, callback, user_data);
 657 }
 658
 659 EXPORT_API int connection_unset_ip_address_changed_cb(connection_h connection)
 660 {
 661         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 662
 663         if (!(__connection_check_handle_validity(connection))) {
 664                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 665                 return CONNECTION_ERROR_INVALID_PARAMETER;
 666         }
 667
 668         return __connection_set_ip_changed_callback(connection, NULL, NULL);
 669 }
 670
 671 EXPORT_API int connection_set_proxy_address_changed_cb(connection_h connection,
 672                                 connection_address_changed_cb callback, void* user_data)
 673 {
 674         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 675
 676         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 677                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 678                 return CONNECTION_ERROR_INVALID_PARAMETER;
 679         }
 680
 681         return __connection_set_proxy_changed_callback(connection, callback, user_data);
 682 }
 683
 684 EXPORT_API int connection_unset_proxy_address_changed_cb(connection_h connection)
 685 {
 686         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 687
 688         if (!(__connection_check_handle_validity(connection))) {
 689                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 690                 return CONNECTION_ERROR_INVALID_PARAMETER;
 691         }
 692
 693         return __connection_set_proxy_changed_callback(connection, NULL, NULL);
 694 }
 695
 696 EXPORT_API int connection_add_profile(connection_h connection, connection_profile_h profile)
 697 {
 698         int rv = 0;
 699         connection_handle_s *conn_handle = (connection_handle_s *)connection;
 700         net_profile_info_t *profile_info = (net_profile_info_t *)profile;
 701
 702         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 703
 704         if (!(__connection_check_handle_validity(connection)) ||
 705             !(_connection_libnet_check_profile_validity(profile))) {
 706                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 707                 return CONNECTION_ERROR_INVALID_PARAMETER;
 708         }
 709
 710         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
 711                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 712                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 713         }
 714
 715         if (profile_info->ProfileInfo.Pdp.PSModemPath[0] != '/' ||
 716                         strlen(profile_info->ProfileInfo.Pdp.PSModemPath) < 2) {
 717                 CONNECTION_LOG(CONNECTION_ERROR, "Modem object path is NULL"); //LCOV_EXCL_LINE
 718                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 719         }
 720
 721         rv = net_add_profile(conn_handle->network_info_handle,
 722                                 profile_info->ProfileInfo.Pdp.ServiceType, profile_info);
 723         if (rv == NET_ERR_ACCESS_DENIED) {
 724                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 725                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 726         } else if (rv != NET_ERR_NONE) {
 727                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to add profile[%d]", rv); //LCOV_EXCL_LINE
 728                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 729         }
 730
 731         return CONNECTION_ERROR_NONE;
 732 }
 733
 734 EXPORT_API int connection_remove_profile(connection_h connection, connection_profile_h profile)
 735 {
 736         int rv = 0;
 737         connection_handle_s *conn_handle = (connection_handle_s *)connection;
 738         net_profile_info_t *profile_info = (net_profile_info_t *)profile;
 739
 740         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
 741
 742         if (!(__connection_check_handle_validity(connection)) ||
 743                 !(_connection_libnet_check_profile_validity(profile))) {
 744                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 745                 return CONNECTION_ERROR_INVALID_PARAMETER;
 746         }
 747
 748         if (profile_info->profile_type != NET_DEVICE_CELLULAR &&
 749                 profile_info->profile_type != NET_DEVICE_MESH &&
 750             profile_info->profile_type != NET_DEVICE_WIFI) {
 751                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 752                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 753         }
 754
 755         rv = net_delete_profile(conn_handle->network_info_handle, profile_info->ProfileName);
 756         if (rv == NET_ERR_ACCESS_DENIED) {
 757                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 758                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 759         } else if (rv != NET_ERR_NONE) {
 760                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to delete profile[%d]", rv); //LCOV_EXCL_LINE
 761                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 762         }
 763
 764         return CONNECTION_ERROR_NONE;
 765 }
 766
 767 EXPORT_API int connection_update_profile(connection_h connection, connection_profile_h profile)
 768 {
 769         int rv = 0;
 770         connection_handle_s *conn_handle = (connection_handle_s *)connection;
 771         net_profile_info_t *profile_info = (net_profile_info_t *)profile;
 772
 773         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
 774
 775         if (!(__connection_check_handle_validity(connection)) ||
 776             !(_connection_libnet_check_profile_validity(profile))) {
 777                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 778                 return CONNECTION_ERROR_INVALID_PARAMETER;
 779         }
 780
 781         rv = net_modify_profile(conn_handle->network_info_handle,
 782                         profile_info->ProfileName, (net_profile_info_t*)profile);
 783         if (rv == NET_ERR_ACCESS_DENIED) {
 784                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 785                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 786         } else if (rv != NET_ERR_NONE) {
 787                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to modify profile[%d]", rv); //LCOV_EXCL_LINE
 788                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 789         }
 790
 791         return CONNECTION_ERROR_NONE;
 792 }
 793
 794 EXPORT_API int connection_get_profile_iterator(connection_h connection,
 795                 connection_iterator_type_e type, connection_profile_iterator_h* profile_iterator)
 796 {
 797         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 798
 799         if (!(__connection_check_handle_validity(connection)) ||
 800             (type != CONNECTION_ITERATOR_TYPE_REGISTERED &&
 801              type != CONNECTION_ITERATOR_TYPE_CONNECTED &&
 802              type != CONNECTION_ITERATOR_TYPE_DEFAULT)) {
 803                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 804                 return CONNECTION_ERROR_INVALID_PARAMETER;
 805         }
 806
 807         return _connection_libnet_get_profile_iterator(connection, type, profile_iterator);
 808 }
 809
 810 EXPORT_API int connection_profile_iterator_next(connection_profile_iterator_h profile_iterator,
 811                                                         connection_profile_h* profile)
 812 {
 813         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 814
 815         return _connection_libnet_get_iterator_next(profile_iterator, profile);
 816 }
 817
 818 EXPORT_API bool connection_profile_iterator_has_next(connection_profile_iterator_h profile_iterator)
 819 {
 820         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 821
 822         return _connection_libnet_iterator_has_next(profile_iterator);
 823 }
 824
 825 EXPORT_API int connection_destroy_profile_iterator(connection_profile_iterator_h profile_iterator)
 826 {
 827         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 828
 829         return _connection_libnet_destroy_iterator(profile_iterator);
 830 }
 831
 832 EXPORT_API int connection_get_current_profile(connection_h connection, connection_profile_h* profile)
 833 {
 834         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 835
 836         if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
 837                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 838                 return CONNECTION_ERROR_INVALID_PARAMETER;
 839         }
 840
 841         return _connection_libnet_get_current_profile(connection, profile);
 842 }
 843
 844 EXPORT_API int connection_get_default_cellular_service_profile(
 845                 connection_h connection, connection_cellular_service_type_e type,
 846                 connection_profile_h *profile)
 847 {
 848         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 849
 850         if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
 851                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 852                 return CONNECTION_ERROR_INVALID_PARAMETER;
 853         }
 854
 855         return _connection_libnet_get_cellular_service_profile(connection, type, profile);
 856 }
 857
 858 EXPORT_API int connection_set_default_cellular_service_profile(connection_h connection,
 859                 connection_cellular_service_type_e type, connection_profile_h profile)
 860 {
 861         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 862
 863         if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
 864                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 865                 return CONNECTION_ERROR_INVALID_PARAMETER;
 866         }
 867
 868         return _connection_libnet_set_cellular_service_profile_sync(connection, type, profile);
 869 }
 870
 871 EXPORT_API int connection_set_default_cellular_service_profile_async(connection_h connection,
 872                 connection_cellular_service_type_e type, connection_profile_h profile,
 873                 connection_set_default_cb callback, void* user_data)
 874 {
 875         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 876
 877         int rv;
 878
 879         if (!(__connection_check_handle_validity(connection)) ||
 880             profile == NULL || callback == NULL) {
 881                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 882                 return CONNECTION_ERROR_INVALID_PARAMETER;
 883         }
 884
 885         rv = _connection_libnet_set_cellular_service_profile_async(connection, type, profile);
 886         if (rv == NET_ERR_ACCESS_DENIED) {
 887                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 888                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 889         } else if (rv != NET_ERR_NONE) {
 890                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to set default cellular service profile[%d]", rv); //LCOV_EXCL_LINE
 891                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 892         }
 893
 894         __connection_set_default_cellular_service_profile_callback(connection, callback, user_data);
 895
 896         return CONNECTION_ERROR_NONE;
 897 }
 898
 899 EXPORT_API int connection_open_profile(connection_h connection, connection_profile_h profile,
 900                                         connection_opened_cb callback, void* user_data)
 901 {
 902         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
 903
 904         int rv;
 905
 906         if (!(__connection_check_handle_validity(connection)) ||
 907             profile == NULL || callback == NULL) {
 908                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 909                 return CONNECTION_ERROR_INVALID_PARAMETER;
 910         }
 911
 912         rv = _connection_libnet_open_profile(connection, profile);
 913         if (rv == NET_ERR_ACCESS_DENIED) {
 914                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 915                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 916         } else if (rv != NET_ERR_NONE) {
 917                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open profile[%d]", rv); //LCOV_EXCL_LINE
 918                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 919         }
 920
 921         __connection_open_profile_set_callback(connection, callback, user_data);
 922
 923         return CONNECTION_ERROR_NONE;
 924 }
 925
 926 EXPORT_API int connection_close_profile(connection_h connection, connection_profile_h profile,
 927                                         connection_closed_cb callback, void* user_data)
 928 {
 929         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
 930
 931         int rv;
 932
 933         if (!(__connection_check_handle_validity(connection)) ||
 934             profile == NULL || callback == NULL) {
 935                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 936                 return CONNECTION_ERROR_INVALID_PARAMETER;
 937         }
 938
 939         rv = _connection_libnet_close_profile(connection, profile);
 940         if (rv == NET_ERR_ACCESS_DENIED) {
 941                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 942                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 943         } else if (rv != NET_ERR_NONE) {
 944                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to close profile[%d]", rv); //LCOV_EXCL_LINE
 945                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 946         }
 947
 948         __connection_close_profile_set_callback(connection, callback, user_data);
 949
 950         return CONNECTION_ERROR_NONE;
 951 }
 952
 953 EXPORT_API int connection_reset_profile(connection_h connection,
 954                                 connection_reset_option_e type, int id, connection_reset_cb callback, void *user_data)
 955 {
 956         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 957
 958         int rv;
 959
 960         if (!(__connection_check_handle_validity(connection))) {
 961                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed");
 962                 return CONNECTION_ERROR_INVALID_PARAMETER;
 963         }
 964
 965         if (id < 0 || id > 1) {
 966                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed"); //LCOV_EXCL_LINE
 967                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 968         }
 969
 970         rv = _connection_libnet_reset_profile(connection, type, id);
 971         if (rv == NET_ERR_ACCESS_DENIED) {
 972                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 973                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 974         } else if (rv != NET_ERR_NONE) {
 975                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to reset profile[%d]", rv); //LCOV_EXCL_LINE
 976                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 977         }
 978
 979         __connection_reset_profile_set_callback(connection, callback, user_data);
 980
 981         return CONNECTION_ERROR_NONE;
 982 }
 983
 984 EXPORT_API int connection_add_route(connection_h connection, const char* interface_name, const char* host_address)
 985 {
 986         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 987
 988         if (!(__connection_check_handle_validity(connection)) ||
 989             interface_name == NULL || host_address == NULL) {
 990                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 991                 return CONNECTION_ERROR_INVALID_PARAMETER;
 992         }
 993
 994         return _connection_libnet_add_route(connection, interface_name, host_address);
 995 }
 996
 997 EXPORT_API int connection_remove_route(connection_h connection, const char* interface_name, const char* host_address)
 998 {
 999         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1000
1001         if (!(__connection_check_handle_validity(connection)) ||
1002             interface_name == NULL || host_address == NULL) {
1003                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1004                 return CONNECTION_ERROR_INVALID_PARAMETER;
1005         }
1006
1007         return _connection_libnet_remove_route(connection, interface_name, host_address);
1008 }
1009
1010 EXPORT_API int connection_add_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
1011 {
1012         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1013
1014         if (!(__connection_check_handle_validity(connection)) ||
1015             interface_name == NULL || host_address == NULL) {
1016                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1017                 return CONNECTION_ERROR_INVALID_PARAMETER;
1018         }
1019
1020         return _connection_libnet_add_route_ipv6(connection, interface_name, host_address, gateway);
1021 }
1022
1023 EXPORT_API int connection_remove_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
1024 {
1025         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1026
1027         if (!(__connection_check_handle_validity(connection)) ||
1028             interface_name == NULL || host_address == NULL) {
1029                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1030                 return CONNECTION_ERROR_INVALID_PARAMETER;
1031         }
1032
1033         return _connection_libnet_remove_route_ipv6(connection, interface_name, host_address, gateway);
1034 }
1035
1036 EXPORT_API int connection_add_route_entry(connection_h connection,
1037                 connection_address_family_e address_family,     const char *interface_name,
1038                 const char *host_address, const char *gateway)
1039 {
1040         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1041
1042         if (!(__connection_check_handle_validity(connection)) ||
1043                 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1044              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1045             interface_name == NULL || host_address == NULL) {
1046                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1047                 return CONNECTION_ERROR_INVALID_PARAMETER;
1048         }
1049
1050         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
1051                 return _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4,
1052                                                                 interface_name, host_address, gateway);
1053         else
1054                 return _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6,
1055                                                                 interface_name, host_address, gateway);
1056
1057         return CONNECTION_ERROR_NONE;
1058 }
1059
1060 EXPORT_API int connection_remove_route_entry(connection_h connection,
1061                 connection_address_family_e address_family,     const char *interface_name,
1062                 const char *host_address, const char *gateway)
1063 {
1064         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1065
1066         if (!(__connection_check_handle_validity(connection)) ||
1067                 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1068              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1069             interface_name == NULL || host_address == NULL) {
1070                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1071                 return CONNECTION_ERROR_INVALID_PARAMETER;
1072         }
1073
1074         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
1075                 return _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4,
1076                                                                 interface_name, host_address, gateway);
1077         else
1078                 return _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6,
1079                                                                 interface_name, host_address, gateway);
1080
1081         return CONNECTION_ERROR_NONE;
1082 }
1083
1084 static int __get_cellular_statistic(connection_statistics_type_e statistics_type, long long *llsize)
1085 {
1086         int rv = VCONF_OK, rv1 = VCONF_OK;
1087         int last_size = 0, size = 0;
1088 #if defined TIZEN_DUALSIM_ENABLE
1089         int sim_id = 0;
1090 #endif
1091
1092         if (llsize == NULL) {
1093                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1094                 return CONNECTION_ERROR_INVALID_PARAMETER;
1095         }
1096
1097         switch (statistics_type) {
1098         case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1099         case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1100         case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1101         case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1102                 break;
1103         default:
1104                 return CONNECTION_ERROR_INVALID_PARAMETER;
1105         }
1106
1107 #if defined TIZEN_DUALSIM_ENABLE
1108         rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id);
1109         if (rv != VCONF_OK) {
1110                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get default subscriber id");
1111                 *llsize = 0;
1112                 return CONNECTION_ERROR_OPERATION_FAILED;
1113         }
1114
1115         switch (sim_id) {
1116         case 0:
1117 #endif
1118                 switch (statistics_type) {
1119                 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1120                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size);
1121                         break;
1122                 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1123                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size);
1124                         break;
1125                 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1126                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size);
1127                         rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT, &size);
1128                         break;
1129                 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1130                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size);
1131                         rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV, &size);
1132                         break;
1133                 }
1134 #if defined TIZEN_DUALSIM_ENABLE
1135                 break;
1136         case 1:
1137                 switch (statistics_type) {
1138                 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1139                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size);
1140                         break;
1141                 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1142                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size);
1143                         break;
1144                 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1145                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size);
1146                         rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT2, &size);
1147                         break;
1148                 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1149                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size);
1150                         rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV2, &size);
1151                         break;
1152                 }
1153                 break;
1154         default:
1155                 *llsize = 0;
1156                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
1157                 return CONNECTION_ERROR_OPERATION_FAILED;
1158         }
1159 #endif
1160
1161         if (rv != VCONF_OK || rv1 != VCONF_OK) {
1162                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular statistics"); //LCOV_EXCL_LINE
1163                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1164         }
1165
1166         *llsize = (long long)(last_size * 1000) + (long long)(size * 1000);
1167         CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", *llsize);
1168
1169         return CONNECTION_ERROR_NONE;
1170 }
1171
1172 static int __get_statistic(connection_handle_s *conn_handle, connection_type_e connection_type,
1173                 connection_statistics_type_e statistics_type, long long *llsize)
1174 {
1175         int rv, stat_type;
1176         unsigned long long ull_size;
1177
1178         if (llsize == NULL) {
1179                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1180                 return CONNECTION_ERROR_INVALID_PARAMETER;
1181         }
1182
1183         rv  = _connection_libnet_check_get_privilege();
1184         if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
1185                 return rv;
1186         else if (rv != CONNECTION_ERROR_NONE) {
1187                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get statistics"); //LCOV_EXCL_LINE
1188                 return CONNECTION_ERROR_OPERATION_FAILED;
1189         }
1190
1191         if (connection_type == CONNECTION_TYPE_CELLULAR)
1192                 return __get_cellular_statistic(statistics_type, llsize);
1193         else if (connection_type == CONNECTION_TYPE_WIFI) {
1194                 switch (statistics_type) {
1195                 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1196                         stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
1197                         break;
1198                 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1199                         stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
1200                         break;
1201                 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1202                         stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
1203                         break;
1204                 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1205                         stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
1206                         break;
1207                 default:
1208                         return CONNECTION_ERROR_INVALID_PARAMETER;
1209                 }
1210
1211                 rv  = _connection_libnet_get_statistics(conn_handle, stat_type, &ull_size);
1212                 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
1213                         return rv;
1214                 else if (rv != CONNECTION_ERROR_NONE) {
1215                         CONNECTION_LOG(CONNECTION_ERROR, "Failed to get Wi-Fi statistics"); //LCOV_EXCL_LINE
1216                         *llsize = 0; //LCOV_EXCL_LINE
1217                         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1218                 }
1219
1220                 CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", ull_size);
1221                 *llsize = (long long)ull_size;
1222         } else
1223                 return CONNECTION_ERROR_INVALID_PARAMETER;
1224
1225         return CONNECTION_ERROR_NONE;
1226 }
1227
1228 static int __reset_statistic(connection_handle_s *conn_handle,
1229                         connection_type_e connection_type, connection_statistics_type_e statistics_type)
1230 {
1231         int conn_type;
1232         int stat_type;
1233         int rv;
1234
1235         if (connection_type == CONNECTION_TYPE_CELLULAR)
1236                 conn_type = NET_DEVICE_CELLULAR;
1237         else if (connection_type == CONNECTION_TYPE_WIFI)
1238                 conn_type = NET_DEVICE_WIFI;
1239         else
1240                 return CONNECTION_ERROR_INVALID_PARAMETER;
1241
1242         switch (statistics_type) {
1243         case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1244                 stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
1245                 break;
1246         case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1247                 stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
1248                 break;
1249         case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1250                 stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
1251                 break;
1252         case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1253                 stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
1254                 break;
1255         default:
1256                 return CONNECTION_ERROR_INVALID_PARAMETER;
1257         }
1258
1259         rv = _connection_libnet_set_statistics(conn_handle, conn_type, stat_type);
1260         if (rv != CONNECTION_ERROR_NONE)
1261                 return rv;
1262
1263         CONNECTION_LOG(CONNECTION_INFO, "connection_reset_statistics success");
1264
1265         return CONNECTION_ERROR_NONE;
1266 }
1267
1268 EXPORT_API int connection_get_statistics(connection_h connection,
1269                                 connection_type_e connection_type,
1270                                 connection_statistics_type_e statistics_type, long long* size)
1271 {
1272         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
1273
1274         if (connection_type == CONNECTION_TYPE_CELLULAR)
1275                 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1276         else if (connection_type == CONNECTION_TYPE_WIFI)
1277                 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1278
1279         if (!(__connection_check_handle_validity(connection)) || size == NULL) {
1280                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1281                 return CONNECTION_ERROR_INVALID_PARAMETER;
1282         }
1283
1284         return __get_statistic(connection, connection_type, statistics_type, size);
1285 }
1286
1287 EXPORT_API int connection_reset_statistics(connection_h connection,
1288                                 connection_type_e connection_type,
1289                                 connection_statistics_type_e statistics_type)
1290 {
1291         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
1292
1293         if (connection_type == CONNECTION_TYPE_CELLULAR)
1294                 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1295         else if (connection_type == CONNECTION_TYPE_WIFI)
1296                 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1297
1298         if (!__connection_check_handle_validity(connection)) {
1299                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1300                 return CONNECTION_ERROR_INVALID_PARAMETER;
1301         }
1302
1303         return __reset_statistic(connection, connection_type, statistics_type);
1304 }
1305
1306 EXPORT_API int connection_foreach_ipv6_address(connection_h connection,
1307                 connection_type_e connection_type, connection_ipv6_address_cb callback,
1308                 void *user_data)
1309 {
1310         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1311                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1312
1313         GSList *ipv6_address_list = NULL;
1314
1315         if (!(__connection_check_handle_validity(connection))) {
1316                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1317                 return CONNECTION_ERROR_INVALID_PARAMETER;
1318         }
1319
1320         int rv = CONNECTION_ERROR_NONE;
1321
1322         switch (connection_type) {
1323         case CONNECTION_TYPE_WIFI:
1324                 rv = net_foreach_ipv6_address(NET_DEVICE_WIFI,
1325                                 &ipv6_address_list);
1326                 break;
1327         case CONNECTION_TYPE_CELLULAR:
1328                 rv = net_foreach_ipv6_address(NET_DEVICE_CELLULAR,
1329                                 &ipv6_address_list);
1330                 break;
1331         case CONNECTION_TYPE_ETHERNET:
1332                 rv = net_foreach_ipv6_address(NET_DEVICE_ETHERNET,
1333                                 &ipv6_address_list);
1334                 break;
1335         case CONNECTION_TYPE_BT:
1336                 rv = net_foreach_ipv6_address(NET_DEVICE_BLUETOOTH,
1337                                 &ipv6_address_list);
1338                 break;
1339         default:
1340                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1341                 return CONNECTION_ERROR_INVALID_PARAMETER;
1342         }
1343
1344         if (rv != NET_ERR_NONE) {
1345                 CONNECTION_LOG(CONNECTION_ERROR, "net_get_multiple_id_address"
1346                                 " Failed = %d\n", rv);
1347                 return CONNECTION_ERROR_OPERATION_FAILED;
1348         }
1349
1350         GSList *list;
1351         for (list = ipv6_address_list; list; list = list->next) {
1352                 rv = callback((char *)list->data, user_data);
1353                 if (rv == false)
1354                         break;
1355         }
1356
1357         g_slist_free_full(ipv6_address_list, g_free);
1358         ipv6_address_list = NULL;
1359
1360         return CONNECTION_ERROR_NONE;
1361 }
1362
1363 EXPORT_API int connection_profile_start_tcpdump(connection_h connection)
1364 {
1365         int ret = 0;
1366
1367         if (!(__connection_check_handle_validity(connection))) {
1368                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1369                 return CONNECTION_ERROR_INVALID_PARAMETER;
1370         }
1371
1372         ret = _connection_libnet_start_tcpdump(connection);
1373         if (ret != CONNECTION_ERROR_NONE) {
1374                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to start tcpdump (%d)", ret);
1375                 return ret;
1376         }
1377
1378         return CONNECTION_ERROR_NONE;
1379 }
1380
1381 EXPORT_API int connection_profile_stop_tcpdump(connection_h connection)
1382 {
1383         int ret = 0;
1384
1385         if (!(__connection_check_handle_validity(connection))) {
1386                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1387                 return CONNECTION_ERROR_INVALID_PARAMETER;
1388         }
1389
1390         ret = _connection_libnet_stop_tcpdump(connection);
1391         if (ret != CONNECTION_ERROR_NONE) {
1392                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to stop tcpdump (%d)", ret);
1393                 return ret;
1394         }
1395
1396         return CONNECTION_ERROR_NONE;
1397 }
1398
1399 EXPORT_API int connection_profile_get_tcpdump_state(connection_h connection, gboolean *tcpdump_state)
1400 {
1401         int ret = 0;
1402
1403         if (!(__connection_check_handle_validity(connection)) || !tcpdump_state) {
1404                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1405                 return CONNECTION_ERROR_INVALID_PARAMETER;
1406         }
1407
1408         ret = _connection_libnet_get_tcpdump_state(connection, tcpdump_state);
1409         if (ret != CONNECTION_ERROR_NONE) {
1410                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get the tcpdump state (%d)", ret);
1411                 return ret;
1412         }
1413
1414         return CONNECTION_ERROR_NONE;
1415 }