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