src/connection.c

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