src/connection.c

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