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