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