src/connection.c

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