src/connection.c

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