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