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