src/libnetwork.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 <stdio.h>
  18 #include <string.h>
  19 #include <glib.h>
  20 #include <vconf/vconf.h>
  21 #include <arpa/inet.h>
  22
  23 #include "net_connection_private.h"
  24
  25 static GSList *prof_handle_list = NULL;
  26 static GHashTable *profile_cb_table = NULL;
  27
  28 struct _profile_cb_s {
  29         connection_profile_state_changed_cb callback;
  30         connection_profile_state_e state;
  31         void *user_data;
  32 };
  33
  34 struct _profile_list_s {
  35         int count;
  36         int next;
  37         net_profile_info_t *profiles;
  38 };
  39
  40 struct _libnet_s {
  41         connection_opened_cb opened_cb;
  42         connection_closed_cb closed_cb;
  43         connection_set_default_cb set_default_cb;
  44         connection_reset_cb reset_profile_cb;
  45         libnet_ethernet_cable_state_changed_cb ethernet_cable_state_changed_cb;
  46         void *opened_user_data;
  47         void *closed_user_data;
  48         void *set_default_user_data;
  49         void *reset_profile_user_data;
  50         bool registered;
  51         bool is_created;
  52 };
  53
  54 struct managed_idle_data {
  55         GSourceFunc func;
  56         gpointer user_data;
  57         guint id;
  58 };
  59
  60 struct feature_type {
  61         bool telephony;
  62         bool wifi;
  63         bool tethering_bluetooth;
  64 };
  65
  66 static struct _profile_list_s profile_iterator = {0, 0, NULL};
  67 static struct _libnet_s libnet = {NULL, NULL, NULL, NULL, NULL, NULL, false};
  68 static __thread GSList *managed_idler_list = NULL;
  69 static __thread bool is_check_enable_feature = false;
  70 static __thread struct feature_type enable_feature = {false, false, false};
  71
  72 bool _connection_is_created(void)
  73 {
  74         return libnet.is_created;
  75 }
  76
  77 static connection_error_e __libnet_convert_to_cp_error_type(net_err_t err_type)
  78 {
  79         switch (err_type) {
  80         case NET_ERR_NONE:
  81                 return CONNECTION_ERROR_NONE;
  82         case NET_ERR_APP_ALREADY_REGISTERED:
  83                 return CONNECTION_ERROR_INVALID_OPERATION;
  84         case NET_ERR_APP_NOT_REGISTERED:
  85                 return CONNECTION_ERROR_INVALID_OPERATION;
  86         case NET_ERR_NO_ACTIVE_CONNECTIONS:
  87                 return CONNECTION_ERROR_NO_CONNECTION;
  88         case NET_ERR_ACTIVE_CONNECTION_EXISTS:
  89                 return CONNECTION_ERROR_ALREADY_EXISTS;
  90         case NET_ERR_CONNECTION_DHCP_FAILED:
  91                 return CONNECTION_ERROR_DHCP_FAILED;
  92         case NET_ERR_CONNECTION_INVALID_KEY:
  93                 return CONNECTION_ERROR_INVALID_KEY;
  94         case NET_ERR_IN_PROGRESS:
  95                 return CONNECTION_ERROR_NOW_IN_PROGRESS;
  96         case NET_ERR_OPERATION_ABORTED:
  97                 return CONNECTION_ERROR_OPERATION_ABORTED;
  98         case NET_ERR_TIME_OUT:
  99                 return CONNECTION_ERROR_NO_REPLY;
 100         case NET_ERR_ACCESS_DENIED:
 101                 return CONNECTION_ERROR_PERMISSION_DENIED;
 102         default:
 103                 return CONNECTION_ERROR_OPERATION_FAILED;
 104         }
 105 }
 106
 107 static const char *__libnet_convert_cp_error_type_to_string(connection_error_e err_type)
 108 {
 109         switch (err_type) {
 110         case CONNECTION_ERROR_NONE:
 111                 return "NONE";
 112         case CONNECTION_ERROR_INVALID_PARAMETER:
 113                 return "INVALID_PARAMETER";
 114         case CONNECTION_ERROR_OUT_OF_MEMORY:
 115                 return "OUT_OF_MEMORY";
 116         case CONNECTION_ERROR_INVALID_OPERATION:
 117                 return "INVALID_OPERATION";
 118         case CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED:
 119                 return "ADDRESS_FAMILY_NOT_SUPPORTED";
 120         case CONNECTION_ERROR_OPERATION_FAILED:
 121                 return "OPERATION_FAILED";
 122         case CONNECTION_ERROR_ITERATOR_END:
 123                 return "ITERATOR_END";
 124         case CONNECTION_ERROR_NO_CONNECTION:
 125                 return "NO_CONNECTION";
 126         case CONNECTION_ERROR_NOW_IN_PROGRESS:
 127                 return "NOW_IN_PROGRESS";
 128         case CONNECTION_ERROR_ALREADY_EXISTS:
 129                 return "ALREADY_EXISTS";
 130         case CONNECTION_ERROR_OPERATION_ABORTED:
 131                 return "OPERATION_ABORTED";
 132         case CONNECTION_ERROR_DHCP_FAILED:
 133                 return "DHCP_FAILED";
 134         case CONNECTION_ERROR_INVALID_KEY:
 135                 return "INVALID_KEY";
 136         case CONNECTION_ERROR_NO_REPLY:
 137                 return "NO_REPLY";
 138         case CONNECTION_ERROR_PERMISSION_DENIED:
 139                 return "PERMISSION_DENIED";
 140         case CONNECTION_ERROR_NOT_SUPPORTED:
 141                 return "NOT_SUPPORTED";
 142         }
 143
 144         return "UNKNOWN";
 145 }
 146
 147 static const char *__libnet_convert_cp_state_to_string(connection_profile_state_e state)
 148 {
 149         switch (state) {
 150         case CONNECTION_PROFILE_STATE_DISCONNECTED:
 151                 return "DISCONNECTED";
 152         case CONNECTION_PROFILE_STATE_ASSOCIATION:
 153                 return "ASSOCIATION";
 154         case CONNECTION_PROFILE_STATE_CONFIGURATION:
 155                 return "CONFIGURATION";
 156         case CONNECTION_PROFILE_STATE_CONNECTED:
 157                 return "CONNECTED";
 158         default:
 159                 return "UNKNOWN";
 160         }
 161 }
 162
 163 static void __libnet_set_reset_profile_cb(connection_opened_cb user_cb, void *user_data)
 164 {
 165         if (user_cb != NULL) {
 166                 libnet.reset_profile_cb = user_cb;
 167                 libnet.reset_profile_user_data = user_data;
 168         }
 169 }
 170
 171 static void __libnet_set_opened_cb(connection_opened_cb user_cb, void *user_data)
 172 {
 173         if (user_cb) {
 174                 libnet.opened_cb = user_cb;
 175                 libnet.opened_user_data = user_data;
 176         }
 177 }
 178
 179 static gboolean __libnet_reset_profile_cb_idle(gpointer data)
 180 {
 181         connection_error_e result = (connection_error_e)data;
 182
 183         if (libnet.reset_profile_cb != NULL)
 184                 libnet.reset_profile_cb(result, libnet.reset_profile_user_data);
 185
 186         libnet.reset_profile_cb = NULL;
 187         libnet.reset_profile_user_data = NULL;
 188
 189         return FALSE;
 190 }
 191
 192 static void __libnet_reset_profile_cb(connection_error_e result)
 193 {
 194         if (_connection_is_created() != true) {
 195                 CONNECTION_LOG(CONNECTION_ERROR, "Application is not registered"
 196                                 "If multi-threaded, thread integrity be broken.");
 197                 return;
 198         }
 199
 200         if (libnet.reset_profile_cb != NULL)
 201                 _connection_callback_add(__libnet_reset_profile_cb_idle, (gpointer)result);
 202 }
 203
 204 static void __libnet_opened_cb(connection_error_e result)
 205 {
 206         if (libnet.opened_cb)
 207                 libnet.opened_cb(result, libnet.opened_user_data);
 208
 209         libnet.opened_cb = NULL;
 210         libnet.opened_user_data = NULL;
 211 }
 212
 213 static void __libnet_set_closed_cb(connection_closed_cb user_cb, void *user_data)
 214 {
 215         if (user_cb) {
 216                 libnet.closed_cb = user_cb;
 217                 libnet.closed_user_data = user_data;
 218         }
 219 }
 220
 221 static void __libnet_closed_cb(connection_error_e result)
 222 {
 223         if (libnet.closed_cb)
 224                 libnet.closed_cb(result, libnet.closed_user_data);
 225
 226         libnet.closed_cb = NULL;
 227         libnet.closed_user_data = NULL;
 228 }
 229
 230 static void __libnet_set_default_cb(connection_set_default_cb user_cb, void *user_data)
 231 {
 232         if (user_cb) {
 233                 libnet.set_default_cb = user_cb;
 234                 libnet.set_default_user_data = user_data;
 235         }
 236 }
 237
 238 static void __libnet_default_cb(connection_error_e result)
 239 {
 240         if (libnet.set_default_cb)
 241                 libnet.set_default_cb(result, libnet.set_default_user_data);
 242
 243         libnet.set_default_cb = NULL;
 244         libnet.set_default_user_data = NULL;
 245 }
 246
 247 static void __libnet_set_ethernet_cable_state_changed_cb(
 248                 libnet_ethernet_cable_state_changed_cb user_cb)
 249 {
 250         libnet.ethernet_cable_state_changed_cb = user_cb;
 251 }
 252
 253 static void __libnet_ethernet_cable_state_changed_cb(
 254                 connection_ethernet_cable_state_e state)
 255 {
 256         if (libnet.ethernet_cable_state_changed_cb)
 257                 libnet.ethernet_cable_state_changed_cb(state);
 258 }
 259
 260 static void __libnet_state_changed_cb(char *profile_name, connection_profile_state_e state)
 261 {
 262         if (profile_name == NULL)
 263                 return;
 264
 265         struct _profile_cb_s *cb_info;
 266         cb_info = g_hash_table_lookup(profile_cb_table, profile_name);
 267
 268         if (cb_info == NULL)
 269                 return;
 270
 271         if (cb_info->state == state)
 272                 return;
 273
 274         cb_info->state = state;
 275
 276         if (state >= 0 && cb_info->callback)
 277                 cb_info->callback(state, cb_info->user_data);
 278 }
 279
 280 static void __libnet_clear_profile_list(struct _profile_list_s *profile_list)
 281 {
 282         if (profile_list->count > 0)
 283                 g_free(profile_list->profiles);
 284
 285         profile_list->count = 0;
 286         profile_list->next = 0;
 287         profile_list->profiles = NULL;
 288 }
 289
 290 static void __libnet_evt_cb(net_event_info_t*  event_cb, void* user_data)
 291 {
 292         bool is_requested = false;
 293         connection_error_e result = CONNECTION_ERROR_NONE;
 294
 295         switch (event_cb->Event) {
 296         case NET_EVENT_OPEN_RSP:
 297                 is_requested = true;
 298                 /* fall through */
 299         case NET_EVENT_OPEN_IND:
 300                 result = __libnet_convert_to_cp_error_type(event_cb->Error);
 301                 CONNECTION_LOG(CONNECTION_INFO, "Got connection open %s : %s\n",
 302                                         (is_requested) ? "RSP":"IND",
 303                                         __libnet_convert_cp_error_type_to_string(result));
 304
 305                 if (is_requested)
 306                         __libnet_opened_cb(result);
 307
 308                 switch (event_cb->Error) {
 309                 case NET_ERR_NONE:
 310                 case NET_ERR_ACTIVE_CONNECTION_EXISTS:
 311                         CONNECTION_LOG(CONNECTION_INFO, "'Open connection' succeeded\n");
 312
 313                         __libnet_state_changed_cb(event_cb->ProfileName, CONNECTION_PROFILE_STATE_CONNECTED);
 314                         return;
 315                 default:
 316                         CONNECTION_LOG(CONNECTION_ERROR, "'Open connection' failed!! [%s]\n",
 317                                                 __libnet_convert_cp_error_type_to_string(result));
 318                 }
 319
 320                 __libnet_state_changed_cb(event_cb->ProfileName, CONNECTION_PROFILE_STATE_DISCONNECTED);
 321
 322                 break;
 323         case NET_EVENT_CLOSE_RSP:
 324                 is_requested = true;
 325                 /* fall through */
 326         case NET_EVENT_CLOSE_IND:
 327                 result = __libnet_convert_to_cp_error_type(event_cb->Error);
 328                 CONNECTION_LOG(CONNECTION_INFO, "Got connection close %s : %s\n",
 329                                         (is_requested) ? "RSP":"IND",
 330                                         __libnet_convert_cp_error_type_to_string(result));
 331
 332                 if (is_requested)
 333                         __libnet_closed_cb(result);
 334
 335                 switch (event_cb->Error) {
 336                 case NET_ERR_NONE:
 337                         CONNECTION_LOG(CONNECTION_INFO, "'Close connection' succeeded!\n");
 338
 339                         __libnet_state_changed_cb(event_cb->ProfileName, CONNECTION_PROFILE_STATE_DISCONNECTED);
 340                         return;
 341                 default:
 342                         CONNECTION_LOG(CONNECTION_ERROR, "'Close connection' failed!! [%s]\n",
 343                                                 __libnet_convert_cp_error_type_to_string(result));
 344                 }
 345
 346                 break;
 347         case NET_EVENT_NET_STATE_IND:
 348                 CONNECTION_LOG(CONNECTION_INFO, "Got State changed IND\n");
 349
 350                 if (event_cb->Datalength != sizeof(net_state_type_t))
 351                         return;
 352
 353                 net_state_type_t *profile_state = (net_state_type_t*)event_cb->Data;
 354                 connection_profile_state_e cp_state = _profile_convert_to_cp_state(*profile_state);
 355
 356                 CONNECTION_LOG(CONNECTION_INFO,
 357                                 "Profile State : %s, profile name : %s\n",
 358                                 __libnet_convert_cp_state_to_string(cp_state),
 359                                 event_cb->ProfileName);
 360
 361                 __libnet_state_changed_cb(event_cb->ProfileName, cp_state);
 362
 363                 break;
 364         case NET_EVENT_WIFI_SCAN_IND:
 365         case NET_EVENT_WIFI_SCAN_RSP:
 366                 CONNECTION_LOG(CONNECTION_INFO, "Got wifi scan IND\n");
 367                 break;
 368         case NET_EVENT_WIFI_POWER_IND:
 369         case NET_EVENT_WIFI_POWER_RSP:
 370                 CONNECTION_LOG(CONNECTION_INFO, "Got wifi power IND\n");
 371                 break;
 372         case NET_EVENT_CELLULAR_SET_DEFAULT_RSP:
 373                 result = __libnet_convert_to_cp_error_type(event_cb->Error);
 374                 CONNECTION_LOG(CONNECTION_INFO, "Got set default profile RSP %d\n", result);
 375                 __libnet_default_cb(result);
 376                 break;
 377         case NET_EVENT_WIFI_WPS_RSP:
 378                 CONNECTION_LOG(CONNECTION_INFO, "Got wifi WPS RSP\n");
 379                 /* fall through */
 380         case NET_EVENT_CELLULAR_RESET_DEFAULT_RSP:
 381                 result = __libnet_convert_to_cp_error_type(event_cb->Error);
 382                 CONNECTION_LOG(CONNECTION_INFO, "Got reset default profile RSP %d", result);
 383                 __libnet_reset_profile_cb(result);
 384
 385         case NET_EVENT_ETHERNET_CABLE_ATTACHED:
 386                 CONNECTION_LOG(CONNECTION_INFO, "Got Ethernet cable Attached Indication\n");
 387                 __libnet_ethernet_cable_state_changed_cb(CONNECTION_ETHERNET_CABLE_ATTACHED);
 388                 break;
 389         case NET_EVENT_ETHERNET_CABLE_DETACHED:
 390                 CONNECTION_LOG(CONNECTION_INFO, "Got Ethernet cable detached Indication\n");
 391                 __libnet_ethernet_cable_state_changed_cb(CONNECTION_ETHERNET_CABLE_DETACHED);
 392                 break;
 393         default :
 394                 CONNECTION_LOG(CONNECTION_ERROR, "Error! Unknown Event\n\n");
 395                 break;
 396         }
 397 }
 398
 399 static int __libnet_check_address_type(int address_family, const char *address)
 400 {
 401         struct in6_addr buf;
 402         int err = 0;
 403
 404         err = inet_pton(address_family, address, &buf);
 405         if(err > 0)
 406                 return 1;
 407
 408         return 0;
 409 }
 410
 411 int __libnet_get_connected_count(struct _profile_list_s *profile_list)
 412 {
 413         int count = 0;
 414         int i = 0;
 415
 416         for (;i < profile_list->count;i++) {
 417                 if (profile_list->profiles[i].ProfileState == NET_STATE_TYPE_ONLINE ||
 418                     profile_list->profiles[i].ProfileState == NET_STATE_TYPE_READY)
 419                         count++;
 420         }
 421
 422         return count;
 423 }
 424
 425 void __libnet_copy_connected_profile(net_profile_info_t **dest, struct _profile_list_s *source)
 426 {
 427         int i = 0;
 428
 429         for (;i < source->count;i++) {
 430                 if (source->profiles[i].ProfileState == NET_STATE_TYPE_ONLINE ||
 431                     source->profiles[i].ProfileState == NET_STATE_TYPE_READY) {
 432                         memcpy(*dest, &source->profiles[i], sizeof(net_profile_info_t));
 433                         (*dest)++;
 434                 }
 435         }
 436 }
 437
 438 int _connection_libnet_init(void)
 439 {
 440         int rv;
 441
 442         if (!libnet.registered) {
 443                 rv = net_register_client_ext((net_event_cb_t)__libnet_evt_cb, NET_DEVICE_DEFAULT, NULL);
 444                 if (rv != NET_ERR_NONE)
 445                         return false;
 446
 447                 libnet.registered = true;
 448
 449                 if (profile_cb_table == NULL)
 450                         profile_cb_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
 451         }
 452
 453         return NET_ERR_NONE;
 454 }
 455
 456 bool _connection_libnet_deinit(void)
 457 {
 458         if (libnet.registered) {
 459                 if (net_deregister_client_ext(NET_DEVICE_DEFAULT) != NET_ERR_NONE)
 460                         return false;
 461
 462                 libnet.registered = false;
 463
 464                 if (profile_cb_table) {
 465                         g_hash_table_destroy(profile_cb_table);
 466                         profile_cb_table = NULL;
 467                 }
 468
 469                 __libnet_clear_profile_list(&profile_iterator);
 470
 471                 if (prof_handle_list) {
 472                         g_slist_free_full(prof_handle_list, g_free);
 473                         prof_handle_list = NULL;
 474                 }
 475         }
 476
 477         return true;
 478 }
 479
 480 bool _connection_libnet_check_profile_validity(connection_profile_h profile)
 481 {
 482         GSList *list;
 483         int i = 0;
 484
 485         for (list = prof_handle_list; list; list = list->next)
 486                 if (profile == list->data) return true;
 487
 488         for (;i < profile_iterator.count;i++)
 489                 if (profile == &profile_iterator.profiles[i]) return true;
 490
 491         return false;
 492 }
 493
 494 bool _connection_libnet_check_profile_cb_validity(connection_profile_h profile)
 495 {
 496         struct _profile_cb_s *cb_info;
 497         net_profile_info_t *profile_info = profile;
 498
 499         if (profile == NULL)
 500                 return false;
 501
 502         cb_info = g_hash_table_lookup(profile_cb_table, profile_info->ProfileName);
 503         if (cb_info != NULL)
 504                 return true;
 505
 506         return false;
 507 }
 508
 509
 510 int _connection_libnet_get_wifi_state(connection_wifi_state_e *state)
 511 {
 512         int rv;
 513         net_wifi_state_t wlan_state;
 514         net_profile_name_t profile_name;
 515
 516         rv = net_get_wifi_state(&wlan_state, &profile_name);
 517         if (rv == NET_ERR_ACCESS_DENIED) {
 518                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 519                 return CONNECTION_ERROR_PERMISSION_DENIED;
 520         } else if (rv != NET_ERR_NONE) {
 521                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get Wi-Fi state[%d]", rv);
 522                 return CONNECTION_ERROR_OPERATION_FAILED;
 523         }
 524
 525         switch (wlan_state) {
 526         case WIFI_OFF:
 527                 *state = CONNECTION_WIFI_STATE_DEACTIVATED;
 528                 break;
 529         case WIFI_ON:
 530         case WIFI_CONNECTING:
 531                 *state = CONNECTION_WIFI_STATE_DISCONNECTED;
 532                 break;
 533         case WIFI_CONNECTED:
 534         case WIFI_DISCONNECTING:
 535                 *state = CONNECTION_WIFI_STATE_CONNECTED;
 536                 break;
 537         default :
 538                 CONNECTION_LOG(CONNECTION_ERROR, "Error!! Unknown state\n");
 539                 return CONNECTION_ERROR_INVALID_OPERATION;
 540         }
 541
 542         return CONNECTION_ERROR_NONE;
 543 }
 544
 545 int _connection_libnet_get_ethernet_state(connection_ethernet_state_e* state)
 546 {
 547         int rv;
 548         struct _profile_list_s ethernet_profiles = {0, 0, NULL};
 549         rv = net_get_profile_list(NET_DEVICE_ETHERNET, &ethernet_profiles.profiles, &ethernet_profiles.count);
 550         if (rv == NET_ERR_ACCESS_DENIED) {
 551                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 552                 return CONNECTION_ERROR_PERMISSION_DENIED;
 553         }
 554
 555         if (ethernet_profiles.count == 0) {
 556                 state = CONNECTION_ETHERNET_STATE_DEACTIVATED;
 557                 return CONNECTION_ERROR_NONE;
 558         }
 559
 560         switch (ethernet_profiles.profiles->ProfileState) {
 561         case NET_STATE_TYPE_ONLINE:
 562         case NET_STATE_TYPE_READY:
 563                 *state = CONNECTION_ETHERNET_STATE_CONNECTED;
 564                 break;
 565         case NET_STATE_TYPE_IDLE:
 566         case NET_STATE_TYPE_FAILURE:
 567         case NET_STATE_TYPE_ASSOCIATION:
 568         case NET_STATE_TYPE_CONFIGURATION:
 569         case NET_STATE_TYPE_DISCONNECT:
 570                 *state = CONNECTION_ETHERNET_STATE_DISCONNECTED;
 571                 break;
 572         default:
 573                 return CONNECTION_ERROR_OPERATION_FAILED;
 574         }
 575
 576         __libnet_clear_profile_list(&ethernet_profiles);
 577
 578         return CONNECTION_ERROR_NONE;
 579 }
 580
 581 int _connection_libnet_get_ethernet_cable_state(connection_ethernet_cable_state_e* state)
 582 {
 583         int rv = 0;
 584         int status = 0;
 585
 586         rv = net_get_ethernet_cable_state(&status);
 587         if (rv == NET_ERR_ACCESS_DENIED) {
 588                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 589                 return CONNECTION_ERROR_PERMISSION_DENIED;
 590         } else if (rv != NET_ERR_NONE) {
 591                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get ethernet cable state[%d]", rv);
 592                 return CONNECTION_ERROR_OPERATION_FAILED;
 593         }
 594
 595         if(status == 1)
 596                 *state = CONNECTION_ETHERNET_CABLE_ATTACHED;
 597         else
 598                 *state = CONNECTION_ETHERNET_CABLE_DETACHED;
 599         return CONNECTION_ERROR_NONE;
 600 }
 601
 602 int _connection_libnet_set_ethernet_cable_state_changed_cb(
 603                 libnet_ethernet_cable_state_changed_cb callback)
 604 {
 605         __libnet_set_ethernet_cable_state_changed_cb(callback);
 606
 607         return CONNECTION_ERROR_NONE;
 608 }
 609
 610 int _connection_libnet_get_bluetooth_state(connection_bt_state_e* state)
 611 {
 612         int i = 0;
 613         int rv = 0;
 614         struct _profile_list_s bluetooth_profiles = {0, 0, NULL};
 615         rv = net_get_profile_list(NET_DEVICE_BLUETOOTH, &bluetooth_profiles.profiles, &bluetooth_profiles.count);
 616         if (rv == NET_ERR_ACCESS_DENIED) {
 617                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 618                 return CONNECTION_ERROR_PERMISSION_DENIED;
 619         }
 620
 621         if (bluetooth_profiles.count == 0) {
 622                 *state = CONNECTION_BT_STATE_DEACTIVATED;
 623                 return CONNECTION_ERROR_NONE;
 624         }
 625
 626         for (; i < bluetooth_profiles.count; i++) {
 627                 switch (bluetooth_profiles.profiles[i].ProfileState) {
 628                 case NET_STATE_TYPE_ONLINE:
 629                 case NET_STATE_TYPE_READY:
 630                         *state = CONNECTION_BT_STATE_CONNECTED;
 631                         goto done;
 632                 case NET_STATE_TYPE_IDLE:
 633                 case NET_STATE_TYPE_FAILURE:
 634                 case NET_STATE_TYPE_ASSOCIATION:
 635                 case NET_STATE_TYPE_CONFIGURATION:
 636                 case NET_STATE_TYPE_DISCONNECT:
 637                         *state = CONNECTION_BT_STATE_DISCONNECTED;
 638                         break;
 639                 default:
 640                         __libnet_clear_profile_list(&bluetooth_profiles);
 641                         return CONNECTION_ERROR_OPERATION_FAILED;
 642                 }
 643         }
 644
 645 done:
 646         __libnet_clear_profile_list(&bluetooth_profiles);
 647
 648         return CONNECTION_ERROR_NONE;
 649 }
 650
 651 int _connection_libnet_get_profile_iterator(connection_iterator_type_e type, connection_profile_iterator_h* profile_iter_h)
 652 {
 653         int count = 0;
 654         int rv;
 655         net_profile_info_t *profiles = NULL;
 656
 657         struct _profile_list_s all_profiles = {0, 0, NULL};
 658
 659         __libnet_clear_profile_list(&profile_iterator);
 660
 661         rv = net_get_profile_list(NET_DEVICE_MAX, &all_profiles.profiles, &all_profiles.count);
 662
 663         if (rv != NET_ERR_NONE) {
 664                 if (rv == NET_ERR_NO_SERVICE) {
 665                         *profile_iter_h = &profile_iterator;
 666                         return CONNECTION_ERROR_NONE;
 667                 } else
 668                         return CONNECTION_ERROR_OPERATION_FAILED;
 669         }
 670
 671         *profile_iter_h = &profile_iterator;
 672
 673         switch (type) {
 674         case CONNECTION_ITERATOR_TYPE_REGISTERED:
 675                 count = all_profiles.count;
 676                 CONNECTION_LOG(CONNECTION_INFO, "Total profile count : %d\n", count);
 677
 678                 if (count == 0)
 679                         return CONNECTION_ERROR_NONE;
 680
 681                 profile_iterator.profiles = all_profiles.profiles;
 682
 683                 break;
 684         case CONNECTION_ITERATOR_TYPE_CONNECTED:
 685                 count = __libnet_get_connected_count(&all_profiles);
 686                 CONNECTION_LOG(CONNECTION_INFO, "Total connected profile count : %d\n", count);
 687
 688                 if (count == 0)
 689                         return CONNECTION_ERROR_NONE;
 690
 691                 profiles = g_try_new0(net_profile_info_t, count);
 692                 if (profiles == NULL) {
 693                         __libnet_clear_profile_list(&all_profiles);
 694                         return CONNECTION_ERROR_OUT_OF_MEMORY;
 695                 break;
 696         case CONNECTION_ITERATOR_TYPE_DEFAULT:
 697                         /* To do : Not supported yet */
 698                 break;
 699                 }
 700
 701                 profile_iterator.profiles = profiles;
 702
 703                 __libnet_copy_connected_profile(&profiles, &all_profiles);
 704
 705                 __libnet_clear_profile_list(&all_profiles);
 706         }
 707
 708         profile_iterator.count = count;
 709
 710         return CONNECTION_ERROR_NONE;
 711 }
 712
 713 int _connection_libnet_get_iterator_next(connection_profile_iterator_h profile_iter_h, connection_profile_h *profile)
 714 {
 715         if (profile_iter_h != &profile_iterator)
 716                 return CONNECTION_ERROR_INVALID_PARAMETER;
 717
 718         if (profile_iterator.count <= profile_iterator.next)
 719                 return CONNECTION_ERROR_ITERATOR_END;
 720
 721         *profile = &profile_iterator.profiles[profile_iterator.next];
 722         profile_iterator.next++;
 723
 724         return CONNECTION_ERROR_NONE;
 725 }
 726
 727 bool _connection_libnet_iterator_has_next(connection_profile_iterator_h profile_iter_h)
 728 {
 729         if (profile_iter_h != &profile_iterator)
 730                 return false;
 731
 732         if (profile_iterator.count <= profile_iterator.next)
 733                 return false;
 734
 735         return true;
 736 }
 737
 738 int _connection_libnet_destroy_iterator(connection_profile_iterator_h profile_iter_h)
 739 {
 740         if (profile_iter_h != &profile_iterator)
 741                 return CONNECTION_ERROR_INVALID_PARAMETER;
 742
 743         __libnet_clear_profile_list(&profile_iterator);
 744
 745         return CONNECTION_ERROR_NONE;
 746 }
 747
 748 int _connection_libnet_get_current_profile(connection_profile_h *profile)
 749 {
 750         net_profile_info_t active_profile;
 751         int rv;
 752
 753         rv = net_get_active_net_info(&active_profile);
 754         if (rv == NET_ERR_NO_SERVICE)
 755                 return CONNECTION_ERROR_NO_CONNECTION;
 756         else if (rv == NET_ERR_ACCESS_DENIED) {
 757                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 758                 return CONNECTION_ERROR_PERMISSION_DENIED;
 759         } else if (rv != NET_ERR_NONE)
 760                 return CONNECTION_ERROR_OPERATION_FAILED;
 761
 762         *profile = g_try_malloc0(sizeof(net_profile_info_t));
 763         if (*profile == NULL)
 764                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 765
 766         memcpy(*profile, &active_profile, sizeof(net_profile_info_t));
 767         prof_handle_list = g_slist_append(prof_handle_list, *profile);
 768
 769         return CONNECTION_ERROR_NONE;
 770 }
 771
 772 int _connection_libnet_reset_profile(connection_reset_option_e type,
 773                 connection_cellular_subscriber_id_e id, connection_reset_cb callback, void *user_data)
 774 {
 775         int rv;
 776
 777         rv = net_reset_profile(type, id);
 778         if (rv == NET_ERR_ACCESS_DENIED) {
 779                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 780                 return CONNECTION_ERROR_PERMISSION_DENIED;
 781         } else if (rv != NET_ERR_NONE) {
 782                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to add profile[%d]", rv);
 783                 return CONNECTION_ERROR_OPERATION_FAILED;
 784         }
 785
 786         __libnet_set_reset_profile_cb(callback, user_data);
 787
 788         return CONNECTION_ERROR_NONE;
 789 }
 790
 791 int _connection_libnet_open_profile(connection_profile_h profile, connection_opened_cb callback, void* user_data)
 792 {
 793         int rv;
 794
 795         if (!(_connection_libnet_check_profile_validity(profile))) {
 796                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 797                 return CONNECTION_ERROR_INVALID_PARAMETER;
 798         }
 799
 800         net_profile_info_t *profile_info = profile;
 801
 802         rv = net_open_connection_with_profile(profile_info->ProfileName);
 803         if (rv == NET_ERR_ACCESS_DENIED) {
 804                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 805                 return CONNECTION_ERROR_PERMISSION_DENIED;
 806         } else if (rv != NET_ERR_NONE)
 807                 return CONNECTION_ERROR_OPERATION_FAILED;
 808
 809         __libnet_set_opened_cb(callback, user_data);
 810
 811         return CONNECTION_ERROR_NONE;
 812 }
 813
 814 int _connection_libnet_get_cellular_service_profile(connection_cellular_service_type_e type, connection_profile_h *profile)
 815 {
 816         int i = 0;
 817         int j = 0;
 818         int rv = NET_ERR_NONE;
 819         net_service_type_t service_type = _connection_profile_convert_to_libnet_cellular_service_type(type);
 820
 821         struct _profile_list_s cellular_profiles = {0, 0, NULL};
 822
 823         rv = net_get_profile_list(NET_DEVICE_CELLULAR, &cellular_profiles.profiles, &cellular_profiles.count);
 824         if (rv == NET_ERR_ACCESS_DENIED) {
 825                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 826                 return CONNECTION_ERROR_PERMISSION_DENIED;
 827         } else if (rv != NET_ERR_NONE) {
 828                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get profile list (%d)", rv);
 829                 return CONNECTION_ERROR_OPERATION_FAILED;
 830         }
 831
 832         for (;i < cellular_profiles.count;i++)
 833                 if (cellular_profiles.profiles[i].ProfileInfo.Pdp.ServiceType == service_type)
 834                         break;
 835
 836         if (i >= cellular_profiles.count)
 837                 return CONNECTION_ERROR_OPERATION_FAILED;
 838
 839         *profile = g_try_malloc0(sizeof(net_profile_info_t));
 840         if (*profile == NULL)
 841                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 842
 843         memcpy(*profile, &cellular_profiles.profiles[i], sizeof(net_profile_info_t));
 844
 845         if (cellular_profiles.profiles[i].ProfileInfo.Pdp.DefaultConn)
 846                 goto done;
 847
 848         if (type != CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET &&
 849             type != CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET)
 850                 goto done;
 851
 852         for (;j < cellular_profiles.count;j++) {
 853                 if (i == j)
 854                         continue;
 855
 856                 if (cellular_profiles.profiles[j].ProfileInfo.Pdp.ServiceType != service_type)
 857                         continue;
 858
 859                 if (cellular_profiles.profiles[j].ProfileInfo.Pdp.DefaultConn) {
 860                         memcpy(*profile, &cellular_profiles.profiles[j], sizeof(net_profile_info_t));
 861                         goto done;
 862                 }
 863         }
 864
 865 done:
 866         prof_handle_list = g_slist_append(prof_handle_list, *profile);
 867
 868         return CONNECTION_ERROR_NONE;
 869 }
 870
 871 int _connection_libnet_set_cellular_service_profile_sync(connection_cellular_service_type_e type, connection_profile_h profile)
 872 {
 873         int rv;
 874
 875         if (!(_connection_libnet_check_profile_validity(profile))) {
 876                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 877                 return CONNECTION_ERROR_INVALID_PARAMETER;
 878         }
 879
 880         net_profile_info_t *profile_info = profile;
 881         connection_cellular_service_type_e service_type;
 882
 883         service_type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
 884
 885         if (service_type != type)
 886                 return CONNECTION_ERROR_INVALID_PARAMETER;
 887
 888         rv = net_set_default_cellular_service_profile(profile_info->ProfileName);
 889         if (rv == NET_ERR_ACCESS_DENIED) {
 890                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 891                 return CONNECTION_ERROR_PERMISSION_DENIED;
 892         } else if (rv != NET_ERR_NONE)
 893                 return CONNECTION_ERROR_OPERATION_FAILED;
 894
 895         return CONNECTION_ERROR_NONE;
 896 }
 897
 898 int _connection_libnet_set_cellular_service_profile_async(connection_cellular_service_type_e type,
 899                         connection_profile_h profile, connection_set_default_cb callback, void* user_data)
 900 {
 901         int rv;
 902
 903         if (!(_connection_libnet_check_profile_validity(profile))) {
 904                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 905                 return CONNECTION_ERROR_INVALID_PARAMETER;
 906         }
 907
 908         net_profile_info_t *profile_info = profile;
 909         connection_cellular_service_type_e service_type;
 910
 911         service_type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
 912
 913         if (service_type != type)
 914                 return CONNECTION_ERROR_INVALID_PARAMETER;
 915
 916         rv = net_set_default_cellular_service_profile_async(profile_info->ProfileName);
 917         if (rv == NET_ERR_ACCESS_DENIED) {
 918                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 919                 return CONNECTION_ERROR_PERMISSION_DENIED;
 920         } else if (rv != NET_ERR_NONE)
 921                 return CONNECTION_ERROR_OPERATION_FAILED;
 922
 923         __libnet_set_default_cb(callback, user_data);
 924
 925         return CONNECTION_ERROR_NONE;
 926 }
 927
 928 int _connection_libnet_close_profile(connection_profile_h profile, connection_closed_cb callback, void *user_data)
 929 {
 930         int rv;
 931
 932         if (!(_connection_libnet_check_profile_validity(profile))) {
 933                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 934                 return CONNECTION_ERROR_INVALID_PARAMETER;
 935         }
 936
 937         net_profile_info_t *profile_info = profile;
 938
 939         rv = net_close_connection(profile_info->ProfileName);
 940         if (rv == NET_ERR_ACCESS_DENIED) {
 941                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 942                 return CONNECTION_ERROR_PERMISSION_DENIED;
 943         } else if (rv != NET_ERR_NONE)
 944                 return CONNECTION_ERROR_OPERATION_FAILED;
 945
 946         if (net_close_connection(profile_info->ProfileName) != NET_ERR_NONE)
 947                 return CONNECTION_ERROR_OPERATION_FAILED;
 948
 949         __libnet_set_closed_cb(callback, user_data);
 950
 951         return CONNECTION_ERROR_NONE;
 952 }
 953
 954 int _connection_libnet_add_route(const char *interface_name, const char *host_address)
 955 {
 956         int rv;
 957         char *endstr = NULL;
 958         int address_family = 0;
 959
 960         if(__libnet_check_address_type(AF_INET, host_address))
 961                 address_family = AF_INET;
 962         else
 963                 return CONNECTION_ERROR_INVALID_PARAMETER;
 964
 965         switch(address_family) {
 966                 case AF_INET:
 967                         endstr = strrchr(host_address, '.');
 968                         if (endstr == NULL ||
 969                                         strcmp(endstr, ".0") == 0 ||
 970                                         strncmp(host_address, "0.", 2) == 0 ||
 971                                         strstr(host_address, "255") != NULL) {
 972                                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid IP address Passed\n");
 973                                 return CONNECTION_ERROR_INVALID_PARAMETER;
 974                         }
 975                         break;
 976                 default:
 977                         return CONNECTION_ERROR_OPERATION_FAILED;
 978         }
 979
 980         rv = net_add_route(host_address, interface_name, address_family);
 981         if (rv == NET_ERR_ACCESS_DENIED) {
 982                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 983                 return CONNECTION_ERROR_PERMISSION_DENIED;
 984         } else if (rv != NET_ERR_NONE)
 985                 return CONNECTION_ERROR_OPERATION_FAILED;
 986
 987         return CONNECTION_ERROR_NONE;
 988 }
 989
 990 int _connection_libnet_remove_route(const char *interface_name, const char *host_address)
 991 {
 992         int rv;
 993         char *endstr = strrchr(host_address, '.');
 994         int address_family = 0;
 995
 996         if (__libnet_check_address_type(AF_INET, host_address))
 997                 address_family = AF_INET;
 998         else
 999                 return CONNECTION_ERROR_INVALID_PARAMETER;
1000
1001         switch(address_family) {
1002                 case AF_INET:
1003                         endstr = strrchr(host_address, '.');
1004                         if (endstr == NULL ||
1005                                 strcmp(endstr, ".0") == 0 ||
1006                                 strncmp(host_address, "0.", 2) == 0 ||
1007                                 strstr(host_address, ".0.") != NULL ||strstr(host_address, "255") != NULL) {
1008                                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid IP address Passed");
1009                                 return CONNECTION_ERROR_INVALID_PARAMETER;
1010                         }
1011                         break;
1012                 default:
1013                         return CONNECTION_ERROR_OPERATION_FAILED;
1014         }
1015
1016         rv = net_remove_route(host_address, interface_name, address_family);
1017         if (rv == NET_ERR_ACCESS_DENIED) {
1018                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
1019                 return CONNECTION_ERROR_PERMISSION_DENIED;
1020         } else if (rv != NET_ERR_NONE)
1021                 return CONNECTION_ERROR_OPERATION_FAILED;
1022
1023         return CONNECTION_ERROR_NONE;
1024 }
1025
1026 int _connection_libnet_add_route_ipv6(const char *interface_name, const char *host_address, const char *gateway)
1027 {
1028         int rv;
1029         int address_family = 0;
1030
1031         address_family = AF_INET6;
1032 /*      if(__libnet_check_address_type(AF_INET6, host_address))
1033                 address_family = AF_INET6;
1034         else
1035                 return CONNECTION_ERROR_INVALID_PARAMETER;*/
1036
1037         switch(address_family) {
1038                 case AF_INET6:
1039                         if (strncmp(host_address, "fe80:", 5) == 0 ||
1040                                 strncmp(host_address, "ff00:", 5) == 0 ||
1041                                 strncmp(host_address, "::", 2) == 0) {
1042                                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid IP address Passed\n");
1043                                 return CONNECTION_ERROR_INVALID_PARAMETER;
1044                         }
1045                         break;
1046                 default:
1047                         return CONNECTION_ERROR_OPERATION_FAILED;
1048         }
1049
1050         rv = net_add_route_ipv6(host_address, interface_name, address_family, gateway);
1051         if (rv == NET_ERR_ACCESS_DENIED) {
1052                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
1053                 return CONNECTION_ERROR_PERMISSION_DENIED;
1054         } else if (rv != NET_ERR_NONE)
1055                 return CONNECTION_ERROR_OPERATION_FAILED;
1056
1057         return CONNECTION_ERROR_NONE;
1058 }
1059
1060 int _connection_libnet_remove_route_ipv6(const char *interface_name, const char *host_address, const char *gateway)
1061 {
1062         int rv;
1063         int address_family = 0;
1064
1065         address_family = AF_INET6;
1066 /*      if (__libnet_check_address_type(AF_INET6, host_address))
1067                 address_family = AF_INET6;
1068         else
1069                 return CONNECTION_ERROR_INVALID_PARAMETER;*/
1070
1071         switch(address_family) {
1072                 case AF_INET6:
1073                         if (strncmp(host_address, "fe80:", 5) == 0 ||
1074                                 strncmp(host_address, "ff00:", 5) == 0 ||
1075                                 strncmp(host_address, "::", 2) == 0) {
1076                                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid IP address Passed\n");
1077                                 return CONNECTION_ERROR_INVALID_PARAMETER;
1078                         }
1079                         break;
1080                 default:
1081                         return CONNECTION_ERROR_OPERATION_FAILED;
1082         }
1083
1084         rv = net_remove_route_ipv6(host_address, interface_name, address_family, gateway);
1085         if (rv == NET_ERR_ACCESS_DENIED) {
1086                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
1087                 return CONNECTION_ERROR_PERMISSION_DENIED;
1088         } else if (rv != NET_ERR_NONE)
1089                 return CONNECTION_ERROR_OPERATION_FAILED;
1090
1091         return CONNECTION_ERROR_NONE;
1092 }
1093
1094 void _connection_libnet_add_to_profile_list(connection_profile_h profile)
1095 {
1096         prof_handle_list = g_slist_append(prof_handle_list, profile);
1097 }
1098
1099 void _connection_libnet_remove_from_profile_list(connection_profile_h profile)
1100 {
1101         prof_handle_list = g_slist_remove(prof_handle_list, profile);
1102         g_free(profile);
1103 }
1104
1105 bool _connection_libnet_add_to_profile_cb_list(connection_profile_h profile,
1106                 connection_profile_state_changed_cb callback, void *user_data)
1107 {
1108         net_profile_info_t *profile_info = profile;
1109         char *profile_name = g_strdup(profile_info->ProfileName);
1110
1111         struct _profile_cb_s *profile_cb_info = g_try_malloc0(sizeof(struct _profile_cb_s));
1112         if (profile_cb_info == NULL) {
1113                 g_free(profile_name);
1114                 return false;
1115         }
1116
1117         profile_cb_info->callback = callback;
1118         profile_cb_info->user_data = user_data;
1119
1120         g_hash_table_insert(profile_cb_table, profile_name, profile_cb_info);
1121
1122         return true;
1123 }
1124
1125 bool _connection_libnet_remove_from_profile_cb_list(connection_profile_h profile)
1126 {
1127         net_profile_info_t *profile_info = profile;
1128         if (g_hash_table_remove(profile_cb_table, profile_info->ProfileName) == TRUE)
1129                 return true;
1130
1131         return false;
1132 }
1133
1134 int _connection_libnet_set_statistics(net_device_t device_type, net_statistics_type_e statistics_type)
1135 {
1136         int rv;
1137         rv = net_set_statistics(device_type, statistics_type);
1138         if (rv == NET_ERR_ACCESS_DENIED) {
1139                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
1140                 return CONNECTION_ERROR_PERMISSION_DENIED;
1141         } else if (rv != NET_ERR_NONE)
1142                 return CONNECTION_ERROR_OPERATION_FAILED;
1143
1144         return CONNECTION_ERROR_NONE;
1145 }
1146
1147 int _connection_libnet_get_statistics(net_statistics_type_e statistics_type, unsigned long long *size)
1148 {
1149         int rv;
1150         rv = net_get_statistics(NET_DEVICE_WIFI, statistics_type, size);
1151         if (rv == NET_ERR_ACCESS_DENIED) {
1152                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
1153                 return CONNECTION_ERROR_PERMISSION_DENIED;
1154         }else if (rv != NET_ERR_NONE)
1155                 return CONNECTION_ERROR_OPERATION_FAILED;
1156
1157         return CONNECTION_ERROR_NONE;
1158 }
1159
1160 int _connection_libnet_set_cellular_subscriber_id(connection_profile_h profile,
1161                 connection_cellular_subscriber_id_e sim_id)
1162 {
1163         char *modem_path = NULL;
1164         net_profile_info_t *profile_info = (net_profile_info_t *)profile;
1165
1166         if (net_get_cellular_modem_object_path(&modem_path, sim_id) != NET_ERR_NONE) {
1167                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get subscriber[%d]", sim_id);
1168                 return CONNECTION_ERROR_OPERATION_FAILED;
1169         }
1170
1171         if (!modem_path) {
1172                 CONNECTION_LOG(CONNECTION_ERROR, "NULL modem object path");
1173                 return CONNECTION_ERROR_OPERATION_FAILED;
1174         }
1175
1176         g_strlcpy(profile_info->ProfileInfo.Pdp.PSModemPath, modem_path,
1177                                 NET_PROFILE_NAME_LEN_MAX);
1178         g_free(modem_path);
1179
1180         return CONNECTION_ERROR_NONE;
1181 }
1182
1183 static void __connection_idle_destroy_cb(gpointer data)
1184 {
1185         if (!data)
1186                 return;
1187
1188         managed_idler_list = g_slist_remove(managed_idler_list, data);
1189         g_free(data);
1190 }
1191
1192 static gboolean __connection_idle_cb(gpointer user_data)
1193 {
1194         struct managed_idle_data *data = (struct managed_idle_data *)user_data;
1195
1196         if (!data)
1197                 return FALSE;
1198
1199         return data->func(data->user_data);
1200 }
1201
1202 guint _connection_callback_add(GSourceFunc func, gpointer user_data)
1203 {
1204         guint id;
1205         struct managed_idle_data *data;
1206
1207         if (!func)
1208                 return 0;
1209
1210         data = g_try_new0(struct managed_idle_data, 1);
1211         if (!data)
1212                 return 0;
1213
1214         data->func = func;
1215         data->user_data = user_data;
1216
1217         id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, __connection_idle_cb, data,
1218                         __connection_idle_destroy_cb);
1219         if (!id) {
1220                 g_free(data);
1221                 return id;
1222         }
1223
1224         data->id = id;
1225
1226         managed_idler_list = g_slist_append(managed_idler_list, data);
1227
1228         return id;
1229 }
1230
1231 void _connection_callback_cleanup(void)
1232 {
1233         GSList *cur = managed_idler_list;
1234         GSource *src;
1235         struct managed_idle_data *data;
1236
1237         while (cur) {
1238                 GSList *next = cur->next;
1239                 data = (struct managed_idle_data *)cur->data;
1240
1241                 src = g_main_context_find_source_by_id(g_main_context_default(), data->id);
1242                 if (src) {
1243                         g_source_destroy(src);
1244                         cur = managed_idler_list;
1245                 } else
1246                         cur = next;
1247         }
1248
1249         g_slist_free(managed_idler_list);
1250         managed_idler_list = NULL;
1251 }
1252
1253 int _connection_libnet_check_get_privilege()
1254 {
1255         int rv;
1256
1257         rv = net_check_get_privilege();
1258         if (rv == NET_ERR_ACCESS_DENIED) {
1259                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
1260                 return CONNECTION_ERROR_PERMISSION_DENIED;
1261         } else if (rv != NET_ERR_NONE)
1262                 return CONNECTION_ERROR_OPERATION_FAILED;
1263
1264         return CONNECTION_ERROR_NONE;
1265 }
1266
1267 int _connection_libnet_check_profile_privilege()
1268 {
1269         int rv;
1270
1271         rv = net_check_profile_privilege();
1272         if (rv == NET_ERR_ACCESS_DENIED) {
1273                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
1274                 return CONNECTION_ERROR_PERMISSION_DENIED;
1275         } else if (rv != NET_ERR_NONE)
1276                 return CONNECTION_ERROR_OPERATION_FAILED;
1277
1278         return CONNECTION_ERROR_NONE;
1279 }
1280
1281 bool _connection_libnet_get_is_check_enable_feature()
1282 {
1283         return is_check_enable_feature;
1284 }
1285
1286 bool _connection_libnet_get_enable_feature_state(enable_feature_type_e feature_type)
1287 {
1288         if(is_check_enable_feature){
1289                 switch(feature_type) {
1290                 case FEATURE_TYPE_TELEPHONY:
1291                         return enable_feature.telephony;
1292                 case FEATURE_TYPE_WIFI:
1293                         return enable_feature.wifi;
1294                 case FEATURE_TYPE_TETHERING_BLUETOOTH:
1295                         return enable_feature.tethering_bluetooth;
1296                 default:
1297                         CONNECTION_LOG(CONNECTION_ERROR, "Invalid feature type");
1298                         return false;
1299                 }
1300         }
1301         CONNECTION_LOG(CONNECTION_ERROR, "Not checked enable feature yet");
1302         return false;
1303 }