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 void __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
  89 static void __connection_set_ip_changed_callback(connection_handle_s *conn_handle,
  90                         void *callback, void *user_data)
  91 {
  92         conn_handle->ip_changed_user_data = user_data;
  93         conn_handle->ip_changed_callback = callback;
  94 }
  95
  96 static void __connection_set_proxy_changed_callback(connection_handle_s *conn_handle,
  97                         void *callback, void *user_data)
  98 {
  99         conn_handle->proxy_changed_user_data = user_data;
 100         conn_handle->proxy_changed_callback = callback;
 101 }
 102
 103 static void __connection_set_internet_state_changed_callback(connection_handle_s *conn_handle,
 104                         void *callback, void *user_data)
 105 {
 106         conn_handle->internet_state_changed_user_data = user_data;
 107         conn_handle->internet_state_changed_callback = callback;
 108 }
 109
 110 static void __connection_set_ethernet_cable_state_changed_cb(connection_handle_s *conn_handle,
 111                         void *callback, void *user_data)
 112 {
 113         conn_handle->ethernet_cable_state_changed_callback = callback;
 114         conn_handle->ethernet_cable_state_changed_user_data = user_data;
 115 }
 116
 117 static void __connection_set_default_cellular_service_profile_callback(connection_handle_s *conn_handle,
 118                         void *callback, void *user_data)
 119 {
 120         conn_handle->set_default_callback = callback;
 121         conn_handle->set_default_user_data = user_data;
 122 }
 123
 124 static void __connection_open_profile_set_callback(connection_handle_s *conn_handle,
 125                         void *callback, void *user_data)
 126 {
 127         conn_handle->opened_callback = callback;
 128         conn_handle->opened_user_data = user_data;
 129 }
 130
 131 static void __connection_close_profile_set_callback(connection_handle_s *conn_handle,
 132                         void *callback, void *user_data)
 133 {
 134         conn_handle->closed_callback = callback;
 135         conn_handle->closed_user_data = user_data;
 136 }
 137
 138 static void __connection_reset_profile_set_callback(connection_handle_s *conn_handle,
 139                         void *callback, void *user_data)
 140 {
 141         conn_handle->reset_callback = callback;
 142         conn_handle->reset_user_data = user_data;
 143 }
 144 //LCOV_EXCL_STOP
 145
 146 /* Connection Manager ********************************************************/
 147 EXPORT_API int connection_create(connection_h *connection)
 148 {
 149         CONN_LOCK;
 150
 151         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 152
 153         int rv;
 154
 155         if (connection == NULL || __connection_check_handle_validity(*connection)) {
 156                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 157                 CONN_UNLOCK; //LCOV_EXCL_LINE
 158                 return CONNECTION_ERROR_INVALID_PARAMETER;
 159         }
 160
 161         *connection = g_try_malloc0(sizeof(connection_handle_s));
 162         if (*connection != NULL) {
 163                 CONNECTION_LOG(CONNECTION_INFO, "New handle created[%p]", *connection);
 164         } else {
 165                 CONN_UNLOCK; //LCOV_EXCL_LINE
 166                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 167         }
 168
 169         rv = _connection_libnet_init(*connection);
 170         if (rv == NET_ERR_ACCESS_DENIED) {
 171                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 172                 CONN_UNLOCK; //LCOV_EXCL_LINE
 173                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 174         } else if (rv != NET_ERR_NONE) {
 175                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create connection[%d]", rv); //LCOV_EXCL_LINE
 176                 CONN_UNLOCK; //LCOV_EXCL_LINE
 177                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 178         }
 179
 180         conn_handle_list = g_slist_prepend(conn_handle_list, *connection);
 181
 182         CONN_UNLOCK;
 183         return CONNECTION_ERROR_NONE;
 184 }
 185
 186 EXPORT_API int connection_destroy(connection_h connection)
 187 {
 188         CONN_LOCK;
 189
 190         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 191
 192         if (!(__connection_check_handle_validity(connection))) {
 193                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 194                 CONN_UNLOCK;
 195                 return CONNECTION_ERROR_INVALID_PARAMETER;
 196         }
 197
 198         CONNECTION_LOG(CONNECTION_INFO, "Destroy handle: %p", connection);
 199
 200         __connection_set_type_changed_callback(connection, NULL, NULL);
 201         __connection_set_ip_changed_callback(connection, NULL, NULL);
 202         __connection_set_proxy_changed_callback(connection, NULL, NULL);
 203         __connection_set_internet_state_changed_callback(connection, NULL, NULL);
 204         __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
 205
 206         conn_handle_list = g_slist_remove(conn_handle_list, connection);
 207         _connection_libnet_deinit(connection, (conn_handle_list == NULL));
 208
 209         g_free(connection);
 210         connection = NULL;
 211
 212         CONN_UNLOCK;
 213         return CONNECTION_ERROR_NONE;
 214 }
 215
 216 //LCOV_EXCL_START
 217 EXPORT_API int connection_create_cs(int tid, connection_h *connection)
 218 {
 219         int rv;
 220
 221         rv = connection_create(connection);
 222         if (rv == CONNECTION_ERROR_NONE) {
 223                 CONN_LOCK;
 224                 _connection_set_cs_tid(tid, *connection);
 225                 CONN_UNLOCK;
 226         }
 227
 228         return rv;
 229 }
 230
 231 EXPORT_API int connection_destroy_cs(int tid, connection_h connection)
 232 {
 233         int rv;
 234
 235         CONN_LOCK;
 236
 237         if (!(__connection_check_handle_validity(connection))) {
 238                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 239                 CONN_UNLOCK;
 240                 return CONNECTION_ERROR_INVALID_PARAMETER;
 241         }
 242
 243         CONNECTION_LOG(CONNECTION_INFO, "Destroy connection handle: %p", connection);
 244         _connection_unset_cs_tid(tid, connection);
 245         CONN_UNLOCK;
 246
 247         rv = connection_destroy(connection);
 248
 249         return rv;
 250 }
 251 //LCOV_EXCL_STOP
 252
 253 EXPORT_API int connection_get_type(connection_h connection, connection_type_e* type)
 254 {
 255         int rv = 0;
 256         int status = 0;
 257
 258         CONN_LOCK;
 259
 260         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 261
 262         if (type == NULL || !(__connection_check_handle_validity(connection))) {
 263                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 264                 CONN_UNLOCK;
 265                 return CONNECTION_ERROR_INVALID_PARAMETER;
 266         }
 267
 268         rv = vconf_get_int(VCONFKEY_NETWORK_STATUS, &status);
 269         if (rv != VCONF_OK) {
 270                 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed = %d", status); //LCOV_EXCL_LINE
 271                 CONN_UNLOCK; //LCOV_EXCL_LINE
 272                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 273         }
 274
 275         CONNECTION_LOG(CONNECTION_INFO, "Connected Network = %d", status);
 276
 277         *type = __connection_convert_net_state(status);
 278
 279         CONN_UNLOCK;
 280         return CONNECTION_ERROR_NONE;
 281 }
 282
 283 EXPORT_API int connection_get_ip_address(connection_h connection,
 284                                 connection_address_family_e address_family, char** ip_address)
 285 {
 286         CONN_LOCK;
 287
 288         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 289
 290         if (ip_address == NULL || !(__connection_check_handle_validity(connection))) {
 291                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 292                 CONN_UNLOCK;
 293                 return CONNECTION_ERROR_INVALID_PARAMETER;
 294         }
 295
 296         switch (address_family) {
 297         case CONNECTION_ADDRESS_FAMILY_IPV4:
 298                 *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP);
 299                 break;
 300         case CONNECTION_ADDRESS_FAMILY_IPV6:
 301                 *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP6);
 302                 break;
 303         default:
 304                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 305                 CONN_UNLOCK;
 306                 return CONNECTION_ERROR_INVALID_PARAMETER;
 307         }
 308
 309         if (*ip_address == NULL) {
 310                 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE
 311                 CONN_UNLOCK; //LCOV_EXCL_LINE
 312                 return CONNECTION_ERROR_OPERATION_FAILED;//LCOV_EXCL_LINE
 313         }
 314
 315         CONN_UNLOCK;
 316         return CONNECTION_ERROR_NONE;
 317 }
 318
 319 EXPORT_API int connection_get_proxy(connection_h connection,
 320                                 connection_address_family_e address_family, char** proxy)
 321 {
 322         CONN_LOCK;
 323
 324         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 325
 326         if (proxy == NULL || !(__connection_check_handle_validity(connection))) {
 327                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 328                 CONN_UNLOCK;
 329                 return CONNECTION_ERROR_INVALID_PARAMETER;
 330         }
 331
 332         switch (address_family) {
 333         case CONNECTION_ADDRESS_FAMILY_IPV4:
 334         case CONNECTION_ADDRESS_FAMILY_IPV6:
 335                 *proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
 336                 break;
 337         default:
 338                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 339                 CONN_UNLOCK;
 340                 return CONNECTION_ERROR_INVALID_PARAMETER;
 341         }
 342
 343         if (*proxy == NULL) {
 344                 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed"); //LCOV_EXCL_LINE
 345                 CONN_UNLOCK; //LCOV_EXCL_LINE
 346                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 347         }
 348
 349         CONN_UNLOCK;
 350         return CONNECTION_ERROR_NONE;
 351 }
 352
 353 EXPORT_API int connection_get_mac_address(connection_h connection, connection_type_e type, char** mac_addr)
 354 {
 355         FILE *fp;
 356         char buf[CONNECTION_MAC_INFO_LENGTH + 1];
 357
 358         CONN_LOCK;
 359
 360         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE, ETHERNET_FEATURE);
 361
 362         if (type == CONNECTION_TYPE_WIFI)
 363                 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 364         else if (type == CONNECTION_TYPE_ETHERNET) //LCOV_EXCL_LINE
 365                 CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE); //LCOV_EXCL_LINE
 366
 367         if (mac_addr == NULL || !(__connection_check_handle_validity(connection))) {
 368                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 369                 CONN_UNLOCK;
 370                 return CONNECTION_ERROR_INVALID_PARAMETER;
 371         }
 372
 373         switch (type) {
 374         case CONNECTION_TYPE_WIFI:
 375                 if (__builtin_expect(tv_profile == -1, 0)) {
 376                         char *profileName;
 377                         system_info_get_platform_string("http://tizen.org/feature/profile", &profileName);
 378                         if (*profileName == 't' || *profileName == 'T')
 379                                 tv_profile = 1; //LCOV_EXCL_LINE
 380                         else
 381                                 tv_profile = 0;
 382                         free(profileName);
 383                 }
 384                 if (tv_profile == 1) {
 385                         //LCOV_EXCL_START
 386                         fp = fopen(WIFI_MAC_INFO_FILE, "r");
 387                         if (fp == NULL) {
 388                                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", WIFI_MAC_INFO_FILE);
 389                                 CONN_UNLOCK;
 390                                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 391                         }
 392
 393                         if (fgets(buf, sizeof(buf), fp) == NULL) {
 394                                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", WIFI_MAC_INFO_FILE);
 395                                 fclose(fp);
 396                                 CONN_UNLOCK;
 397                                 return CONNECTION_ERROR_OPERATION_FAILED;
 398                         }
 399
 400                         CONNECTION_LOG(CONNECTION_INFO, "%s : %s", WIFI_MAC_INFO_FILE, buf);
 401
 402                         *mac_addr = (char *)malloc(CONNECTION_MAC_INFO_LENGTH + 1);
 403                         if (*mac_addr == NULL) {
 404                                 CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed");
 405                                 fclose(fp);
 406                                 CONN_UNLOCK;
 407                                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 408                         }
 409                         g_strlcpy(*mac_addr, buf, CONNECTION_MAC_INFO_LENGTH + 1);
 410                         fclose(fp);
 411                         //LCOV_EXCL_STOP
 412                 } else {
 413                         *mac_addr = vconf_get_str(VCONFKEY_WIFI_BSSID_ADDRESS);
 414
 415                         if (*mac_addr == NULL) {
 416                                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get vconf from %s", VCONFKEY_WIFI_BSSID_ADDRESS); //LCOV_EXCL_LINE
 417                                 CONN_UNLOCK; //LCOV_EXCL_LINE
 418                                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 419                         }
 420                 }
 421                 break;
 422         //LCOV_EXCL_START
 423         case CONNECTION_TYPE_ETHERNET:
 424                 fp = fopen(ETHERNET_MAC_INFO_FILE, "r");
 425                 if (fp == NULL) {
 426                         CONNECTION_LOG(CONNECTION_ERROR, "Failed to open file %s", ETHERNET_MAC_INFO_FILE);
 427                         CONN_UNLOCK;
 428                         return CONNECTION_ERROR_OUT_OF_MEMORY;
 429                 }
 430
 431                 if (fgets(buf, sizeof(buf), fp) == NULL) {
 432                         CONNECTION_LOG(CONNECTION_ERROR, "Failed to get MAC info from %s", ETHERNET_MAC_INFO_FILE);
 433                         fclose(fp);
 434                         CONN_UNLOCK;
 435                         return CONNECTION_ERROR_OPERATION_FAILED;
 436                 }
 437
 438                 CONNECTION_LOG(CONNECTION_INFO, "%s : %s", ETHERNET_MAC_INFO_FILE, buf);
 439
 440                 *mac_addr = (char *)malloc(CONNECTION_MAC_INFO_LENGTH + 1);
 441                 if (*mac_addr == NULL) {
 442                         CONNECTION_LOG(CONNECTION_ERROR, "malloc() failed");
 443                         fclose(fp);
 444                         CONN_UNLOCK;
 445                         return CONNECTION_ERROR_OUT_OF_MEMORY;
 446                 }
 447
 448                 g_strlcpy(*mac_addr, buf, CONNECTION_MAC_INFO_LENGTH + 1);
 449                 fclose(fp);
 450
 451                 break;
 452         //LCOV_EXCL_STOP
 453         default:
 454                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 455                 CONN_UNLOCK; //LCOV_EXCL_LINE
 456                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 457         }
 458
 459         /* Checking Invalid MAC Address */
 460         if ((strcmp(*mac_addr, "00:00:00:00:00:00") == 0) ||
 461                         (strcmp(*mac_addr, "ff:ff:ff:ff:ff:ff") == 0)) {
 462                 CONNECTION_LOG(CONNECTION_ERROR, "MAC Address(%s) is invalid", *mac_addr); //LCOV_EXCL_LINE
 463                 CONN_UNLOCK; //LCOV_EXCL_LINE
 464                 return CONNECTION_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
 465         }
 466
 467         CONNECTION_LOG(CONNECTION_INFO, "MAC Address %s", *mac_addr);
 468
 469         CONN_UNLOCK;
 470         return CONNECTION_ERROR_NONE;
 471 }
 472
 473
 474 EXPORT_API int connection_is_metered_network(connection_h connection, bool* is_metered)
 475 {
 476         CONN_LOCK;
 477
 478         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 479
 480         if (is_metered == NULL || !(__connection_check_handle_validity(connection))) {
 481                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 482                 CONN_UNLOCK;
 483                 return CONNECTION_ERROR_INVALID_PARAMETER;
 484         }
 485
 486         int rv = _connection_libnet_get_metered_state(connection, is_metered);
 487         if (rv != CONNECTION_ERROR_NONE) {
 488                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get metered state[%d]", rv); //LCOV_EXCL_LINE
 489                 CONN_UNLOCK; //LCOV_EXCL_LINE
 490                 return rv; //LCOV_EXCL_LINE
 491         }
 492
 493         CONNECTION_LOG(CONNECTION_INFO, "metered state: %s", is_metered ? "true" : "false");
 494         CONN_UNLOCK;
 495         return CONNECTION_ERROR_NONE;
 496 }
 497
 498
 499 EXPORT_API int connection_get_cellular_state(connection_h connection, connection_cellular_state_e* state)
 500 {
 501         int rv = 0;
 502         int status = 0;
 503         int cellular_state = 0;
 504 #if defined TIZEN_DUALSIM_ENABLE
 505         int sim_id = 0;
 506 #endif
 507
 508         CONN_LOCK;
 509
 510         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 511
 512         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 513                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 514                 CONN_UNLOCK;
 515                 return CONNECTION_ERROR_INVALID_PARAMETER;
 516         }
 517
 518         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &status);
 519         if (rv != VCONF_OK) {
 520                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
 521                 CONN_UNLOCK; //LCOV_EXCL_LINE
 522                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 523         }
 524
 525         CONNECTION_LOG(CONNECTION_INFO, "Cellular: %d", status);
 526         *state = __connection_convert_cellular_state(status);
 527
 528         if (*state == CONNECTION_CELLULAR_STATE_AVAILABLE) {
 529 #if defined TIZEN_DUALSIM_ENABLE
 530                 rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id);
 531                 if (rv != VCONF_OK) {
 532                         CONNECTION_LOG(CONNECTION_ERROR,
 533                                         "Failed to get default subscriber id", sim_id);
 534                         CONN_UNLOCK;
 535                         return CONNECTION_ERROR_OPERATION_FAILED;
 536                 }
 537
 538                 switch (sim_id) {
 539                 case CONNECTION_CELLULAR_SUBSCRIBER_1:
 540 #endif
 541                         rv = vconf_get_int(VCONFKEY_DNET_STATE, &cellular_state);
 542 #if defined TIZEN_DUALSIM_ENABLE
 543                         break;
 544
 545                 case CONNECTION_CELLULAR_SUBSCRIBER_2:
 546                         rv = vconf_get_int(VCONFKEY_DNET_STATE2, &cellular_state);
 547                         break;
 548
 549                 default:
 550                         CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
 551                         CONN_UNLOCK;
 552                         return CONNECTION_ERROR_OPERATION_FAILED;
 553                 }
 554 #endif
 555                 if (rv != VCONF_OK) {
 556                         CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
 557                         CONN_UNLOCK; //LCOV_EXCL_LINE
 558                         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 559                 }
 560         }
 561
 562         CONNECTION_LOG(CONNECTION_INFO, "Cellular state: %d", cellular_state);
 563
 564         if (cellular_state == VCONFKEY_DNET_NORMAL_CONNECTED ||
 565                         cellular_state == VCONFKEY_DNET_SECURE_CONNECTED ||
 566                         cellular_state == VCONFKEY_DNET_TRANSFER)
 567                 *state = CONNECTION_CELLULAR_STATE_CONNECTED;
 568
 569         CONN_UNLOCK;
 570         return CONNECTION_ERROR_NONE;
 571 }
 572
 573 EXPORT_API int connection_get_wifi_state(connection_h connection, connection_wifi_state_e* state)
 574 {
 575         CONN_LOCK;
 576
 577         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 578
 579         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 580                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 581                 CONN_UNLOCK;
 582                 return CONNECTION_ERROR_INVALID_PARAMETER;
 583         }
 584
 585         int rv = _connection_libnet_get_wifi_state(connection, state);
 586         if (rv != CONNECTION_ERROR_NONE) {
 587                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get Wi-Fi state[%d]", rv); //LCOV_EXCL_LINE
 588                 CONN_UNLOCK; //LCOV_EXCL_LINE
 589                 return rv; //LCOV_EXCL_LINE
 590         }
 591
 592         CONNECTION_LOG(CONNECTION_INFO, "Wi-Fi state: %d", *state);
 593
 594         CONN_UNLOCK;
 595         return CONNECTION_ERROR_NONE;
 596 }
 597
 598 EXPORT_API int connection_get_ethernet_state(connection_h connection, connection_ethernet_state_e *state)
 599 {
 600         CONN_LOCK;
 601
 602         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 603
 604         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 605                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 606                 CONN_UNLOCK;
 607                 return CONNECTION_ERROR_INVALID_PARAMETER;
 608         }
 609
 610         int rv = _connection_libnet_get_ethernet_state(connection, state);
 611         if (rv != CONNECTION_ERROR_NONE) {
 612                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get ethernet state[%d]", rv); //LCOV_EXCL_LINE
 613                 CONN_UNLOCK; //LCOV_EXCL_LINE
 614                 return rv; //LCOV_EXCL_LINE
 615         }
 616
 617         CONN_UNLOCK;
 618         return CONNECTION_ERROR_NONE;
 619 }
 620
 621 EXPORT_API int connection_get_ethernet_cable_state(connection_h connection, connection_ethernet_cable_state_e *state)
 622 {
 623         CONN_LOCK;
 624
 625         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 626
 627         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 628                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 629                 CONN_UNLOCK;
 630                 return CONNECTION_ERROR_INVALID_PARAMETER;
 631         }
 632
 633         int rv = _connection_libnet_get_ethernet_cable_state(connection, state);
 634         if (rv != CONNECTION_ERROR_NONE) {
 635                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get ethernet cable state[%d]", rv); //LCOV_EXCL_LINE
 636                 CONN_UNLOCK; //LCOV_EXCL_LINE
 637                 return rv; //LCOV_EXCL_LINE
 638         }
 639
 640         CONN_UNLOCK;
 641         return CONNECTION_ERROR_NONE;
 642 }
 643
 644 EXPORT_API int connection_set_ethernet_cable_state_chaged_cb(connection_h connection,
 645                           connection_ethernet_cable_state_chaged_cb callback, void *user_data)
 646 {
 647         DEPRECATED_LOG(__FUNCTION__, "connection_set_ethernet_cable_state_changed_cb");
 648
 649         CONN_LOCK;
 650
 651         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 652
 653         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 654                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 655                 CONN_UNLOCK;
 656                 return CONNECTION_ERROR_INVALID_PARAMETER;
 657         }
 658
 659         DEPRECATED_LOG("connection_ethernet_cable_state_chaged_cb",
 660                         "connection_ethernet_cable_state_changed_cb");
 661
 662         __connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data);
 663
 664         CONN_UNLOCK;
 665         return CONNECTION_ERROR_NONE;
 666 }
 667
 668 EXPORT_API int connection_unset_ethernet_cable_state_chaged_cb(connection_h connection)
 669 {
 670         DEPRECATED_LOG(__FUNCTION__, "connection_unset_ethernet_cable_state_changed_cb");
 671
 672         CONN_LOCK;
 673
 674         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 675
 676         if (!(__connection_check_handle_validity(connection))) {
 677                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 678                 CONN_UNLOCK;
 679                 return CONNECTION_ERROR_INVALID_PARAMETER;
 680         }
 681
 682         __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
 683
 684         CONN_UNLOCK;
 685         return CONNECTION_ERROR_NONE;
 686 }
 687
 688 EXPORT_API int connection_set_ethernet_cable_state_changed_cb(connection_h connection,
 689                           connection_ethernet_cable_state_changed_cb callback, void *user_data)
 690 {
 691         CONN_LOCK;
 692
 693         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 694
 695         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 696                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 697                 CONN_UNLOCK;
 698                 return CONNECTION_ERROR_INVALID_PARAMETER;
 699         }
 700
 701         __connection_set_ethernet_cable_state_changed_cb(connection, callback, user_data);
 702
 703         CONN_UNLOCK;
 704         return CONNECTION_ERROR_NONE;
 705 }
 706
 707 EXPORT_API int connection_unset_ethernet_cable_state_changed_cb(connection_h connection)
 708 {
 709         CONN_LOCK;
 710
 711         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 712
 713         if (!(__connection_check_handle_validity(connection))) {
 714                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 715                 CONN_UNLOCK;
 716                 return CONNECTION_ERROR_INVALID_PARAMETER;
 717         }
 718
 719         __connection_set_ethernet_cable_state_changed_cb(connection, NULL, NULL);
 720
 721         CONN_UNLOCK;
 722         return CONNECTION_ERROR_NONE;
 723 }
 724
 725 EXPORT_API int connection_get_bt_state(connection_h connection, connection_bt_state_e *state)
 726 {
 727         CONN_LOCK;
 728
 729         CHECK_FEATURE_SUPPORTED(TETHERING_BLUETOOTH_FEATURE);
 730
 731         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 732                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 733                 CONN_UNLOCK;
 734                 return CONNECTION_ERROR_INVALID_PARAMETER;
 735         }
 736
 737         int rv = _connection_libnet_get_bluetooth_state(connection, state);
 738         if (rv != CONNECTION_ERROR_NONE) {
 739                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get bluetooth state[%d]", rv); //LCOV_EXCL_LINE
 740                 CONN_UNLOCK; //LCOV_EXCL_LINE
 741                 return rv; //LCOV_EXCL_LINE
 742         }
 743
 744         CONN_UNLOCK;
 745         return CONNECTION_ERROR_NONE;
 746 }
 747
 748 EXPORT_API int connection_set_type_changed_cb(connection_h connection,
 749                                         connection_type_changed_cb callback, void* user_data)
 750 {
 751         CONN_LOCK;
 752
 753         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 754
 755         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 756                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 757                 CONN_UNLOCK;
 758                 return CONNECTION_ERROR_INVALID_PARAMETER;
 759         }
 760
 761         __connection_set_type_changed_callback(connection, callback, user_data);
 762
 763         CONN_UNLOCK;
 764         return CONNECTION_ERROR_NONE;
 765 }
 766
 767 EXPORT_API int connection_unset_type_changed_cb(connection_h connection)
 768 {
 769         CONN_LOCK;
 770
 771         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 772
 773         if (!(__connection_check_handle_validity(connection))) {
 774                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 775                 CONN_UNLOCK;
 776                 return CONNECTION_ERROR_INVALID_PARAMETER;
 777         }
 778
 779         __connection_set_type_changed_callback(connection, NULL, NULL);
 780
 781         CONN_UNLOCK;
 782         return CONNECTION_ERROR_NONE;
 783 }
 784
 785 EXPORT_API int connection_set_ip_address_changed_cb(connection_h connection,
 786                                 connection_address_changed_cb callback, void* user_data)
 787 {
 788         CONN_LOCK;
 789
 790         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 791
 792         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 793                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 794                 CONN_UNLOCK;
 795                 return CONNECTION_ERROR_INVALID_PARAMETER;
 796         }
 797
 798         __connection_set_ip_changed_callback(connection, callback, user_data);
 799
 800         CONN_UNLOCK;
 801         return CONNECTION_ERROR_NONE;
 802 }
 803
 804 EXPORT_API int connection_unset_ip_address_changed_cb(connection_h connection)
 805 {
 806         CONN_LOCK;
 807
 808         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 809
 810         if (!(__connection_check_handle_validity(connection))) {
 811                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 812                 CONN_UNLOCK;
 813                 return CONNECTION_ERROR_INVALID_PARAMETER;
 814         }
 815
 816         __connection_set_ip_changed_callback(connection, NULL, NULL);
 817
 818         CONN_UNLOCK;
 819         return CONNECTION_ERROR_NONE;
 820 }
 821
 822 EXPORT_API int connection_set_proxy_address_changed_cb(connection_h connection,
 823                                 connection_address_changed_cb callback, void* user_data)
 824 {
 825         CONN_LOCK;
 826
 827         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 828
 829         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 830                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 831                 CONN_UNLOCK;
 832                 return CONNECTION_ERROR_INVALID_PARAMETER;
 833         }
 834
 835         __connection_set_proxy_changed_callback(connection, callback, user_data);
 836
 837         CONN_UNLOCK;
 838         return CONNECTION_ERROR_NONE;
 839 }
 840
 841 EXPORT_API int connection_unset_proxy_address_changed_cb(connection_h connection)
 842 {
 843         CONN_LOCK;
 844
 845         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 846
 847         if (!(__connection_check_handle_validity(connection))) {
 848                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 849                 CONN_UNLOCK;
 850                 return CONNECTION_ERROR_INVALID_PARAMETER;
 851         }
 852
 853         __connection_set_proxy_changed_callback(connection, NULL, NULL);
 854
 855         CONN_UNLOCK;
 856         return CONNECTION_ERROR_NONE;
 857 }
 858
 859 EXPORT_API int connection_set_internet_state_changed_cb(connection_h connection,
 860                 connection_internet_state_changed_cb callback, void *user_data)
 861 {
 862         CONN_LOCK;
 863
 864         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 865
 866         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 867                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 868                 CONN_UNLOCK;
 869                 return CONNECTION_ERROR_INVALID_PARAMETER;
 870         }
 871
 872         __connection_set_internet_state_changed_callback(connection, callback, user_data);
 873
 874         CONN_UNLOCK;
 875         return CONNECTION_ERROR_NONE;
 876 }
 877
 878 EXPORT_API int connection_unset_internet_state_changed_cb(connection_h connection)
 879 {
 880         CONN_LOCK;
 881
 882         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 883
 884         if (!(__connection_check_handle_validity(connection))) {
 885                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 886                 CONN_UNLOCK;
 887                 return CONNECTION_ERROR_INVALID_PARAMETER;
 888         }
 889
 890         __connection_set_internet_state_changed_callback(connection, NULL, NULL);
 891
 892         CONN_UNLOCK;
 893         return CONNECTION_ERROR_NONE;
 894 }
 895
 896 EXPORT_API int connection_add_profile(connection_h connection, connection_profile_h profile)
 897 {
 898         int rv = 0;
 899         connection_handle_s *conn_handle = (connection_handle_s *)connection;
 900         net_profile_info_t *profile_info = (net_profile_info_t *)profile;
 901
 902         CONN_LOCK;
 903
 904         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 905
 906         if (!(__connection_check_handle_validity(connection)) ||
 907             !(_connection_libnet_check_profile_validity(profile))) {
 908                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 909                 CONN_UNLOCK;
 910                 return CONNECTION_ERROR_INVALID_PARAMETER;
 911         }
 912
 913         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
 914                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 915                 CONN_UNLOCK; //LCOV_EXCL_LINE
 916                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 917         }
 918
 919         if (profile_info->ProfileInfo.Pdp.PSModemPath[0] != '/' ||
 920                         strlen(profile_info->ProfileInfo.Pdp.PSModemPath) < 2) {
 921                 CONNECTION_LOG(CONNECTION_ERROR, "Modem object path is NULL"); //LCOV_EXCL_LINE
 922                 CONN_UNLOCK; //LCOV_EXCL_LINE
 923                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 924         }
 925
 926         rv = net_add_profile(conn_handle->network_info_handle,
 927                                 profile_info->ProfileInfo.Pdp.ServiceType, profile_info);
 928         if (rv == NET_ERR_ACCESS_DENIED) {
 929                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 930                 CONN_UNLOCK; //LCOV_EXCL_LINE
 931                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 932         } else if (rv != NET_ERR_NONE) {
 933                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to add profile[%d]", rv); //LCOV_EXCL_LINE
 934                 CONN_UNLOCK; //LCOV_EXCL_LINE
 935                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 936         }
 937
 938         CONN_UNLOCK;
 939         return CONNECTION_ERROR_NONE;
 940 }
 941
 942 EXPORT_API int connection_remove_profile(connection_h connection, connection_profile_h profile)
 943 {
 944         int rv = 0;
 945         connection_handle_s *conn_handle = (connection_handle_s *)connection;
 946         net_profile_info_t *profile_info = (net_profile_info_t *)profile;
 947
 948         CONN_LOCK;
 949
 950         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
 951
 952         if (!(__connection_check_handle_validity(connection)) ||
 953                 !(_connection_libnet_check_profile_validity(profile))) {
 954                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 955                 CONN_UNLOCK;
 956                 return CONNECTION_ERROR_INVALID_PARAMETER;
 957         }
 958
 959         if (profile_info->profile_type != NET_DEVICE_CELLULAR &&
 960                 profile_info->profile_type != NET_DEVICE_MESH &&
 961             profile_info->profile_type != NET_DEVICE_WIFI) {
 962                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 963                 CONN_UNLOCK; //LCOV_EXCL_LINE
 964                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 965         }
 966
 967         rv = net_delete_profile(conn_handle->network_info_handle, profile_info->ProfileName);
 968         if (rv == NET_ERR_ACCESS_DENIED) {
 969                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 970                 CONN_UNLOCK; //LCOV_EXCL_LINE
 971                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 972         } else if (rv != NET_ERR_NONE) {
 973                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to delete profile[%d]", rv); //LCOV_EXCL_LINE
 974                 CONN_UNLOCK; //LCOV_EXCL_LINE
 975                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 976         }
 977
 978         CONN_UNLOCK;
 979         return CONNECTION_ERROR_NONE;
 980 }
 981
 982 EXPORT_API int connection_update_profile(connection_h connection, connection_profile_h profile)
 983 {
 984         int rv = 0;
 985         connection_handle_s *conn_handle = (connection_handle_s *)connection;
 986         net_profile_info_t *profile_info = (net_profile_info_t *)profile;
 987
 988         CONN_LOCK;
 989
 990         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
 991
 992         if (!(__connection_check_handle_validity(connection)) ||
 993             !(_connection_libnet_check_profile_validity(profile))) {
 994                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 995                 CONN_UNLOCK;
 996                 return CONNECTION_ERROR_INVALID_PARAMETER;
 997         }
 998
 999         rv = net_modify_profile(conn_handle->network_info_handle,
1000                         profile_info->ProfileName, (net_profile_info_t*)profile);
1001         if (rv == NET_ERR_ACCESS_DENIED) {
1002                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1003                 CONN_UNLOCK; //LCOV_EXCL_LINE
1004                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1005         } else if (rv != NET_ERR_NONE) {
1006                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to modify profile[%d]", rv); //LCOV_EXCL_LINE
1007                 CONN_UNLOCK; //LCOV_EXCL_LINE
1008                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1009         }
1010
1011         CONN_UNLOCK;
1012         return CONNECTION_ERROR_NONE;
1013 }
1014
1015 EXPORT_API int connection_get_profile_iterator(connection_h connection,
1016                 connection_iterator_type_e type, connection_profile_iterator_h* profile_iterator)
1017 {
1018         CONN_LOCK;
1019
1020         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1021
1022         if (!(__connection_check_handle_validity(connection)) ||
1023             (type != CONNECTION_ITERATOR_TYPE_REGISTERED &&
1024              type != CONNECTION_ITERATOR_TYPE_CONNECTED &&
1025              type != CONNECTION_ITERATOR_TYPE_DEFAULT)) {
1026                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1027                 CONN_UNLOCK;
1028                 return CONNECTION_ERROR_INVALID_PARAMETER;
1029         }
1030
1031         int rv = _connection_libnet_get_profile_iterator(connection, type, profile_iterator);
1032         if (rv != CONNECTION_ERROR_NONE) {
1033                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get profile iterator [%d]", rv); //LCOV_EXCL_LINE
1034                 CONN_UNLOCK; //LCOV_EXCL_LINE
1035                 return rv; //LCOV_EXCL_LINE
1036         }
1037
1038         CONN_UNLOCK;
1039         return CONNECTION_ERROR_NONE;
1040 }
1041
1042 EXPORT_API int connection_profile_iterator_next(connection_profile_iterator_h profile_iterator,
1043                                                         connection_profile_h* profile)
1044 {
1045         CONN_LOCK;
1046
1047         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1048
1049         int rv = _connection_libnet_get_iterator_next(profile_iterator, profile);
1050
1051         CONN_UNLOCK;
1052         return rv;
1053 }
1054
1055 EXPORT_API bool connection_profile_iterator_has_next(connection_profile_iterator_h profile_iterator)
1056 {
1057         CONN_LOCK;
1058
1059         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1060
1061         int rv = _connection_libnet_iterator_has_next(profile_iterator);
1062
1063         CONN_UNLOCK;
1064         return rv;
1065 }
1066
1067 EXPORT_API int connection_destroy_profile_iterator(connection_profile_iterator_h profile_iterator)
1068 {
1069         CONN_LOCK;
1070
1071         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1072
1073         int rv = _connection_libnet_destroy_iterator(profile_iterator);
1074
1075         CONN_UNLOCK;
1076         return rv;
1077 }
1078
1079 EXPORT_API int connection_get_current_profile(connection_h connection, connection_profile_h* profile)
1080 {
1081         CONN_LOCK;
1082
1083         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1084
1085         if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1086                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1087                 CONN_UNLOCK;
1088                 return CONNECTION_ERROR_INVALID_PARAMETER;
1089         }
1090
1091         int rv = _connection_libnet_get_current_profile(connection, profile);
1092         if (rv != CONNECTION_ERROR_NONE) {
1093                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get current profile [%d]", rv); //LCOV_EXCL_LINE
1094                 CONN_UNLOCK; //LCOV_EXCL_LINE
1095                 return rv; //LCOV_EXCL_LINE
1096         }
1097
1098         CONN_UNLOCK;
1099         return CONNECTION_ERROR_NONE;
1100 }
1101
1102 EXPORT_API int connection_get_default_cellular_service_profile(
1103                 connection_h connection, connection_cellular_service_type_e type,
1104                 connection_profile_h *profile)
1105 {
1106         CONN_LOCK;
1107
1108         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1109
1110         if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1111                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1112                 CONN_UNLOCK;
1113                 return CONNECTION_ERROR_INVALID_PARAMETER;
1114         }
1115
1116         int rv = _connection_libnet_get_cellular_service_profile(connection, type, profile);
1117         if (rv != CONNECTION_ERROR_NONE) {
1118                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get default cellular service profile [%d]", rv); //LCOV_EXCL_LINE
1119                 CONN_UNLOCK; //LCOV_EXCL_LINE
1120                 return rv; //LCOV_EXCL_LINE
1121         }
1122
1123         CONN_UNLOCK;
1124         return CONNECTION_ERROR_NONE;
1125 }
1126
1127 EXPORT_API int connection_set_default_cellular_service_profile(connection_h connection,
1128                 connection_cellular_service_type_e type, connection_profile_h profile)
1129 {
1130         CONN_LOCK;
1131
1132         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1133
1134         if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1135                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1136                 CONN_UNLOCK;
1137                 return CONNECTION_ERROR_INVALID_PARAMETER;
1138         }
1139
1140         int rv = _connection_libnet_set_cellular_service_profile_sync(connection, type, profile);
1141         if (rv != CONNECTION_ERROR_NONE) {
1142                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to set default cellular service profile [%d]", rv); //LCOV_EXCL_LINE
1143                 CONN_UNLOCK; //LCOV_EXCL_LINE
1144                 return rv; //LCOV_EXCL_LINE
1145         }
1146
1147         CONN_UNLOCK;
1148         return CONNECTION_ERROR_NONE;
1149 }
1150
1151 EXPORT_API int connection_set_default_cellular_service_profile_async(connection_h connection,
1152                 connection_cellular_service_type_e type, connection_profile_h profile,
1153                 connection_set_default_cb callback, void* user_data)
1154 {
1155         CONN_LOCK;
1156
1157         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1158
1159         int rv;
1160
1161         if (!(__connection_check_handle_validity(connection)) ||
1162             profile == NULL || callback == NULL) {
1163                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1164                 CONN_UNLOCK;
1165                 return CONNECTION_ERROR_INVALID_PARAMETER;
1166         }
1167
1168         rv = _connection_libnet_set_cellular_service_profile_async(connection, type, profile);
1169         if (rv == NET_ERR_ACCESS_DENIED) {
1170                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1171                 CONN_UNLOCK; //LCOV_EXCL_LINE
1172                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1173         } else if (rv != NET_ERR_NONE) {
1174                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to set default cellular service profile[%d]", rv); //LCOV_EXCL_LINE
1175                 CONN_UNLOCK; //LCOV_EXCL_LINE
1176                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1177         }
1178
1179         __connection_set_default_cellular_service_profile_callback(connection, callback, user_data);
1180
1181         CONN_UNLOCK;
1182         return CONNECTION_ERROR_NONE;
1183 }
1184
1185 EXPORT_API int connection_open_profile(connection_h connection, connection_profile_h profile,
1186                                         connection_opened_cb callback, void* user_data)
1187 {
1188         CONN_LOCK;
1189
1190         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1191
1192         int rv;
1193
1194         if (!(__connection_check_handle_validity(connection)) ||
1195             profile == NULL || callback == NULL) {
1196                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1197                 CONN_UNLOCK;
1198                 return CONNECTION_ERROR_INVALID_PARAMETER;
1199         }
1200
1201         rv = _connection_libnet_open_profile(connection, profile);
1202         if (rv == NET_ERR_ACCESS_DENIED) {
1203                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1204                 CONN_UNLOCK; //LCOV_EXCL_LINE
1205                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1206         } else if (rv != NET_ERR_NONE) {
1207                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to open profile[%d]", rv); //LCOV_EXCL_LINE
1208                 CONN_UNLOCK; //LCOV_EXCL_LINE
1209                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1210         }
1211
1212         __connection_open_profile_set_callback(connection, callback, user_data);
1213
1214         CONN_UNLOCK;
1215         return CONNECTION_ERROR_NONE;
1216 }
1217
1218 EXPORT_API int connection_close_profile(connection_h connection, connection_profile_h profile,
1219                                         connection_closed_cb callback, void* user_data)
1220 {
1221         CONN_LOCK;
1222
1223         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1224
1225         int rv;
1226
1227         if (!(__connection_check_handle_validity(connection)) ||
1228             profile == NULL || callback == NULL) {
1229                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1230                 CONN_UNLOCK;
1231                 return CONNECTION_ERROR_INVALID_PARAMETER;
1232         }
1233
1234         rv = _connection_libnet_close_profile(connection, profile);
1235         if (rv == NET_ERR_ACCESS_DENIED) {
1236                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1237                 CONN_UNLOCK; //LCOV_EXCL_LINE
1238                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1239         } else if (rv != NET_ERR_NONE) {
1240                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to close profile[%d]", rv); //LCOV_EXCL_LINE
1241                 CONN_UNLOCK; //LCOV_EXCL_LINE
1242                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1243         }
1244
1245         __connection_close_profile_set_callback(connection, callback, user_data);
1246
1247         CONN_UNLOCK;
1248         return CONNECTION_ERROR_NONE;
1249 }
1250
1251 EXPORT_API int connection_reset_profile(connection_h connection,
1252                                 connection_reset_option_e type, int id, connection_reset_cb callback, void *user_data)
1253 {
1254         CONN_LOCK;
1255
1256         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1257
1258         int rv;
1259
1260         if (!(__connection_check_handle_validity(connection))) {
1261                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed");
1262                 CONN_UNLOCK;
1263                 return CONNECTION_ERROR_INVALID_PARAMETER;
1264         }
1265
1266         if (id < 0 || id > 1) {
1267                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed"); //LCOV_EXCL_LINE
1268                 CONN_UNLOCK; //LCOV_EXCL_LINE
1269                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1270         }
1271
1272         rv = _connection_libnet_reset_profile(connection, type, id);
1273         if (rv == NET_ERR_ACCESS_DENIED) {
1274                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1275                 CONN_UNLOCK; //LCOV_EXCL_LINE
1276                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1277         } else if (rv != NET_ERR_NONE) {
1278                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to reset profile[%d]", rv); //LCOV_EXCL_LINE
1279                 CONN_UNLOCK; //LCOV_EXCL_LINE
1280                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1281         }
1282
1283         __connection_reset_profile_set_callback(connection, callback, user_data);
1284
1285         CONN_UNLOCK;
1286         return CONNECTION_ERROR_NONE;
1287 }
1288
1289 EXPORT_API int connection_add_route(connection_h connection, const char* interface_name, const char* host_address)
1290 {
1291         CONN_LOCK;
1292
1293         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1294
1295         if (!(__connection_check_handle_validity(connection)) ||
1296             interface_name == NULL || host_address == NULL) {
1297                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1298                 CONN_UNLOCK;
1299                 return CONNECTION_ERROR_INVALID_PARAMETER;
1300         }
1301
1302         int rv = _connection_libnet_add_route(connection, interface_name, host_address);
1303         if (rv != CONNECTION_ERROR_NONE) {
1304                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to add route [%d]", rv); //LCOV_EXCL_LINE
1305                 CONN_UNLOCK; //LCOV_EXCL_LINE
1306                 return rv; //LCOV_EXCL_LINE
1307         }
1308
1309         CONN_UNLOCK;
1310         return CONNECTION_ERROR_NONE;
1311 }
1312
1313 EXPORT_API int connection_remove_route(connection_h connection, const char* interface_name, const char* host_address)
1314 {
1315         CONN_LOCK;
1316
1317         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1318
1319         if (!(__connection_check_handle_validity(connection)) ||
1320             interface_name == NULL || host_address == NULL) {
1321                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1322                 CONN_UNLOCK;
1323                 return CONNECTION_ERROR_INVALID_PARAMETER;
1324         }
1325
1326         int rv = _connection_libnet_remove_route(connection, interface_name, host_address);
1327         if (rv != CONNECTION_ERROR_NONE) {
1328                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to remove route [%d]", rv); //LCOV_EXCL_LINE
1329                 CONN_UNLOCK; //LCOV_EXCL_LINE
1330                 return rv; //LCOV_EXCL_LINE
1331         }
1332
1333         CONN_UNLOCK;
1334         return CONNECTION_ERROR_NONE;
1335 }
1336
1337 EXPORT_API int connection_add_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
1338 {
1339         CONN_LOCK;
1340
1341         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1342
1343         if (!(__connection_check_handle_validity(connection)) ||
1344             interface_name == NULL || host_address == NULL) {
1345                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1346                 CONN_UNLOCK;
1347                 return CONNECTION_ERROR_INVALID_PARAMETER;
1348         }
1349
1350         int rv = _connection_libnet_add_route_ipv6(connection, interface_name, host_address, gateway);
1351         if (rv != CONNECTION_ERROR_NONE) {
1352                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to add route ipv6 [%d]", rv); //LCOV_EXCL_LINE
1353                 CONN_UNLOCK; //LCOV_EXCL_LINE
1354                 return rv; //LCOV_EXCL_LINE
1355         }
1356
1357         CONN_UNLOCK;
1358         return CONNECTION_ERROR_NONE;
1359 }
1360
1361 EXPORT_API int connection_remove_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
1362 {
1363         CONN_LOCK;
1364
1365         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1366
1367         if (!(__connection_check_handle_validity(connection)) ||
1368             interface_name == NULL || host_address == NULL) {
1369                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1370                 CONN_UNLOCK;
1371                 return CONNECTION_ERROR_INVALID_PARAMETER;
1372         }
1373
1374         int rv = _connection_libnet_remove_route_ipv6(connection, interface_name, host_address, gateway);
1375         if (rv != CONNECTION_ERROR_NONE) {
1376                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to remove route ipv6 [%d]", rv); //LCOV_EXCL_LINE
1377                 CONN_UNLOCK; //LCOV_EXCL_LINE
1378                 return rv; //LCOV_EXCL_LINE
1379         }
1380
1381         CONN_UNLOCK;
1382         return CONNECTION_ERROR_NONE;
1383 }
1384
1385 EXPORT_API int connection_add_route_entry(connection_h connection,
1386                 connection_address_family_e address_family,     const char *interface_name,
1387                 const char *host_address, const char *gateway)
1388 {
1389         CONN_LOCK;
1390
1391         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1392
1393         if (!(__connection_check_handle_validity(connection)) ||
1394                 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1395              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1396             interface_name == NULL || host_address == NULL) {
1397                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1398                 CONN_UNLOCK;
1399                 return CONNECTION_ERROR_INVALID_PARAMETER;
1400         }
1401
1402         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1403                 int rv = _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4,
1404                                                                 interface_name, host_address, gateway);
1405                 CONN_UNLOCK;
1406                 return rv;
1407         } else {
1408                 int rv = _connection_libnet_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6,
1409                                                                 interface_name, host_address, gateway);
1410                 CONN_UNLOCK;
1411                 return rv;
1412         }
1413 }
1414
1415 EXPORT_API int connection_remove_route_entry(connection_h connection,
1416                 connection_address_family_e address_family,     const char *interface_name,
1417                 const char *host_address, const char *gateway)
1418 {
1419         CONN_LOCK;
1420
1421         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1422
1423         if (!(__connection_check_handle_validity(connection)) ||
1424                 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1425              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1426             interface_name == NULL || host_address == NULL) {
1427                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1428                 CONN_UNLOCK;
1429                 return CONNECTION_ERROR_INVALID_PARAMETER;
1430         }
1431
1432         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1433                 int rv = _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4,
1434                                                                 interface_name, host_address, gateway);
1435                 CONN_UNLOCK;
1436                 return rv;
1437         } else {
1438                 int rv = _connection_libnet_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6,
1439                                                                 interface_name, host_address, gateway);
1440                 CONN_UNLOCK;
1441                 return rv;
1442         }
1443 }
1444
1445 static int __get_cellular_statistic(connection_statistics_type_e statistics_type, long long *llsize)
1446 {
1447         int rv = VCONF_OK, rv1 = VCONF_OK;
1448         int last_size = 0, size = 0;
1449 #if defined TIZEN_DUALSIM_ENABLE
1450         int sim_id = 0;
1451 #endif
1452
1453         if (llsize == NULL) {
1454                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1455                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1456         }
1457
1458         switch (statistics_type) {
1459         case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1460         case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1461         case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1462         case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1463                 break;
1464         default:
1465                 return CONNECTION_ERROR_INVALID_PARAMETER;
1466         }
1467
1468 #if defined TIZEN_DUALSIM_ENABLE
1469         rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id);
1470         if (rv != VCONF_OK) {
1471                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get default subscriber id");
1472                 *llsize = 0;
1473                 return CONNECTION_ERROR_OPERATION_FAILED;
1474         }
1475
1476         switch (sim_id) {
1477         case 0:
1478 #endif
1479                 switch (statistics_type) {
1480                 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1481                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size);
1482                         break;
1483                 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1484                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size);
1485                         break;
1486                 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1487                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size);
1488                         rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT, &size);
1489                         break;
1490                 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1491                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size);
1492                         rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV, &size);
1493                         break;
1494                 }
1495 #if defined TIZEN_DUALSIM_ENABLE
1496                 break;
1497         case 1:
1498                 switch (statistics_type) {
1499                 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1500                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size);
1501                         break;
1502                 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1503                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size);
1504                         break;
1505                 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1506                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size);
1507                         rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT2, &size);
1508                         break;
1509                 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1510                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size);
1511                         rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV2, &size);
1512                         break;
1513                 }
1514                 break;
1515         default:
1516                 *llsize = 0;
1517                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
1518                 return CONNECTION_ERROR_OPERATION_FAILED;
1519         }
1520 #endif
1521
1522         if (rv != VCONF_OK || rv1 != VCONF_OK) {
1523                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular statistics"); //LCOV_EXCL_LINE
1524                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1525         }
1526
1527         *llsize = (long long)(last_size * 1000) + (long long)(size * 1000);
1528         CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", *llsize);
1529
1530         return CONNECTION_ERROR_NONE;
1531 }
1532
1533 static int __get_statistic(connection_handle_s *conn_handle, connection_type_e connection_type,
1534                 connection_statistics_type_e statistics_type, long long *llsize)
1535 {
1536         int rv, stat_type;
1537         unsigned long long ull_size;
1538
1539         if (llsize == NULL) {
1540                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1541                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1542         }
1543
1544         rv  = _connection_libnet_check_get_privilege();
1545         if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
1546                 return rv;
1547         else if (rv != CONNECTION_ERROR_NONE) {
1548                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get statistics"); //LCOV_EXCL_LINE
1549                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1550         }
1551
1552         if (connection_type == CONNECTION_TYPE_CELLULAR)
1553                 return __get_cellular_statistic(statistics_type, llsize);
1554         else if (connection_type == CONNECTION_TYPE_WIFI) {
1555                 switch (statistics_type) {
1556                 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1557                         stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
1558                         break;
1559                 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1560                         stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
1561                         break;
1562                 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1563                         stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
1564                         break;
1565                 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1566                         stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
1567                         break;
1568                 default:
1569                         return CONNECTION_ERROR_INVALID_PARAMETER;
1570                 }
1571
1572                 rv  = _connection_libnet_get_statistics(conn_handle, stat_type, &ull_size);
1573                 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
1574                         return rv;
1575                 else if (rv != CONNECTION_ERROR_NONE) {
1576                         CONNECTION_LOG(CONNECTION_ERROR, "Failed to get Wi-Fi statistics"); //LCOV_EXCL_LINE
1577                         *llsize = 0; //LCOV_EXCL_LINE
1578                         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1579                 }
1580
1581                 CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", ull_size);
1582                 *llsize = (long long)ull_size;
1583         } else
1584                 return CONNECTION_ERROR_INVALID_PARAMETER;
1585
1586         return CONNECTION_ERROR_NONE;
1587 }
1588
1589 static int __reset_statistic(connection_handle_s *conn_handle,
1590                         connection_type_e connection_type, connection_statistics_type_e statistics_type)
1591 {
1592         int conn_type;
1593         int stat_type;
1594         int rv;
1595
1596         if (connection_type == CONNECTION_TYPE_CELLULAR)
1597                 conn_type = NET_DEVICE_CELLULAR;
1598         else if (connection_type == CONNECTION_TYPE_WIFI)
1599                 conn_type = NET_DEVICE_WIFI;
1600         else
1601                 return CONNECTION_ERROR_INVALID_PARAMETER;
1602
1603         switch (statistics_type) {
1604         case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1605                 stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
1606                 break;
1607         case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1608                 stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
1609                 break;
1610         case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1611                 stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
1612                 break;
1613         case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1614                 stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
1615                 break;
1616         default:
1617                 return CONNECTION_ERROR_INVALID_PARAMETER;
1618         }
1619
1620         rv = _connection_libnet_set_statistics(conn_handle, conn_type, stat_type);
1621         if (rv != CONNECTION_ERROR_NONE)
1622                 return rv;
1623
1624         CONNECTION_LOG(CONNECTION_INFO, "connection_reset_statistics success");
1625
1626         return CONNECTION_ERROR_NONE;
1627 }
1628
1629 EXPORT_API int connection_get_statistics(connection_h connection,
1630                                 connection_type_e connection_type,
1631                                 connection_statistics_type_e statistics_type, long long* size)
1632 {
1633         CONN_LOCK;
1634
1635         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
1636
1637         if (connection_type == CONNECTION_TYPE_CELLULAR)
1638                 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1639         else if (connection_type == CONNECTION_TYPE_WIFI)
1640                 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1641
1642         if (!(__connection_check_handle_validity(connection)) || size == NULL) {
1643                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1644                 CONN_UNLOCK;
1645                 return CONNECTION_ERROR_INVALID_PARAMETER;
1646         }
1647
1648         int rv = __get_statistic(connection, connection_type, statistics_type, size);
1649         if (rv != CONNECTION_ERROR_NONE) {
1650                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get statistics [%d]", rv); //LCOV_EXCL_LINE
1651                 CONN_UNLOCK;
1652                 return rv; //LCOV_EXCL_LINE
1653         }
1654
1655         CONN_UNLOCK;
1656         return CONNECTION_ERROR_NONE;
1657 }
1658
1659 EXPORT_API int connection_reset_statistics(connection_h connection,
1660                                 connection_type_e connection_type,
1661                                 connection_statistics_type_e statistics_type)
1662 {
1663         CONN_LOCK;
1664
1665         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
1666
1667         if (connection_type == CONNECTION_TYPE_CELLULAR)
1668                 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1669         else if (connection_type == CONNECTION_TYPE_WIFI)
1670                 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1671
1672         if (!__connection_check_handle_validity(connection)) {
1673                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1674                 CONN_UNLOCK;
1675                 return CONNECTION_ERROR_INVALID_PARAMETER;
1676         }
1677
1678         int rv = __reset_statistic(connection, connection_type, statistics_type);
1679         if (rv != CONNECTION_ERROR_NONE) {
1680                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get statistics [%d]", rv); //LCOV_EXCL_LINE
1681                 CONN_UNLOCK;
1682                 return rv; //LCOV_EXCL_LINE
1683         }
1684
1685         CONN_UNLOCK;
1686         return CONNECTION_ERROR_NONE;
1687 }
1688
1689 EXPORT_API int connection_foreach_ipv6_address(connection_h connection,
1690                 connection_type_e connection_type, connection_ipv6_address_cb callback,
1691                 void *user_data)
1692 {
1693         CONN_LOCK;
1694
1695         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1696                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1697
1698         GSList *ipv6_address_list = NULL;
1699
1700         if (!(__connection_check_handle_validity(connection))) {
1701                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1702                 CONN_UNLOCK;
1703                 return CONNECTION_ERROR_INVALID_PARAMETER;
1704         }
1705
1706         int rv = CONNECTION_ERROR_NONE;
1707
1708         switch (connection_type) {
1709         case CONNECTION_TYPE_WIFI:
1710                 rv = net_foreach_ipv6_address(NET_DEVICE_WIFI,
1711                                 &ipv6_address_list);
1712                 break;
1713         case CONNECTION_TYPE_CELLULAR:
1714                 rv = net_foreach_ipv6_address(NET_DEVICE_CELLULAR,
1715                                 &ipv6_address_list);
1716                 break;
1717         case CONNECTION_TYPE_ETHERNET:
1718                 rv = net_foreach_ipv6_address(NET_DEVICE_ETHERNET,
1719                                 &ipv6_address_list);
1720                 break;
1721         case CONNECTION_TYPE_BT:
1722                 rv = net_foreach_ipv6_address(NET_DEVICE_BLUETOOTH,
1723                                 &ipv6_address_list);
1724                 break;
1725         default:
1726                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1727                 CONN_UNLOCK;
1728                 return CONNECTION_ERROR_INVALID_PARAMETER;
1729         }
1730
1731         if (rv != NET_ERR_NONE) {
1732                 CONNECTION_LOG(CONNECTION_ERROR, "net_get_multiple_id_address" //LCOV_EXCL_LINE
1733                                 " Failed = %d\n", rv);
1734                 CONN_UNLOCK; //LCOV_EXCL_LINE
1735                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1736         }
1737
1738         GSList *list;
1739         for (list = ipv6_address_list; list; list = list->next) {
1740                 rv = callback((char *)list->data, user_data);
1741                 if (rv == false)
1742                         break;
1743         }
1744
1745         g_slist_free_full(ipv6_address_list, g_free);
1746         ipv6_address_list = NULL;
1747
1748         CONN_UNLOCK;
1749         return CONNECTION_ERROR_NONE;
1750 }
1751
1752 EXPORT_API int connection_profile_start_tcpdump(connection_h connection)
1753 {
1754         int ret = 0;
1755
1756         CONN_LOCK;
1757
1758         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1759
1760         if (!(__connection_check_handle_validity(connection))) {
1761                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1762                 CONN_UNLOCK;
1763                 return CONNECTION_ERROR_INVALID_PARAMETER;
1764         }
1765
1766         ret = _connection_libnet_start_tcpdump(connection);
1767         if (ret != CONNECTION_ERROR_NONE) {
1768                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to start tcpdump (%d)", ret); //LCOV_EXCL_LINE
1769                 CONN_UNLOCK; //LCOV_EXCL_LINE
1770                 return ret; //LCOV_EXCL_LINE
1771         }
1772
1773         CONN_UNLOCK;
1774         return CONNECTION_ERROR_NONE;
1775 }
1776
1777 EXPORT_API int connection_profile_stop_tcpdump(connection_h connection)
1778 {
1779         int ret = 0;
1780
1781         CONN_LOCK;
1782
1783         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1784
1785         if (!(__connection_check_handle_validity(connection))) {
1786                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1787                 CONN_UNLOCK;
1788                 return CONNECTION_ERROR_INVALID_PARAMETER;
1789         }
1790
1791         ret = _connection_libnet_stop_tcpdump(connection);
1792         if (ret != CONNECTION_ERROR_NONE) {
1793                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to stop tcpdump (%d)", ret); //LCOV_EXCL_LINE
1794                 CONN_UNLOCK; //LCOV_EXCL_LINE
1795                 return ret; //LCOV_EXCL_LINE
1796         }
1797
1798         CONN_UNLOCK;
1799         return CONNECTION_ERROR_NONE;
1800 }
1801
1802 EXPORT_API int connection_profile_get_tcpdump_state(connection_h connection, gboolean *tcpdump_state)
1803 {
1804         int ret = 0;
1805
1806         CONN_LOCK;
1807
1808         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1809
1810         if (!(__connection_check_handle_validity(connection)) || !tcpdump_state) {
1811                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1812                 CONN_UNLOCK;
1813                 return CONNECTION_ERROR_INVALID_PARAMETER;
1814         }
1815
1816         ret = _connection_libnet_get_tcpdump_state(connection, tcpdump_state);
1817         if (ret != CONNECTION_ERROR_NONE) {
1818                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get the tcpdump state (%d)", ret); //LCOV_EXCL_LINE
1819                 CONN_UNLOCK; //LCOV_EXCL_LINE
1820                 return ret; //LCOV_EXCL_LINE
1821         }
1822
1823         CONN_UNLOCK;
1824         return CONNECTION_ERROR_NONE;
1825 }
1826
1827 EXPORT_API int connection_profile_save_ethernet_eap_config(connection_h connection,
1828                                                         connection_profile_h profile)
1829 {
1830         CONN_LOCK;
1831
1832         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1833
1834         int rv;
1835
1836         if (!__connection_check_handle_validity(connection) ||
1837                 !_connection_libnet_check_profile_validity(profile)) {
1838                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1839                 CONN_UNLOCK;
1840                 return CONNECTION_ERROR_INVALID_PARAMETER;
1841         }
1842
1843         rv = _connection_libnet_profile_save_ethernet_eap_config(connection, profile);
1844         if (rv != CONNECTION_ERROR_NONE) {
1845                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to save ethernet eap config."); //LCOV_EXCL_LINE
1846                 CONN_UNLOCK; //LCOV_EXCL_LINE
1847                 return rv; //LCOV_EXCL_LINE
1848         }
1849
1850         CONN_UNLOCK;
1851         return CONNECTION_ERROR_NONE;
1852 }