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 <stdio.h>
  18 #include <string.h>
  19 #include <glib.h>
  20 #include <vconf/vconf.h>
  21 #include "net_connection_private.h"
  22
  23 static GSList *conn_handle_list = NULL;
  24
  25 static void __connection_cb_state_change_cb(keynode_t *node, void *user_data);
  26 static void __connection_cb_ip_change_cb(keynode_t *node, void *user_data);
  27 static void __connection_cb_proxy_change_cb(keynode_t *node, void *user_data);
  28
  29 static int __connection_convert_net_state(int status)
  30 {
  31         switch (status) {
  32         case VCONFKEY_NETWORK_CELLULAR:
  33                 return CONNECTION_TYPE_CELLULAR;
  34         case VCONFKEY_NETWORK_WIFI:
  35                 return CONNECTION_TYPE_WIFI;
  36         case VCONFKEY_NETWORK_ETHERNET:
  37                 return CONNECTION_TYPE_ETHERNET;
  38         case VCONFKEY_NETWORK_BLUETOOTH:
  39                 return CONNECTION_TYPE_BT;
  40         default:
  41                 return CONNECTION_TYPE_DISCONNECTED;
  42         }
  43 }
  44
  45 static int __connection_convert_cellular_state(int status)
  46 {
  47         switch (status) {
  48         case VCONFKEY_NETWORK_CELLULAR_ON:
  49                 return CONNECTION_CELLULAR_STATE_AVAILABLE;
  50         case VCONFKEY_NETWORK_CELLULAR_3G_OPTION_OFF:
  51                 return CONNECTION_CELLULAR_STATE_CALL_ONLY_AVAILABLE;
  52         case VCONFKEY_NETWORK_CELLULAR_ROAMING_OFF:
  53                 return CONNECTION_CELLULAR_STATE_ROAMING_OFF;
  54         case VCONFKEY_NETWORK_CELLULAR_FLIGHT_MODE:
  55                 return CONNECTION_CELLULAR_STATE_FLIGHT_MODE;
  56         default:
  57                 return CONNECTION_CELLULAR_STATE_OUT_OF_SERVICE;
  58         }
  59 }
  60
  61 static int __connection_get_type_changed_callback_count(void)
  62 {
  63         GSList *list;
  64         int count = 0;
  65
  66         for (list = conn_handle_list; list; list = list->next) {
  67                 connection_handle_s *local_handle = (connection_handle_s *)list->data;
  68                 if (local_handle->type_changed_callback) count++;
  69         }
  70
  71         return count;
  72 }
  73
  74 static int __connection_get_ip_changed_callback_count(void)
  75 {
  76         GSList *list;
  77         int count = 0;
  78
  79         for (list = conn_handle_list; list; list = list->next) {
  80                 connection_handle_s *local_handle = (connection_handle_s *)list->data;
  81                 if (local_handle->ip_changed_callback) count++;
  82         }
  83
  84         return count;
  85 }
  86
  87 static int __connection_get_proxy_changed_callback_count(void)
  88 {
  89         GSList *list;
  90         int count = 0;
  91
  92         for (list = conn_handle_list; list; list = list->next) {
  93                 connection_handle_s *local_handle = (connection_handle_s *)list->data;
  94                 if (local_handle->proxy_changed_callback) count++;
  95         }
  96
  97         return count;
  98 }
  99
 100 static int __connection_set_type_changed_callback(connection_h connection,
 101                                                         void *callback, void *user_data)
 102 {
 103         connection_handle_s *local_handle = (connection_handle_s *)connection;
 104
 105         if (callback) {
 106                 if (__connection_get_type_changed_callback_count() == 0)
 107                         if (vconf_notify_key_changed(VCONFKEY_NETWORK_STATUS ,
 108                                         __connection_cb_state_change_cb, NULL))
 109                                 return CONNECTION_ERROR_OPERATION_FAILED;
 110
 111                 local_handle->state_changed_user_data = user_data;
 112         } else {
 113                 if (local_handle->type_changed_callback &&
 114                     __connection_get_type_changed_callback_count() == 1)
 115                         if (vconf_ignore_key_changed(VCONFKEY_NETWORK_STATUS,
 116                                         __connection_cb_state_change_cb))
 117                                 return CONNECTION_ERROR_OPERATION_FAILED;
 118         }
 119
 120         local_handle->type_changed_callback = callback;
 121         return CONNECTION_ERROR_NONE;
 122 }
 123
 124 static int __connection_set_ip_changed_callback(connection_h connection,
 125                                                         void *callback, void *user_data)
 126 {
 127         connection_handle_s *local_handle = (connection_handle_s *)connection;
 128
 129         if (callback) {
 130                 if (__connection_get_ip_changed_callback_count() == 0)
 131                         if (vconf_notify_key_changed(VCONFKEY_NETWORK_IP,
 132                                         __connection_cb_ip_change_cb, NULL))
 133                                 return CONNECTION_ERROR_OPERATION_FAILED;
 134
 135                 local_handle->ip_changed_user_data = user_data;
 136         } else {
 137                 if (local_handle->ip_changed_callback &&
 138                     __connection_get_ip_changed_callback_count() == 1)
 139                         if (vconf_ignore_key_changed(VCONFKEY_NETWORK_IP,
 140                                         __connection_cb_ip_change_cb))
 141                                 return CONNECTION_ERROR_OPERATION_FAILED;
 142         }
 143
 144         local_handle->ip_changed_callback = callback;
 145         return CONNECTION_ERROR_NONE;
 146 }
 147
 148 static int __connection_set_proxy_changed_callback(connection_h connection,
 149                                                         void *callback, void *user_data)
 150 {
 151         connection_handle_s *local_handle = (connection_handle_s *)connection;
 152
 153         if (callback) {
 154                 if (__connection_get_proxy_changed_callback_count() == 0)
 155                         if (vconf_notify_key_changed(VCONFKEY_NETWORK_PROXY,
 156                                         __connection_cb_proxy_change_cb, NULL))
 157                                 return CONNECTION_ERROR_OPERATION_FAILED;
 158
 159                 local_handle->proxy_changed_user_data = user_data;
 160         } else {
 161                 if (local_handle->proxy_changed_callback &&
 162                     __connection_get_proxy_changed_callback_count() == 1)
 163                         if (vconf_ignore_key_changed(VCONFKEY_NETWORK_PROXY,
 164                                         __connection_cb_proxy_change_cb))
 165                                 return CONNECTION_ERROR_OPERATION_FAILED;
 166         }
 167
 168         local_handle->proxy_changed_callback = callback;
 169         return CONNECTION_ERROR_NONE;
 170 }
 171
 172 static void __connection_cb_state_change_cb(keynode_t *node, void *user_data)
 173 {
 174         CONNECTION_LOG(CONNECTION_INFO, "Net Status Changed Indication\n");
 175
 176         GSList *list;
 177         int state = vconf_keynode_get_int(node);
 178
 179         for (list = conn_handle_list; list; list = list->next) {
 180                 connection_handle_s *local_handle = (connection_handle_s *)list->data;
 181                 if (local_handle->type_changed_callback)
 182                         local_handle->type_changed_callback(
 183                                         __connection_convert_net_state(state),
 184                                         local_handle->state_changed_user_data);
 185         }
 186 }
 187
 188 static void __connection_cb_ip_change_cb(keynode_t *node, void *user_data)
 189 {
 190         CONNECTION_LOG(CONNECTION_INFO, "Net IP Changed Indication\n");
 191
 192         GSList *list;
 193         char *ip_addr = vconf_keynode_get_str(node);
 194
 195         for (list = conn_handle_list; list; list = list->next) {
 196                 connection_handle_s *local_handle = (connection_handle_s *)list->data;
 197                 if (local_handle->ip_changed_callback)
 198                         local_handle->ip_changed_callback(
 199                                         ip_addr, NULL,
 200                                         local_handle->ip_changed_user_data);
 201         }
 202 }
 203
 204 static void __connection_cb_proxy_change_cb(keynode_t *node, void *user_data)
 205 {
 206         CONNECTION_LOG(CONNECTION_INFO, "Net IP Changed Indication\n");
 207
 208         GSList *list;
 209         char *proxy = vconf_keynode_get_str(node);
 210
 211         for (list = conn_handle_list; list; list = list->next) {
 212                 connection_handle_s *local_handle = (connection_handle_s *)list->data;
 213                 if (local_handle->proxy_changed_callback)
 214                         local_handle->proxy_changed_callback(
 215                                         proxy, NULL,
 216                                         local_handle->proxy_changed_user_data);
 217         }
 218 }
 219
 220 static bool __connection_check_handle_validity(connection_h connection)
 221 {
 222         bool ret = false;
 223
 224         if (connection == NULL)
 225                 return false;
 226
 227         if (g_slist_find(conn_handle_list, connection) != NULL)
 228                 ret = true;
 229
 230         return ret;
 231 }
 232
 233 static int __connection_get_handle_count(void)
 234 {
 235         GSList *list;
 236         int count = 0;
 237
 238         if (!conn_handle_list)
 239                 return count;
 240
 241         for (list = conn_handle_list; list; list = list->next) count++;
 242
 243         return count;
 244 }
 245
 246 /* Connection Manager ********************************************************/
 247 EXPORT_API int connection_create(connection_h* connection)
 248 {
 249         CONNECTION_MUTEX_LOCK;
 250         int rv;
 251         if (connection == NULL || __connection_check_handle_validity(*connection)) {
 252                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 253                 CONNECTION_MUTEX_UNLOCK;
 254                 return CONNECTION_ERROR_INVALID_PARAMETER;
 255         }
 256
 257         rv = _connection_libnet_init();
 258         if (rv == NET_ERR_ACCESS_DENIED) {
 259                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 260                 return CONNECTION_ERROR_PERMISSION_DENIED;
 261         }
 262         else if (rv != NET_ERR_NONE) {
 263                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create connection[%d]", rv);
 264                 return CONNECTION_ERROR_OPERATION_FAILED;
 265         }
 266
 267         *connection = g_try_malloc0(sizeof(connection_handle_s));
 268         if (*connection != NULL) {
 269                 CONNECTION_LOG(CONNECTION_INFO, "New Handle Created %p\n", *connection);
 270         } else {
 271                 CONNECTION_MUTEX_UNLOCK;
 272                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 273         }
 274
 275         conn_handle_list = g_slist_append(conn_handle_list, *connection);
 276
 277         CONNECTION_MUTEX_UNLOCK;
 278         return CONNECTION_ERROR_NONE;
 279 }
 280
 281 EXPORT_API int connection_destroy(connection_h connection)
 282 {
 283         CONNECTION_MUTEX_LOCK;
 284
 285         if (connection == NULL || !(__connection_check_handle_validity(connection))) {
 286                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 287                 CONNECTION_MUTEX_UNLOCK;
 288                 return CONNECTION_ERROR_INVALID_PARAMETER;
 289         }
 290
 291         CONNECTION_LOG(CONNECTION_INFO, "Destroy Handle : %p\n", connection);
 292
 293         __connection_set_type_changed_callback(connection, NULL, NULL);
 294         __connection_set_ip_changed_callback(connection, NULL, NULL);
 295         __connection_set_proxy_changed_callback(connection, NULL, NULL);
 296
 297         conn_handle_list = g_slist_remove(conn_handle_list, connection);
 298
 299         g_free(connection);
 300
 301         if (__connection_get_handle_count() == 0)
 302                 _connection_libnet_deinit();
 303
 304         CONNECTION_MUTEX_UNLOCK;
 305         return CONNECTION_ERROR_NONE;
 306 }
 307
 308 EXPORT_API int connection_get_type(connection_h connection, connection_type_e* type)
 309 {
 310         int status = 0;
 311
 312         if (type == NULL || !(__connection_check_handle_validity(connection))) {
 313                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 314                 return CONNECTION_ERROR_INVALID_PARAMETER;
 315         }
 316
 317         if (vconf_get_int(VCONFKEY_NETWORK_STATUS, &status)) {
 318                 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed = %d\n", status);
 319                 return CONNECTION_ERROR_OPERATION_FAILED;
 320         }
 321
 322         CONNECTION_LOG(CONNECTION_INFO, "Connected Network = %d\n", status);
 323
 324         *type = __connection_convert_net_state(status);
 325
 326         return CONNECTION_ERROR_NONE;
 327 }
 328
 329 EXPORT_API int connection_get_ip_address(connection_h connection,
 330                                 connection_address_family_e address_family, char** ip_address)
 331 {
 332         if (ip_address == NULL || !(__connection_check_handle_validity(connection))) {
 333                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 334                 return CONNECTION_ERROR_INVALID_PARAMETER;
 335         }
 336
 337         switch (address_family) {
 338         case CONNECTION_ADDRESS_FAMILY_IPV4:
 339                 *ip_address = vconf_get_str(VCONFKEY_NETWORK_IP);
 340                 break;
 341         case CONNECTION_ADDRESS_FAMILY_IPV6:
 342                 CONNECTION_LOG(CONNECTION_ERROR, "Not supported yet\n");
 343                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 344                 break;
 345         default:
 346                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 347                 return CONNECTION_ERROR_INVALID_PARAMETER;
 348         }
 349
 350         if (*ip_address == NULL) {
 351                 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed\n");
 352                 return CONNECTION_ERROR_OPERATION_FAILED;
 353         }
 354
 355         return CONNECTION_ERROR_NONE;
 356 }
 357
 358 EXPORT_API int connection_get_proxy(connection_h connection,
 359                                 connection_address_family_e address_family, char** proxy)
 360 {
 361         if (proxy == NULL || !(__connection_check_handle_validity(connection))) {
 362                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 363                 return CONNECTION_ERROR_INVALID_PARAMETER;
 364         }
 365
 366         switch (address_family) {
 367         case CONNECTION_ADDRESS_FAMILY_IPV4:
 368                 *proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
 369                 break;
 370         case CONNECTION_ADDRESS_FAMILY_IPV6:
 371                 CONNECTION_LOG(CONNECTION_ERROR, "Not supported yet\n");
 372                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 373                 break;
 374         default:
 375                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 376                 return CONNECTION_ERROR_INVALID_PARAMETER;
 377         }
 378
 379         if (*proxy == NULL) {
 380                 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_str Failed\n");
 381                 return CONNECTION_ERROR_OPERATION_FAILED;
 382         }
 383
 384         return CONNECTION_ERROR_NONE;
 385 }
 386
 387 EXPORT_API int connection_get_cellular_state(connection_h connection, connection_cellular_state_e* state)
 388 {
 389         int status = 0;
 390         int cellular_state = 0;
 391
 392         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 393                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 394                 return CONNECTION_ERROR_INVALID_PARAMETER;
 395         }
 396
 397         if (!vconf_get_int(VCONFKEY_NETWORK_CELLULAR_STATE, &status)) {
 398                 CONNECTION_LOG(CONNECTION_INFO, "Cellular = %d\n", status);
 399                 *state = __connection_convert_cellular_state(status);
 400
 401                 if (*state == CONNECTION_CELLULAR_STATE_AVAILABLE) {
 402                         if (vconf_get_int(VCONFKEY_DNET_STATE, &cellular_state)) {
 403                                 CONNECTION_LOG(CONNECTION_ERROR,
 404                                                 "vconf_get_int Failed = %d\n", cellular_state);
 405                                 return CONNECTION_ERROR_OPERATION_FAILED;
 406                         }
 407                 }
 408
 409                 CONNECTION_LOG(CONNECTION_INFO, "Connection state = %d\n", cellular_state);
 410
 411                 if (cellular_state == VCONFKEY_DNET_NORMAL_CONNECTED ||
 412                     cellular_state == VCONFKEY_DNET_SECURE_CONNECTED ||
 413                     cellular_state == VCONFKEY_DNET_TRANSFER)
 414                         *state = CONNECTION_CELLULAR_STATE_CONNECTED;
 415
 416                 return CONNECTION_ERROR_NONE;
 417         } else {
 418                 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed = %d\n", status);
 419                 return CONNECTION_ERROR_OPERATION_FAILED;
 420         }
 421 }
 422
 423 EXPORT_API int connection_get_wifi_state(connection_h connection, connection_wifi_state_e* state)
 424 {
 425         int rv;
 426
 427         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 428                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 429                 return CONNECTION_ERROR_INVALID_PARAMETER;
 430         }
 431
 432         rv = _connection_libnet_get_wifi_state(state);
 433         if (rv != CONNECTION_ERROR_NONE) {
 434                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get Wi-Fi state[%d]", rv);
 435                 return rv;
 436         }
 437
 438         CONNECTION_LOG(CONNECTION_INFO, "WiFi state = %d\n", *state);
 439
 440         return CONNECTION_ERROR_NONE;
 441 }
 442
 443 EXPORT_API int connection_get_ethernet_state(connection_h connection, connection_ethernet_state_e* state)
 444 {
 445         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 446                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 447                 return CONNECTION_ERROR_INVALID_PARAMETER;
 448         }
 449
 450         return _connection_libnet_get_ethernet_state(state);
 451 }
 452
 453 EXPORT_API int connection_get_bt_state(connection_h connection, connection_bt_state_e* state)
 454 {
 455         if (state == NULL || !(__connection_check_handle_validity(connection))) {
 456                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 457                 return CONNECTION_ERROR_INVALID_PARAMETER;
 458         }
 459
 460         return _connection_libnet_get_bluetooth_state(state);
 461
 462 }
 463
 464 EXPORT_API int connection_set_type_changed_cb(connection_h connection,
 465                                         connection_type_changed_cb callback, void* user_data)
 466 {
 467         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 468                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 469                 return CONNECTION_ERROR_INVALID_PARAMETER;
 470         }
 471
 472         return __connection_set_type_changed_callback(connection, callback, user_data);
 473 }
 474
 475 EXPORT_API int connection_unset_type_changed_cb(connection_h connection)
 476 {
 477         if (!(__connection_check_handle_validity(connection))) {
 478                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 479                 return CONNECTION_ERROR_INVALID_PARAMETER;
 480         }
 481
 482         return __connection_set_type_changed_callback(connection, NULL, NULL);
 483 }
 484
 485 EXPORT_API int connection_set_ip_address_changed_cb(connection_h connection,
 486                                 connection_address_changed_cb callback, void* user_data)
 487 {
 488         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 489                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 490                 return CONNECTION_ERROR_INVALID_PARAMETER;
 491         }
 492
 493         return __connection_set_ip_changed_callback(connection, callback, user_data);
 494 }
 495
 496 EXPORT_API int connection_unset_ip_address_changed_cb(connection_h connection)
 497 {
 498         if (!(__connection_check_handle_validity(connection))) {
 499                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 500                 return CONNECTION_ERROR_INVALID_PARAMETER;
 501         }
 502
 503         return __connection_set_ip_changed_callback(connection, NULL, NULL);
 504 }
 505
 506 EXPORT_API int connection_set_proxy_address_changed_cb(connection_h connection,
 507                                 connection_address_changed_cb callback, void* user_data)
 508 {
 509         if (callback == NULL || !(__connection_check_handle_validity(connection))) {
 510                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 511                 return CONNECTION_ERROR_INVALID_PARAMETER;
 512         }
 513
 514         return __connection_set_proxy_changed_callback(connection, callback, user_data);
 515 }
 516
 517 EXPORT_API int connection_unset_proxy_address_changed_cb(connection_h connection)
 518 {
 519         if (!(__connection_check_handle_validity(connection))) {
 520                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 521                 return CONNECTION_ERROR_INVALID_PARAMETER;
 522         }
 523
 524         return __connection_set_proxy_changed_callback(connection, NULL, NULL);
 525 }
 526
 527 EXPORT_API int connection_add_profile(connection_h connection, connection_profile_h profile)
 528 {
 529         if (!(__connection_check_handle_validity(connection)) ||
 530             !(_connection_libnet_check_profile_validity(profile))) {
 531                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 532                 return CONNECTION_ERROR_INVALID_PARAMETER;
 533         }
 534
 535         int rv = 0;
 536
 537         net_profile_info_t *profile_info = profile;
 538
 539         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
 540                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 541                 return CONNECTION_ERROR_INVALID_PARAMETER;
 542         }
 543
 544         rv = net_add_profile(profile_info->ProfileInfo.Pdp.ServiceType, (net_profile_info_t*)profile);
 545         if (rv == NET_ERR_ACCESS_DENIED) {
 546                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 547                 return CONNECTION_ERROR_PERMISSION_DENIED;
 548         } else if (rv != NET_ERR_NONE) {
 549                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to add profile[%d]", rv);
 550                 return CONNECTION_ERROR_OPERATION_FAILED;
 551         }
 552
 553         return CONNECTION_ERROR_NONE;
 554 }
 555
 556 EXPORT_API int connection_remove_profile(connection_h connection, connection_profile_h profile)
 557 {
 558         if (!(__connection_check_handle_validity(connection)) ||
 559             !(_connection_libnet_check_profile_validity(profile))) {
 560                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 561                 return CONNECTION_ERROR_INVALID_PARAMETER;
 562         }
 563
 564         int rv = 0;
 565         net_profile_info_t *profile_info = profile;
 566
 567         if (profile_info->profile_type != NET_DEVICE_CELLULAR &&
 568             profile_info->profile_type != NET_DEVICE_WIFI) {
 569                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 570                 return CONNECTION_ERROR_INVALID_PARAMETER;
 571         }
 572
 573         rv = net_delete_profile(profile_info->ProfileName);
 574         if (rv == NET_ERR_ACCESS_DENIED) {
 575                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 576                 return CONNECTION_ERROR_PERMISSION_DENIED;
 577         } else if (rv != NET_ERR_NONE) {
 578                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to delete profile[%d]", rv);
 579                 return CONNECTION_ERROR_OPERATION_FAILED;
 580         }
 581
 582         return CONNECTION_ERROR_NONE;
 583 }
 584
 585 EXPORT_API int connection_update_profile(connection_h connection, connection_profile_h profile)
 586 {
 587         if (!(__connection_check_handle_validity(connection)) ||
 588             !(_connection_libnet_check_profile_validity(profile))) {
 589                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 590                 return CONNECTION_ERROR_INVALID_PARAMETER;
 591         }
 592
 593         int rv = 0;
 594         net_profile_info_t *profile_info = profile;
 595
 596         rv = net_modify_profile(profile_info->ProfileName, (net_profile_info_t*)profile);
 597         if (rv == NET_ERR_ACCESS_DENIED) {
 598                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 599                 return CONNECTION_ERROR_PERMISSION_DENIED;
 600         } else if (rv != NET_ERR_NONE) {
 601                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to modify profile[%d]", rv);
 602                 return CONNECTION_ERROR_OPERATION_FAILED;
 603         }
 604
 605         return CONNECTION_ERROR_NONE;
 606 }
 607
 608 EXPORT_API int connection_get_profile_iterator(connection_h connection,
 609                 connection_iterator_type_e type, connection_profile_iterator_h* profile_iterator)
 610 {
 611         if (!(__connection_check_handle_validity(connection)) ||
 612             (type != CONNECTION_ITERATOR_TYPE_REGISTERED &&
 613              type != CONNECTION_ITERATOR_TYPE_CONNECTED &&
 614              type != CONNECTION_ITERATOR_TYPE_DEFAULT)) {
 615                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 616                 return CONNECTION_ERROR_INVALID_PARAMETER;
 617         }
 618
 619         return _connection_libnet_get_profile_iterator(type, profile_iterator);
 620 }
 621
 622 EXPORT_API int connection_profile_iterator_next(connection_profile_iterator_h profile_iterator,
 623                                                         connection_profile_h* profile)
 624 {
 625         return _connection_libnet_get_iterator_next(profile_iterator, profile);
 626 }
 627
 628 EXPORT_API bool connection_profile_iterator_has_next(connection_profile_iterator_h profile_iterator)
 629 {
 630         return _connection_libnet_iterator_has_next(profile_iterator);
 631 }
 632
 633 EXPORT_API int connection_destroy_profile_iterator(connection_profile_iterator_h profile_iterator)
 634 {
 635         return _connection_libnet_destroy_iterator(profile_iterator);
 636 }
 637
 638 EXPORT_API int connection_get_current_profile(connection_h connection, connection_profile_h* profile)
 639 {
 640         if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
 641                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 642                 return CONNECTION_ERROR_INVALID_PARAMETER;
 643         }
 644
 645         return _connection_libnet_get_current_profile(profile);
 646 }
 647
 648 EXPORT_API int connection_get_default_cellular_service_profile(connection_h connection,
 649                 connection_cellular_service_type_e type, connection_profile_h* profile)
 650 {
 651         if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
 652                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 653                 return CONNECTION_ERROR_INVALID_PARAMETER;
 654         }
 655
 656         return _connection_libnet_get_cellular_service_profile(type, profile);
 657 }
 658
 659 EXPORT_API int connection_set_default_cellular_service_profile(connection_h connection,
 660                 connection_cellular_service_type_e type, connection_profile_h profile)
 661 {
 662         if (!(__connection_check_handle_validity(connection)) || profile == NULL) {
 663                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 664                 return CONNECTION_ERROR_INVALID_PARAMETER;
 665         }
 666
 667         return _connection_libnet_set_cellular_service_profile_sync(type, profile);
 668 }
 669
 670 EXPORT_API int connection_set_default_cellular_service_profile_async(connection_h connection,
 671                 connection_cellular_service_type_e type, connection_profile_h profile,
 672                 connection_set_default_cb callback, void* user_data)
 673 {
 674         if (!(__connection_check_handle_validity(connection)) ||
 675             profile == NULL || callback == NULL) {
 676                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 677                 return CONNECTION_ERROR_INVALID_PARAMETER;
 678         }
 679
 680         return _connection_libnet_set_cellular_service_profile_async(type, profile, callback, user_data);
 681 }
 682
 683 EXPORT_API int connection_open_profile(connection_h connection, connection_profile_h profile,
 684                                         connection_opened_cb callback, void* user_data)
 685 {
 686         if (!(__connection_check_handle_validity(connection)) ||
 687             profile == NULL || callback == NULL) {
 688                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 689                 return CONNECTION_ERROR_INVALID_PARAMETER;
 690         }
 691
 692         return _connection_libnet_open_profile(profile, callback, user_data);
 693 }
 694
 695 EXPORT_API int connection_close_profile(connection_h connection, connection_profile_h profile,
 696                                         connection_closed_cb callback, void* user_data)
 697 {
 698         if (!(__connection_check_handle_validity(connection)) ||
 699             profile == NULL || callback == NULL) {
 700                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 701                 return CONNECTION_ERROR_INVALID_PARAMETER;
 702         }
 703
 704         return _connection_libnet_close_profile(profile, callback, user_data);
 705 }
 706
 707 EXPORT_API int connection_reset_profile(connection_h connection,
 708                                 connection_reset_option_e type, int id, connection_reset_cb callback, void *user_data)
 709 {
 710         if (!(__connection_check_handle_validity(connection))) {
 711                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed");
 712                 return CONNECTION_ERROR_INVALID_PARAMETER;
 713         }
 714
 715         if(id < 0 || id > 1) {
 716                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed");
 717                 return CONNECTION_ERROR_INVALID_PARAMETER;
 718         }
 719
 720         return _connection_libnet_reset_profile(type, id, callback, user_data);
 721 }
 722
 723 EXPORT_API int connection_add_route(connection_h connection, const char* interface_name, const char* host_address)
 724 {
 725         if (!(__connection_check_handle_validity(connection)) ||
 726             interface_name == NULL || host_address == NULL) {
 727                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 728                 return CONNECTION_ERROR_INVALID_PARAMETER;
 729         }
 730
 731         return _connection_libnet_add_route(interface_name, host_address);
 732 }
 733
 734 EXPORT_API int connection_remove_route(connection_h connection, const char* interface_name, const char* host_address)
 735 {
 736         if (!(__connection_check_handle_validity(connection)) ||
 737             interface_name == NULL || host_address == NULL) {
 738                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 739                 return CONNECTION_ERROR_INVALID_PARAMETER;
 740         }
 741
 742         return _connection_libnet_remove_route(interface_name, host_address);
 743 }
 744
 745 /* Connection Statistics module ******************************************************************/
 746
 747 static int __get_statistic(connection_type_e connection_type,
 748                         connection_statistics_type_e statistics_type, long long* llsize)
 749 {
 750         int rv, size;
 751         unsigned long long ull_size;
 752         int stat_type;
 753         char *key = NULL;
 754
 755         if (llsize == NULL) {
 756                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 757                 return CONNECTION_ERROR_INVALID_PARAMETER;
 758         }
 759
 760         if (connection_type == CONNECTION_TYPE_CELLULAR) {
 761                 switch (statistics_type) {
 762                 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
 763                         key = VCONFKEY_NETWORK_CELLULAR_PKT_LAST_SNT;
 764                         break;
 765                 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
 766                         key = VCONFKEY_NETWORK_CELLULAR_PKT_LAST_RCV;
 767                         break;
 768                 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
 769                         key = VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_SNT;
 770                         break;
 771                 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
 772                         key = VCONFKEY_NETWORK_CELLULAR_PKT_TOTAL_RCV;
 773                         break;
 774                 default:
 775                         return CONNECTION_ERROR_INVALID_PARAMETER;
 776                 }
 777
 778                 if (vconf_get_int(key, &size)) {
 779                         CONNECTION_LOG(CONNECTION_ERROR, "Cannot Get %s = %d\n", key, size);
 780                         *llsize = 0;
 781                         return CONNECTION_ERROR_OPERATION_FAILED;
 782                 }
 783
 784                 CONNECTION_LOG(CONNECTION_INFO,"%s:%d bytes\n", key, size);
 785                 *llsize = (long long)size;
 786         } else if (connection_type == CONNECTION_TYPE_WIFI) {
 787                 switch (statistics_type) {
 788                 case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
 789                         stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
 790                         break;
 791                 case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
 792                         stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
 793                         break;
 794                 case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
 795                         stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
 796                         break;
 797                 case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
 798                         stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
 799                         break;
 800                 default:
 801                         return CONNECTION_ERROR_INVALID_PARAMETER;
 802                 }
 803
 804                 rv  = _connection_libnet_get_statistics(stat_type, &ull_size);
 805                 if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
 806                         return rv;
 807                 else if (rv != CONNECTION_ERROR_NONE) {
 808                         CONNECTION_LOG(CONNECTION_ERROR, "Failed to get Wi-Fi statistics");
 809                         *llsize = 0;
 810                         return CONNECTION_ERROR_OPERATION_FAILED;
 811                 }
 812
 813                 CONNECTION_LOG(CONNECTION_INFO,"%d bytes\n", ull_size);
 814                 *llsize = (long long)ull_size;
 815         } else
 816                 return CONNECTION_ERROR_INVALID_PARAMETER;
 817
 818         return CONNECTION_ERROR_NONE;
 819 }
 820
 821 static int __reset_statistic(connection_type_e connection_type,
 822                         connection_statistics_type_e statistics_type)
 823 {
 824         int conn_type;
 825         int stat_type;
 826         int rv;
 827
 828         if (connection_type == CONNECTION_TYPE_CELLULAR)
 829                 conn_type = NET_DEVICE_CELLULAR;
 830         else if (connection_type == CONNECTION_TYPE_WIFI)
 831                 conn_type = NET_DEVICE_WIFI;
 832         else
 833                 return CONNECTION_ERROR_INVALID_PARAMETER;
 834
 835         switch (statistics_type) {
 836         case CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA:
 837                 stat_type = NET_STATISTICS_TYPE_LAST_SENT_DATA;
 838                 break;
 839         case CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA:
 840                 stat_type = NET_STATISTICS_TYPE_LAST_RECEIVED_DATA;
 841                 break;
 842         case CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA:
 843                 stat_type = NET_STATISTICS_TYPE_TOTAL_SENT_DATA;
 844                 break;
 845         case CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA:
 846                 stat_type = NET_STATISTICS_TYPE_TOTAL_RECEIVED_DATA;
 847                 break;
 848         default:
 849                 return CONNECTION_ERROR_INVALID_PARAMETER;
 850         }
 851
 852         rv = _connection_libnet_set_statistics(conn_type, stat_type);
 853         if(rv != CONNECTION_ERROR_NONE)
 854                 return rv;
 855
 856
 857         CONNECTION_LOG(CONNECTION_INFO,"connection_reset_statistics success\n");
 858
 859         return CONNECTION_ERROR_NONE;
 860 }
 861
 862 EXPORT_API int connection_get_statistics(connection_h connection,
 863                                 connection_type_e connection_type,
 864                                 connection_statistics_type_e statistics_type, long long* size)
 865 {
 866         if (!(__connection_check_handle_validity(connection)) || size == NULL) {
 867                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 868                 return CONNECTION_ERROR_INVALID_PARAMETER;
 869         }
 870
 871         return __get_statistic(connection_type, statistics_type, size);
 872 }
 873
 874 EXPORT_API int connection_reset_statistics(connection_h connection,
 875                                 connection_type_e connection_type,
 876                                 connection_statistics_type_e statistics_type)
 877 {
 878         if (!(__connection_check_handle_validity(connection))) {
 879                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed");
 880                 return CONNECTION_ERROR_INVALID_PARAMETER;
 881         }
 882
 883         return __reset_statistic(connection_type, statistics_type);
 884 }