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