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_get_cellular_state(connection_h connection, connection_cellular_state_e* state)
 671 {
 672         int rv = 0;
 673         int status = 0;
 674         int cellular_state = 0;
 675 #if defined TIZEN_DUALSIM_ENABLE
 676         int sim_id = 0;
 677 #endif
 678
 679         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 680
 681         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 682                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 683                 return CONNECTION_ERROR_INVALID_PARAMETER;
 684         }
 685
 686         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &status);
 687         if (rv != VCONF_OK) {
 688                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
 689                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 690         }
 691
 692         CONNECTION_LOG(CONNECTION_INFO, "Cellular: %d", status);
 693         *state = __connection_convert_cellular_state(status);
 694
 695         if (*state == CONNECTION_CELLULAR_STATE_AVAILABLE) {
 696 #if defined TIZEN_DUALSIM_ENABLE
 697                 rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id);
 698                 if (rv != VCONF_OK) {
 699                         CONNECTION_LOG(CONNECTION_ERROR,
 700                                         "Failed to get default subscriber id", sim_id);
 701                         return CONNECTION_ERROR_OPERATION_FAILED;
 702                 }
 703
 704                 switch (sim_id) {
 705                 case CONNECTION_CELLULAR_SUBSCRIBER_1:
 706 #endif
 707                         rv = vconf_get_int(VCONFKEY_DNET_STATE, &cellular_state);
 708 #if defined TIZEN_DUALSIM_ENABLE
 709                         break;
 710
 711                 case CONNECTION_CELLULAR_SUBSCRIBER_2:
 712                         rv = vconf_get_int(VCONFKEY_DNET_STATE2, &cellular_state);
 713                         break;
 714
 715                 default:
 716                         CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
 717                         return CONNECTION_ERROR_OPERATION_FAILED;
 718                 }
 719 #endif
 720                 if (rv != VCONF_OK) {
 721                         CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular state"); //LCOV_EXCL_LINE
 722                         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 723                 }
 724         }
 725
 726         CONNECTION_LOG(CONNECTION_INFO, "Cellular state: %d", cellular_state);
 727
 728         if (cellular_state == VCONFKEY_DNET_NORMAL_CONNECTED ||
 729                         cellular_state == VCONFKEY_DNET_SECURE_CONNECTED ||
 730                         cellular_state == VCONFKEY_DNET_TRANSFER)
 731                 *state = CONNECTION_CELLULAR_STATE_CONNECTED;
 732
 733         return CONNECTION_ERROR_NONE;
 734 }
 735
 736 EXPORT_API int connection_get_wifi_state(connection_h connection, connection_wifi_state_e* state)
 737 {
 738         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 739
 740         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 741                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 742                 return CONNECTION_ERROR_INVALID_PARAMETER;
 743         }
 744
 745         int rv = _connection_libnet_get_wifi_state(state);
 746         if (rv != CONNECTION_ERROR_NONE) {
 747                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get Wi-Fi state[%d]", rv); //LCOV_EXCL_LINE
 748                 return rv; //LCOV_EXCL_LINE
 749         }
 750
 751         CONNECTION_LOG(CONNECTION_INFO, "Wi-Fi state: %d", *state);
 752
 753         return CONNECTION_ERROR_NONE;
 754 }
 755
 756 //LCOV_EXCL_START
 757 EXPORT_API int connection_get_ethernet_state(connection_h connection, connection_ethernet_state_e *state)
 758 {
 759         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 760
 761         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 762                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 763                 return CONNECTION_ERROR_INVALID_PARAMETER;
 764         }
 765
 766         return _connection_libnet_get_ethernet_state(state);
 767 }
 768
 769 EXPORT_API int connection_get_ethernet_cable_state(connection_h connection, connection_ethernet_cable_state_e *state)
 770 {
 771         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 772
 773         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 774                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 775                 return CONNECTION_ERROR_INVALID_PARAMETER;
 776         }
 777
 778         return _connection_libnet_get_ethernet_cable_state(state);
 779 }
 780
 781 EXPORT_API int connection_set_ethernet_cable_state_chaged_cb(connection_h connection,
 782                           connection_ethernet_cable_state_chaged_cb callback, void *user_data)
 783 {
 784         DEPRECATED_LOG(__FUNCTION__, "connection_set_ethernet_cable_state_changed_cb");
 785         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 786
 787         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 788                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 789                 return CONNECTION_ERROR_INVALID_PARAMETER;
 790         }
 791
 792         DEPRECATED_LOG("connection_ethernet_cable_state_chaged_cb",
 793                         "connection_ethernet_cable_state_changed_cb");
 794
 795         return __connection_set_ethernet_cable_state_changed_cb(connection,
 796                         (connection_ethernet_cable_state_changed_cb)callback, user_data);
 797 }
 798
 799 EXPORT_API int connection_unset_ethernet_cable_state_chaged_cb(connection_h connection)
 800 {
 801         DEPRECATED_LOG(__FUNCTION__, "connection_unset_ethernet_cable_state_changed_cb");
 802         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 803
 804         if (!(__connection_check_handle_validity(connection))) {
 805                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 806                 return CONNECTION_ERROR_INVALID_PARAMETER;
 807         }
 808
 809         return __connection_set_ethernet_cable_state_changed_cb(connection,
 810                                                         NULL, NULL);
 811 }
 812
 813 EXPORT_API int connection_set_ethernet_cable_state_changed_cb(connection_h connection,
 814                           connection_ethernet_cable_state_changed_cb callback, void *user_data)
 815 {
 816         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 817
 818         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 819                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 820                 return CONNECTION_ERROR_INVALID_PARAMETER;
 821         }
 822
 823         return __connection_set_ethernet_cable_state_changed_cb(connection,
 824                                                         callback, user_data);
 825 }
 826
 827 EXPORT_API int connection_unset_ethernet_cable_state_changed_cb(connection_h connection)
 828 {
 829         CHECK_FEATURE_SUPPORTED(ETHERNET_FEATURE);
 830
 831         if (!(__connection_check_handle_validity(connection))) {
 832                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 833                 return CONNECTION_ERROR_INVALID_PARAMETER;
 834         }
 835
 836         return __connection_set_ethernet_cable_state_changed_cb(connection,
 837                                                         NULL, NULL);
 838 }
 839 //LCOV_EXCL_STOP
 840
 841 EXPORT_API int connection_get_bt_state(connection_h connection, connection_bt_state_e *state)
 842 {
 843         CHECK_FEATURE_SUPPORTED(TETHERING_BLUETOOTH_FEATURE);
 844
 845         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 846                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 847                 return CONNECTION_ERROR_INVALID_PARAMETER;
 848         }
 849
 850         return _connection_libnet_get_bluetooth_state(state);
 851 }
 852
 853 EXPORT_API int connection_set_type_changed_cb(connection_h connection,
 854                                         connection_type_changed_cb callback, void* user_data)
 855 {
 856         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 857
 858         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 859                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 860                 return CONNECTION_ERROR_INVALID_PARAMETER;
 861         }
 862
 863         return __connection_set_type_changed_callback(connection, callback, user_data);
 864 }
 865
 866 EXPORT_API int connection_unset_type_changed_cb(connection_h connection)
 867 {
 868         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 869
 870         if (!(__connection_check_handle_validity(connection))) {
 871                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 872                 return CONNECTION_ERROR_INVALID_PARAMETER;
 873         }
 874
 875         return __connection_set_type_changed_callback(connection, NULL, NULL);
 876 }
 877
 878 EXPORT_API int connection_set_ip_address_changed_cb(connection_h connection,
 879                                 connection_address_changed_cb callback, void* user_data)
 880 {
 881         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 882
 883         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 884                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 885                 return CONNECTION_ERROR_INVALID_PARAMETER;
 886         }
 887
 888         return __connection_set_ip_changed_callback(connection, callback, user_data);
 889 }
 890
 891 EXPORT_API int connection_unset_ip_address_changed_cb(connection_h connection)
 892 {
 893         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 894
 895         if (!(__connection_check_handle_validity(connection))) {
 896                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 897                 return CONNECTION_ERROR_INVALID_PARAMETER;
 898         }
 899
 900         return __connection_set_ip_changed_callback(connection, NULL, NULL);
 901 }
 902
 903 EXPORT_API int connection_set_proxy_address_changed_cb(connection_h connection,
 904                                 connection_address_changed_cb callback, void* user_data)
 905 {
 906         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 907
 908         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 909                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 910                 return CONNECTION_ERROR_INVALID_PARAMETER;
 911         }
 912
 913         return __connection_set_proxy_changed_callback(connection, callback, user_data);
 914 }
 915
 916 EXPORT_API int connection_unset_proxy_address_changed_cb(connection_h connection)
 917 {
 918         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 919
 920         if (!(__connection_check_handle_validity(connection))) {
 921                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 922                 return CONNECTION_ERROR_INVALID_PARAMETER;
 923         }
 924
 925         return __connection_set_proxy_changed_callback(connection, NULL, NULL);
 926 }
 927
 928 EXPORT_API int connection_add_profile(connection_h connection, connection_profile_h profile)
 929 {
 930         int rv = 0;
 931         net_profile_info_t *profile_info = profile;
 932
 933         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 934
 935         if (!(__connection_check_handle_validity(connection)) ||
 936             !(_connection_libnet_check_profile_validity(profile))) {
 937                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 938                 return CONNECTION_ERROR_INVALID_PARAMETER;
 939         }
 940
 941         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
 942                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 943                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 944         }
 945
 946         if (profile_info->ProfileInfo.Pdp.PSModemPath[0] != '/' ||
 947                         strlen(profile_info->ProfileInfo.Pdp.PSModemPath) < 2) {
 948                 CONNECTION_LOG(CONNECTION_ERROR, "Modem object path is NULL"); //LCOV_EXCL_LINE
 949                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 950         }
 951
 952         rv = net_add_profile(profile_info->ProfileInfo.Pdp.ServiceType,
 953                                                         (net_profile_info_t*)profile);
 954         if (rv == NET_ERR_ACCESS_DENIED) {
 955                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 956                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 957         } else if (rv != NET_ERR_NONE) {
 958                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to add profile[%d]", rv); //LCOV_EXCL_LINE
 959                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 960         }
 961
 962         return CONNECTION_ERROR_NONE;
 963 }
 964
 965 EXPORT_API int connection_remove_profile(connection_h connection, connection_profile_h profile)
 966 {
 967         int rv = 0;
 968         net_profile_info_t *profile_info = profile;
 969
 970         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
 971
 972         if (!(__connection_check_handle_validity(connection)) ||
 973                         !(_connection_libnet_check_profile_validity(profile))) {
 974                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 975                 return CONNECTION_ERROR_INVALID_PARAMETER;
 976         }
 977
 978         if (profile_info->profile_type != NET_DEVICE_CELLULAR &&
 979             profile_info->profile_type != NET_DEVICE_WIFI) {
 980                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 981                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 982         }
 983
 984         rv = net_delete_profile(profile_info->ProfileName);
 985         if (rv == NET_ERR_ACCESS_DENIED) {
 986                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 987                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 988         } else if (rv != NET_ERR_NONE) {
 989                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to delete profile[%d]", rv); //LCOV_EXCL_LINE
 990                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 991         }
 992
 993         return CONNECTION_ERROR_NONE;
 994 }
 995
 996 EXPORT_API int connection_update_profile(connection_h connection, connection_profile_h profile)
 997 {
 998         int rv = 0;
 999         net_profile_info_t *profile_info = profile;
1000
1001         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1002
1003         if (!(__connection_check_handle_validity(connection)) ||
1004             !(_connection_libnet_check_profile_validity(profile))) {
1005                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1006                 return CONNECTION_ERROR_INVALID_PARAMETER;
1007         }
1008
1009         rv = net_modify_profile(profile_info->ProfileName, (net_profile_info_t*)profile);
1010         if (rv == NET_ERR_ACCESS_DENIED) {
1011                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1012                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1013         } else if (rv != NET_ERR_NONE) {
1014                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to modify profile[%d]", rv); //LCOV_EXCL_LINE
1015                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1016         }
1017
1018         return CONNECTION_ERROR_NONE;
1019 }
1020
1021 EXPORT_API int connection_get_profile_iterator(connection_h connection,
1022                 connection_iterator_type_e type, connection_profile_iterator_h* profile_iterator)
1023 {
1024         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1025
1026         if (!(__connection_check_handle_validity(connection)) ||
1027             (type != CONNECTION_ITERATOR_TYPE_REGISTERED &&
1028              type != CONNECTION_ITERATOR_TYPE_CONNECTED &&
1029              type != CONNECTION_ITERATOR_TYPE_DEFAULT)) {
1030                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1031                 return CONNECTION_ERROR_INVALID_PARAMETER;
1032         }
1033
1034         return _connection_libnet_get_profile_iterator(type, profile_iterator);
1035 }
1036
1037 EXPORT_API int connection_profile_iterator_next(connection_profile_iterator_h profile_iterator,
1038                                                         connection_profile_h* profile)
1039 {
1040         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1041
1042         return _connection_libnet_get_iterator_next(profile_iterator, profile);
1043 }
1044
1045 EXPORT_API bool connection_profile_iterator_has_next(connection_profile_iterator_h profile_iterator)
1046 {
1047         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1048
1049         return _connection_libnet_iterator_has_next(profile_iterator);
1050 }
1051
1052 EXPORT_API int connection_destroy_profile_iterator(connection_profile_iterator_h profile_iterator)
1053 {
1054         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1055
1056         return _connection_libnet_destroy_iterator(profile_iterator);
1057 }
1058
1059 EXPORT_API int connection_get_current_profile(connection_h connection, connection_profile_h* profile)
1060 {
1061         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1062
1063         if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1064                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1065                 return CONNECTION_ERROR_INVALID_PARAMETER;
1066         }
1067
1068         return _connection_libnet_get_current_profile(profile);
1069 }
1070
1071 EXPORT_API int connection_get_default_cellular_service_profile(
1072                 connection_h connection, connection_cellular_service_type_e type,
1073                 connection_profile_h *profile)
1074 {
1075         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1076
1077         if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1078                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1079                 return CONNECTION_ERROR_INVALID_PARAMETER;
1080         }
1081
1082         return _connection_libnet_get_cellular_service_profile(type, profile);
1083 }
1084
1085 EXPORT_API int connection_set_default_cellular_service_profile(connection_h connection,
1086                 connection_cellular_service_type_e type, connection_profile_h profile)
1087 {
1088         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1089
1090         if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
1091                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1092                 return CONNECTION_ERROR_INVALID_PARAMETER;
1093         }
1094
1095         return _connection_libnet_set_cellular_service_profile_sync(type, profile);
1096 }
1097
1098 EXPORT_API int connection_set_default_cellular_service_profile_async(connection_h connection,
1099                 connection_cellular_service_type_e type, connection_profile_h profile,
1100                 connection_set_default_cb callback, void* user_data)
1101 {
1102         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1103
1104         if (!(__connection_check_handle_validity(connection)) ||
1105             profile == NULL || callback == NULL) {
1106                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1107                 return CONNECTION_ERROR_INVALID_PARAMETER;
1108         }
1109
1110         return _connection_libnet_set_cellular_service_profile_async(type, profile, callback, user_data);
1111 }
1112
1113 EXPORT_API int connection_open_profile(connection_h connection, connection_profile_h profile,
1114                                         connection_opened_cb callback, void* user_data)
1115 {
1116         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1117
1118         if (!(__connection_check_handle_validity(connection)) ||
1119             profile == NULL || callback == NULL) {
1120                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1121                 return CONNECTION_ERROR_INVALID_PARAMETER;
1122         }
1123
1124         return _connection_libnet_open_profile(profile, callback, user_data);
1125 }
1126
1127 EXPORT_API int connection_close_profile(connection_h connection, connection_profile_h profile,
1128                                         connection_closed_cb callback, void* user_data)
1129 {
1130         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE);
1131
1132         if (!(__connection_check_handle_validity(connection)) ||
1133             profile == NULL || callback == NULL) {
1134                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1135                 return CONNECTION_ERROR_INVALID_PARAMETER;
1136         }
1137
1138         return _connection_libnet_close_profile(profile, callback, user_data);
1139 }
1140
1141 EXPORT_API int connection_reset_profile(connection_h connection,
1142                                 connection_reset_option_e type, int id, connection_reset_cb callback, void *user_data)
1143 {
1144         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1145
1146         if (!(__connection_check_handle_validity(connection))) {
1147                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed");
1148                 return CONNECTION_ERROR_INVALID_PARAMETER;
1149         }
1150
1151         if (id < 0 || id > 1) {
1152                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed"); //LCOV_EXCL_LINE
1153                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1154         }
1155
1156         return _connection_libnet_reset_profile(type, id, callback, user_data);
1157 }
1158
1159 EXPORT_API int connection_add_route(connection_h connection, const char* interface_name, const char* host_address)
1160 {
1161         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1162
1163         if (!(__connection_check_handle_validity(connection)) ||
1164             interface_name == NULL || host_address == NULL) {
1165                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1166                 return CONNECTION_ERROR_INVALID_PARAMETER;
1167         }
1168
1169         return _connection_libnet_add_route(interface_name, host_address);
1170 }
1171
1172 EXPORT_API int connection_remove_route(connection_h connection, const char* interface_name, const char* host_address)
1173 {
1174         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1175
1176         if (!(__connection_check_handle_validity(connection)) ||
1177             interface_name == NULL || host_address == NULL) {
1178                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1179                 return CONNECTION_ERROR_INVALID_PARAMETER;
1180         }
1181
1182         return _connection_libnet_remove_route(interface_name, host_address);
1183 }
1184
1185 EXPORT_API int connection_add_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
1186 {
1187         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1188
1189         if (!(__connection_check_handle_validity(connection)) ||
1190             interface_name == NULL || host_address == NULL) {
1191                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1192                 return CONNECTION_ERROR_INVALID_PARAMETER;
1193         }
1194
1195         return _connection_libnet_add_route_ipv6(interface_name, host_address, gateway);
1196 }
1197
1198 EXPORT_API int connection_remove_route_ipv6(connection_h connection, const char *interface_name, const char *host_address, const char * gateway)
1199 {
1200         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1201
1202         if (!(__connection_check_handle_validity(connection)) ||
1203             interface_name == NULL || host_address == NULL) {
1204                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1205                 return CONNECTION_ERROR_INVALID_PARAMETER;
1206         }
1207
1208         return _connection_libnet_remove_route_ipv6(interface_name, host_address, gateway);
1209 }
1210
1211 EXPORT_API int connection_add_route_entry(connection_h connection,
1212                 connection_address_family_e address_family,     const char *interface_name,
1213                 const char *host_address, const char *gateway)
1214 {
1215         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1216
1217         if (!(__connection_check_handle_validity(connection)) ||
1218                 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1219              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1220             interface_name == NULL || host_address == NULL) {
1221                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1222                 return CONNECTION_ERROR_INVALID_PARAMETER;
1223         }
1224
1225         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
1226                 return _connection_libnet_add_route_entry(CONNECTION_ADDRESS_FAMILY_IPV4,
1227                                                                 interface_name, host_address, gateway);
1228         else
1229                 return _connection_libnet_add_route_entry(CONNECTION_ADDRESS_FAMILY_IPV6,
1230                                                                 interface_name, host_address, gateway);
1231
1232         return CONNECTION_ERROR_NONE;
1233 }
1234
1235 EXPORT_API int connection_remove_route_entry(connection_h connection,
1236                 connection_address_family_e address_family,     const char *interface_name,
1237                 const char *host_address, const char *gateway)
1238 {
1239         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, ETHERNET_FEATURE);
1240
1241         if (!(__connection_check_handle_validity(connection)) ||
1242                 (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1243              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1244             interface_name == NULL || host_address == NULL) {
1245                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1246                 return CONNECTION_ERROR_INVALID_PARAMETER;
1247         }
1248
1249         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
1250                 return _connection_libnet_remove_route_entry(CONNECTION_ADDRESS_FAMILY_IPV4,
1251                                                                 interface_name, host_address, gateway);
1252         else
1253                 return _connection_libnet_remove_route_entry(CONNECTION_ADDRESS_FAMILY_IPV6,
1254                                                                 interface_name, host_address, gateway);
1255
1256         return CONNECTION_ERROR_NONE;
1257 }
1258
1259 static int __get_cellular_statistic(connection_statistics_type_e statistics_type, long long *llsize)
1260 {
1261         int rv = VCONF_OK, rv1 = VCONF_OK;
1262         int last_size = 0, size = 0;
1263 #if defined TIZEN_DUALSIM_ENABLE
1264         int sim_id = 0;
1265 #endif
1266
1267         if (llsize == NULL) {
1268                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1269                 return CONNECTION_ERROR_INVALID_PARAMETER;
1270         }
1271
1272         switch (statistics_type) {
1273         case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1274         case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1275         case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1276         case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1277                 break;
1278         default:
1279                 return CONNECTION_ERROR_INVALID_PARAMETER;
1280         }
1281
1282 #if defined TIZEN_DUALSIM_ENABLE
1283         rv = vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE, &sim_id);
1284         if (rv != VCONF_OK) {
1285                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get default subscriber id");
1286                 *llsize = 0;
1287                 return CONNECTION_ERROR_OPERATION_FAILED;
1288         }
1289
1290         switch (sim_id) {
1291         case 0:
1292 #endif
1293                 switch (statistics_type) {
1294                 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1295                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size);
1296                         break;
1297                 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1298                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size);
1299                         break;
1300                 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1301                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT, &last_size);
1302                         rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT, &size);
1303                         break;
1304                 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1305                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV, &last_size);
1306                         rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV, &size);
1307                         break;
1308                 }
1309 #if defined TIZEN_DUALSIM_ENABLE
1310                 break;
1311         case 1:
1312                 switch (statistics_type) {
1313                 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1314                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size);
1315                         break;
1316                 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1317                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size);
1318                         break;
1319                 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1320                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT2, &last_size);
1321                         rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT2, &size);
1322                         break;
1323                 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1324                         rv = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV2, &last_size);
1325                         rv1 = vconf_get_int(VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV2, &size);
1326                         break;
1327                 }
1328                 break;
1329         default:
1330                 *llsize = 0;
1331                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid subscriber id:%d", sim_id);
1332                 return CONNECTION_ERROR_OPERATION_FAILED;
1333         }
1334 #endif
1335
1336         if (rv != VCONF_OK || rv1 != VCONF_OK) {
1337                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get cellular statistics"); //LCOV_EXCL_LINE
1338                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1339         }
1340
1341         *llsize = (long long)(last_size * 1000) + (long long)(size * 1000);
1342         CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", *llsize);
1343
1344         return CONNECTION_ERROR_NONE;
1345 }
1346
1347 static int __get_statistic(connection_type_e connection_type,
1348                 connection_statistics_type_e statistics_type, long long *llsize)
1349 {
1350         int rv, stat_type;
1351         unsigned long long ull_size;
1352
1353         if (llsize == NULL) {
1354                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1355                 return CONNECTION_ERROR_INVALID_PARAMETER;
1356         }
1357
1358         rv  = _connection_libnet_check_get_privilege();
1359         if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
1360                 return rv;
1361         else if (rv != CONNECTION_ERROR_NONE) {
1362                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get statistics"); //LCOV_EXCL_LINE
1363                 return CONNECTION_ERROR_OPERATION_FAILED;
1364         }
1365
1366         if (connection_type == CONNECTION_TYPE_CELLULAR)
1367                 return __get_cellular_statistic(statistics_type, llsize);
1368         else if (connection_type == CONNECTION_TYPE_WIFI) {
1369                 switch (statistics_type) {
1370                 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1371                         stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
1372                         break;
1373                 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1374                         stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
1375                         break;
1376                 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1377                         stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
1378                         break;
1379                 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1380                         stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
1381                         break;
1382                 default:
1383                         return CONNECTION_ERROR_INVALID_PARAMETER;
1384                 }
1385
1386                 rv  = _connection_libnet_get_statistics(stat_type, &ull_size);
1387                 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
1388                         return rv;
1389                 else if (rv != CONNECTION_ERROR_NONE) {
1390                         CONNECTION_LOG(CONNECTION_ERROR, "Failed to get Wi-Fi statistics"); //LCOV_EXCL_LINE
1391                         *llsize = 0; //LCOV_EXCL_LINE
1392                         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1393                 }
1394
1395                 CONNECTION_LOG(CONNECTION_INFO, "%lld bytes", ull_size);
1396                 *llsize = (long long)ull_size;
1397         } else
1398                 return CONNECTION_ERROR_INVALID_PARAMETER;
1399
1400         return CONNECTION_ERROR_NONE;
1401 }
1402
1403 static int __reset_statistic(connection_type_e connection_type,
1404                 connection_statistics_type_e statistics_type)
1405 {
1406         int conn_type;
1407         int stat_type;
1408         int rv;
1409
1410         if (connection_type == CONNECTION_TYPE_CELLULAR)
1411                 conn_type = NET_DEVICE_CELLULAR;
1412         else if (connection_type == CONNECTION_TYPE_WIFI)
1413                 conn_type = NET_DEVICE_WIFI;
1414         else
1415                 return CONNECTION_ERROR_INVALID_PARAMETER;
1416
1417         switch (statistics_type) {
1418         case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
1419                 stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
1420                 break;
1421         case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
1422                 stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
1423                 break;
1424         case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
1425                 stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
1426                 break;
1427         case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
1428                 stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
1429                 break;
1430         default:
1431                 return CONNECTION_ERROR_INVALID_PARAMETER;
1432         }
1433
1434         rv = _connection_libnet_set_statistics(conn_type, stat_type);
1435         if (rv != CONNECTION_ERROR_NONE)
1436                 return rv;
1437
1438         CONNECTION_LOG(CONNECTION_INFO, "connection_reset_statistics success");
1439
1440         return CONNECTION_ERROR_NONE;
1441 }
1442
1443 EXPORT_API int connection_get_statistics(connection_h connection,
1444                                 connection_type_e connection_type,
1445                                 connection_statistics_type_e statistics_type, long long* size)
1446 {
1447         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
1448
1449         if (connection_type == CONNECTION_TYPE_CELLULAR)
1450                 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1451         else if (connection_type == CONNECTION_TYPE_WIFI)
1452                 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1453
1454         if (!(__connection_check_handle_validity(connection)) || size == NULL) {
1455                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1456                 return CONNECTION_ERROR_INVALID_PARAMETER;
1457         }
1458
1459         return __get_statistic(connection_type, statistics_type, size);
1460 }
1461
1462 EXPORT_API int connection_reset_statistics(connection_h connection,
1463                                 connection_type_e connection_type,
1464                                 connection_statistics_type_e statistics_type)
1465 {
1466         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
1467
1468         if (connection_type == CONNECTION_TYPE_CELLULAR)
1469                 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1470         else if (connection_type == CONNECTION_TYPE_WIFI)
1471                 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1472
1473         if (!__connection_check_handle_validity(connection)) {
1474                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1475                 return CONNECTION_ERROR_INVALID_PARAMETER;
1476         }
1477
1478         return __reset_statistic(connection_type, statistics_type);
1479 }
1480
1481 EXPORT_API int connection_foreach_ipv6_address(connection_h connection,
1482                 connection_type_e connection_type, connection_ipv6_address_cb callback,
1483                 void *user_data)
1484 {
1485         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1486                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1487
1488         GSList *ipv6_address_list = NULL;
1489
1490         if (!(__connection_check_handle_validity(connection))) {
1491                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1492                 return CONNECTION_ERROR_INVALID_PARAMETER;
1493         }
1494
1495         int rv = CONNECTION_ERROR_NONE;
1496
1497         switch (connection_type) {
1498         case CONNECTION_TYPE_WIFI:
1499                 rv = net_foreach_ipv6_address(NET_DEVICE_WIFI,
1500                                 &ipv6_address_list);
1501                 break;
1502         case CONNECTION_TYPE_CELLULAR:
1503                 rv = net_foreach_ipv6_address(NET_DEVICE_CELLULAR,
1504                                 &ipv6_address_list);
1505                 break;
1506         case CONNECTION_TYPE_ETHERNET:
1507                 rv = net_foreach_ipv6_address(NET_DEVICE_ETHERNET,
1508                                 &ipv6_address_list);
1509                 break;
1510         case CONNECTION_TYPE_BT:
1511                 rv = net_foreach_ipv6_address(NET_DEVICE_BLUETOOTH,
1512                                 &ipv6_address_list);
1513                 break;
1514         default:
1515                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1516                 return CONNECTION_ERROR_INVALID_PARAMETER;
1517         }
1518
1519         if (rv != NET_ERR_NONE) {
1520                 CONNECTION_LOG(CONNECTION_ERROR, "net_get_multiple_id_address"
1521                                 " Failed = %d\n", rv);
1522                 return CONNECTION_ERROR_OPERATION_FAILED;
1523         }
1524
1525         GSList *list;
1526         for (list = ipv6_address_list; list; list = list->next) {
1527                 rv = callback((char *)list->data, user_data);
1528                 if (rv == false)
1529                         break;
1530         }
1531
1532         g_slist_free_full(ipv6_address_list, g_free);
1533         ipv6_address_list = NULL;
1534
1535         return CONNECTION_ERROR_NONE;
1536 }
1537