src/connection_profile.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 <stdlib.h>
  20 #include <arpa/inet.h>
  21 #include <glib.h>
  22 #include <vconf/vconf.h>
  23 #include "net_connection_private.h"
  24
  25 #define HTTP_PROXY "http_proxy"
  26
  27 static net_dev_info_t* __profile_get_net_info(net_profile_info_t *profile_info)
  28 {
  29         switch (profile_info->profile_type) {
  30         case NET_DEVICE_CELLULAR:
  31                 return &profile_info->ProfileInfo.Pdp.net_info;
  32         case NET_DEVICE_WIFI:
  33                 return &profile_info->ProfileInfo.Wlan.net_info;
  34         case NET_DEVICE_ETHERNET:
  35                 return &profile_info->ProfileInfo.Ethernet.net_info;
  36         case NET_DEVICE_BLUETOOTH:
  37                 return &profile_info->ProfileInfo.Bluetooth.net_info;
  38         case NET_DEVICE_DEFAULT:
  39         case NET_DEVICE_USB:
  40         case NET_DEVICE_UNKNOWN:
  41         case NET_DEVICE_MAX:
  42         default:
  43                 return NULL;
  44         }
  45 }
  46
  47 static char* __profile_convert_ip_to_string(net_addr_t *ip_addr)
  48 {
  49         unsigned char *ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr;
  50
  51         char *ipstr = g_try_malloc0(16);
  52         if (ipstr == NULL)
  53                 return NULL;
  54
  55         snprintf(ipstr, 16, "%d.%d.%d.%d", ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3]);
  56
  57         return ipstr;
  58 }
  59
  60 static void __profile_init_cellular_profile(net_profile_info_t *profile_info, const char *keyword)
  61 {
  62         int default_subscriber_id = 0;
  63         connection_profile_h profile = NULL;
  64
  65         profile_info->profile_type = NET_DEVICE_CELLULAR;
  66         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
  67         profile_info->ProfileInfo.Pdp.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
  68         profile_info->ProfileInfo.Pdp.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
  69         g_strlcpy(profile_info->ProfileInfo.Pdp.Keyword, keyword, NET_PDP_APN_LEN_MAX);
  70
  71         if (vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE,
  72                                         &default_subscriber_id) != 0)
  73                 CONNECTION_LOG(CONNECTION_ERROR,
  74                                                 "Failed to get VCONF_TELEPHONY_DEFAULT_DATA_SERVICE");
  75
  76         profile = (connection_profile_h)profile_info;
  77         _connection_libnet_set_cellular_subscriber_id(profile, default_subscriber_id);
  78 }
  79
  80 static void __profile_init_wifi_profile(net_profile_info_t *profile_info)
  81 {
  82         profile_info->profile_type = NET_DEVICE_WIFI;
  83         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
  84         profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
  85         profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
  86         profile_info->ProfileInfo.Wlan.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
  87         profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
  88         profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
  89 }
  90
  91 static const char* __profile_get_ethernet_proxy(void)
  92 {
  93         char *proxy;
  94
  95         proxy = getenv(HTTP_PROXY);
  96
  97         if(proxy == NULL) {
  98                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get system proxy");
  99                 return NULL;
 100         }
 101
 102         return proxy;
 103 }
 104
 105 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
 106 {
 107         switch (svc_type) {
 108         case NET_SERVICE_INTERNET:
 109                 return CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
 110         case NET_SERVICE_MMS:
 111                 return CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
 112         case NET_SERVICE_PREPAID_INTERNET:
 113                 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
 114         case NET_SERVICE_PREPAID_MMS:
 115                 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
 116         case NET_SERVICE_TETHERING:
 117                 return CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
 118         case NET_SERVICE_APPLICATION:
 119                 return CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
 120         default:
 121                 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
 122         }
 123 }
 124
 125 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
 126 {
 127         connection_profile_state_e cp_state;
 128
 129         switch (state) {
 130         case NET_STATE_TYPE_ONLINE:
 131         case NET_STATE_TYPE_READY:
 132                 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
 133                 break;
 134         case NET_STATE_TYPE_IDLE:
 135         case NET_STATE_TYPE_FAILURE:
 136         case NET_STATE_TYPE_DISCONNECT:
 137                 cp_state = CONNECTION_PROFILE_STATE_DISCONNECTED;
 138                 break;
 139         case NET_STATE_TYPE_ASSOCIATION:
 140                 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
 141                 break;
 142         case NET_STATE_TYPE_CONFIGURATION:
 143                 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
 144                 break;
 145         default:
 146                 cp_state = -1;
 147         }
 148
 149         return cp_state;
 150 }
 151
 152 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
 153 {
 154         switch (svc_type) {
 155         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
 156                 return NET_SERVICE_INTERNET;
 157         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
 158                 return NET_SERVICE_MMS;
 159         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
 160                 return NET_SERVICE_PREPAID_INTERNET;
 161         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
 162                 return NET_SERVICE_PREPAID_MMS;
 163         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
 164                 return NET_SERVICE_TETHERING;
 165         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
 166                 return NET_SERVICE_APPLICATION;
 167         default:
 168                 return NET_SERVICE_UNKNOWN;
 169         }
 170 }
 171
 172 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
 173 {
 174         net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
 175
 176         switch (state) {
 177         case CONNECTION_PROFILE_STATE_CONNECTED:
 178                 libnet_state = NET_STATE_TYPE_ONLINE;
 179                 break;
 180         case CONNECTION_PROFILE_STATE_DISCONNECTED:
 181                 libnet_state = NET_STATE_TYPE_IDLE;
 182                 break;
 183         case CONNECTION_PROFILE_STATE_ASSOCIATION:
 184                 libnet_state = NET_STATE_TYPE_ASSOCIATION;
 185                 break;
 186         case CONNECTION_PROFILE_STATE_CONFIGURATION:
 187                 libnet_state = NET_STATE_TYPE_CONFIGURATION;
 188                 break;
 189         }
 190
 191         return libnet_state;
 192 }
 193
 194
 195 /* Connection profile ********************************************************/
 196 EXPORT_API int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
 197 {
 198         if ((type != CONNECTION_PROFILE_TYPE_CELLULAR &&
 199              type != CONNECTION_PROFILE_TYPE_WIFI) || profile == NULL) {
 200                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 201                 return CONNECTION_ERROR_INVALID_PARAMETER;
 202         }
 203
 204         net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
 205         if (profile_info == NULL)
 206                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 207
 208         switch (type) {
 209         case CONNECTION_PROFILE_TYPE_CELLULAR:
 210                 if (keyword == NULL) {
 211                         CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 212                         g_free(profile_info);
 213                         return CONNECTION_ERROR_INVALID_PARAMETER;
 214                 }
 215                 __profile_init_cellular_profile(profile_info, keyword);
 216                 break;
 217         case CONNECTION_PROFILE_TYPE_WIFI:
 218                 __profile_init_wifi_profile(profile_info);
 219                 break;
 220         default:
 221                 break;
 222         }
 223
 224         *profile = (connection_profile_h)profile_info;
 225         _connection_libnet_add_to_profile_list(*profile);
 226
 227         return CONNECTION_ERROR_NONE;
 228 }
 229
 230 EXPORT_API int connection_profile_destroy(connection_profile_h profile)
 231 {
 232         if (!(_connection_libnet_check_profile_validity(profile))) {
 233                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 234                 return CONNECTION_ERROR_INVALID_PARAMETER;
 235         }
 236
 237         _connection_libnet_remove_from_profile_list(profile);
 238
 239         return CONNECTION_ERROR_NONE;
 240 }
 241
 242 EXPORT_API int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
 243 {
 244         if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
 245                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 246                 return CONNECTION_ERROR_INVALID_PARAMETER;
 247         }
 248
 249         *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
 250         if (*cloned_profile == NULL)
 251                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 252
 253         memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
 254         _connection_libnet_add_to_profile_list(*cloned_profile);
 255
 256         return CONNECTION_ERROR_NONE;
 257 }
 258
 259 EXPORT_API int connection_profile_get_id(connection_profile_h profile, char** profile_id)
 260 {
 261         if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
 262                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 263                 return CONNECTION_ERROR_INVALID_PARAMETER;
 264         }
 265
 266         net_profile_info_t *profile_info = profile;
 267
 268         char *prof_id = strrchr(profile_info->ProfileName, '/');
 269         if (prof_id == NULL)
 270                 return CONNECTION_ERROR_INVALID_PARAMETER;
 271
 272         prof_id++;
 273         *profile_id = g_strdup(prof_id);
 274
 275         if (*profile_id == NULL)
 276                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 277
 278         return CONNECTION_ERROR_NONE;
 279 }
 280
 281 EXPORT_API int connection_profile_get_name(connection_profile_h profile, char** profile_name)
 282 {
 283         if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
 284                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 285                 return CONNECTION_ERROR_INVALID_PARAMETER;
 286         }
 287
 288         net_profile_info_t *profile_info = profile;
 289
 290         switch (profile_info->profile_type) {
 291         case NET_DEVICE_CELLULAR:
 292                 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
 293                 break;
 294         case NET_DEVICE_WIFI:
 295                 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
 296                 break;
 297         case NET_DEVICE_ETHERNET:
 298                 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName);
 299                 break;
 300         case NET_DEVICE_BLUETOOTH: {
 301                 char *bt_name = strrchr(profile_info->ProfileName, '/');
 302                 if (bt_name == NULL)
 303                         return CONNECTION_ERROR_INVALID_PARAMETER;
 304
 305                 bt_name++;
 306                 *profile_name = g_strdup(bt_name);
 307         } break;
 308         default:
 309                 return CONNECTION_ERROR_INVALID_PARAMETER;
 310         }
 311
 312         if (*profile_name == NULL)
 313                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 314
 315         return CONNECTION_ERROR_NONE;
 316 }
 317
 318 EXPORT_API int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e* type)
 319 {
 320         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 321                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 322                 return CONNECTION_ERROR_INVALID_PARAMETER;
 323         }
 324
 325         net_profile_info_t *profile_info = profile;
 326
 327         switch (profile_info->profile_type) {
 328         case NET_DEVICE_CELLULAR:
 329                 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
 330                 break;
 331         case NET_DEVICE_WIFI:
 332                 *type = CONNECTION_PROFILE_TYPE_WIFI;
 333                 break;
 334         case NET_DEVICE_ETHERNET:
 335                 *type = CONNECTION_PROFILE_TYPE_ETHERNET;
 336                 break;
 337         case NET_DEVICE_BLUETOOTH:
 338                 *type = CONNECTION_PROFILE_TYPE_BT;
 339                 break;
 340         default:
 341                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type\n");
 342                 return CONNECTION_ERROR_OPERATION_FAILED;
 343         }
 344
 345         return CONNECTION_ERROR_NONE;
 346 }
 347
 348 EXPORT_API int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
 349 {
 350         if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
 351                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 352                 return CONNECTION_ERROR_INVALID_PARAMETER;
 353         }
 354
 355         net_profile_info_t *profile_info = profile;
 356         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 357         if (net_info == NULL)
 358                 return CONNECTION_ERROR_INVALID_PARAMETER;
 359
 360         *interface_name = g_strdup(net_info->DevName);
 361         if (*interface_name == NULL)
 362                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 363
 364         return CONNECTION_ERROR_NONE;
 365 }
 366
 367 EXPORT_API int connection_profile_refresh(connection_profile_h profile)
 368 {
 369         int rv;
 370         if (!(_connection_libnet_check_profile_validity(profile))) {
 371                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 372                 return CONNECTION_ERROR_INVALID_PARAMETER;
 373         }
 374
 375         net_profile_info_t profile_info_local;
 376         net_profile_info_t *profile_info = profile;
 377
 378         rv = net_get_profile_info(profile_info->ProfileName, &profile_info_local);
 379         if (rv == NET_ERR_ACCESS_DENIED) {
 380                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 381                 return CONNECTION_ERROR_PERMISSION_DENIED;
 382         } else if (rv != NET_ERR_NONE) {
 383                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get profile information");
 384                 return CONNECTION_ERROR_OPERATION_FAILED;
 385         }
 386
 387         memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
 388
 389         return CONNECTION_ERROR_NONE;
 390 }
 391
 392 EXPORT_API int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
 393 {
 394         if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
 395                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 396                 return CONNECTION_ERROR_INVALID_PARAMETER;
 397         }
 398
 399         net_profile_info_t *profile_info = profile;
 400         *state = _profile_convert_to_cp_state(profile_info->ProfileState);
 401         if (*state < 0)
 402                 return CONNECTION_ERROR_OPERATION_FAILED;
 403
 404         return CONNECTION_ERROR_NONE;
 405 }
 406
 407 EXPORT_API int connection_profile_get_ip_config_type(connection_profile_h profile,
 408                 connection_address_family_e address_family, connection_ip_config_type_e* type)
 409 {
 410         if (!(_connection_libnet_check_profile_validity(profile)) ||
 411             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 412              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 413             type == NULL) {
 414                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 415                 return CONNECTION_ERROR_INVALID_PARAMETER;
 416         }
 417
 418         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 419                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 420
 421         net_profile_info_t *profile_info = profile;
 422         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 423         if (net_info == NULL)
 424                 return CONNECTION_ERROR_OPERATION_FAILED;
 425
 426         switch (net_info->IpConfigType) {
 427         case NET_IP_CONFIG_TYPE_STATIC:
 428                 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
 429                 break;
 430         case NET_IP_CONFIG_TYPE_DYNAMIC:
 431                 *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
 432                 break;
 433         case NET_IP_CONFIG_TYPE_AUTO_IP:
 434                 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 435                 break;
 436         case NET_IP_CONFIG_TYPE_FIXED:
 437                 *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
 438                 break;
 439         case NET_IP_CONFIG_TYPE_OFF:
 440                 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 441                 break;
 442         default:
 443                 return CONNECTION_ERROR_OPERATION_FAILED;
 444         }
 445
 446         return CONNECTION_ERROR_NONE;
 447 }
 448
 449 EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
 450                 connection_address_family_e address_family, char** ip_address)
 451 {
 452         if (!(_connection_libnet_check_profile_validity(profile)) ||
 453             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 454              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 455             ip_address == NULL) {
 456                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 457                 return CONNECTION_ERROR_INVALID_PARAMETER;
 458         }
 459
 460         net_profile_info_t *profile_info = profile;
 461         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 462         if (net_info == NULL)
 463                 return CONNECTION_ERROR_OPERATION_FAILED;
 464
 465         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 466                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 467
 468         *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr);
 469         if (*ip_address == NULL)
 470                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 471
 472         return CONNECTION_ERROR_NONE;
 473 }
 474
 475 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
 476                 connection_address_family_e address_family, char** subnet_mask)
 477 {
 478         if (!(_connection_libnet_check_profile_validity(profile)) ||
 479             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 480              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 481             subnet_mask == NULL) {
 482                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 483                 return CONNECTION_ERROR_INVALID_PARAMETER;
 484         }
 485
 486         net_profile_info_t *profile_info = profile;
 487         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 488         if (net_info == NULL)
 489                 return CONNECTION_ERROR_OPERATION_FAILED;
 490
 491         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 492                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 493
 494         *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask);
 495         if (*subnet_mask == NULL)
 496                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 497
 498         return CONNECTION_ERROR_NONE;
 499 }
 500
 501 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
 502                 connection_address_family_e address_family, char** gateway_address)
 503 {
 504         if (!(_connection_libnet_check_profile_validity(profile)) ||
 505             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 506              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 507             gateway_address == NULL) {
 508                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 509                 return CONNECTION_ERROR_INVALID_PARAMETER;
 510         }
 511
 512         net_profile_info_t *profile_info = profile;
 513         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 514         if (net_info == NULL)
 515                 return CONNECTION_ERROR_OPERATION_FAILED;
 516
 517         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 518                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 519
 520         *gateway_address = __profile_convert_ip_to_string(&net_info->GatewayAddr);
 521         if (*gateway_address == NULL)
 522                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 523
 524         return CONNECTION_ERROR_NONE;
 525 }
 526
 527 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
 528                 connection_address_family_e address_family, char** dns_address)
 529 {
 530         if (!(_connection_libnet_check_profile_validity(profile)) ||
 531             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 532              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 533             dns_address == NULL ||
 534             order <= 0 ||
 535             order > NET_DNS_ADDR_MAX) {
 536                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 537                 return CONNECTION_ERROR_INVALID_PARAMETER;
 538         }
 539
 540         net_profile_info_t *profile_info = profile;
 541         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 542         if (net_info == NULL)
 543                 return CONNECTION_ERROR_OPERATION_FAILED;
 544
 545         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 546                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 547
 548         *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1]);
 549         if (*dns_address == NULL)
 550                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 551
 552         return CONNECTION_ERROR_NONE;
 553 }
 554
 555 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e* type)
 556 {
 557         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 558                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 559                 return CONNECTION_ERROR_INVALID_PARAMETER;
 560         }
 561
 562         const char *proxy;
 563         net_profile_info_t *profile_info = profile;
 564         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 565         if (net_info == NULL)
 566                 return CONNECTION_ERROR_OPERATION_FAILED;
 567
 568         if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
 569                 proxy = __profile_get_ethernet_proxy();
 570                 if (proxy == NULL)
 571                         *type = CONNECTION_PROXY_TYPE_DIRECT;
 572                 else
 573                         *type = CONNECTION_PROXY_TYPE_MANUAL;
 574
 575                 return CONNECTION_ERROR_NONE;
 576         }
 577
 578         switch (net_info->ProxyMethod) {
 579         case NET_PROXY_TYPE_DIRECT:
 580                 *type = CONNECTION_PROXY_TYPE_DIRECT;
 581                 break;
 582         case NET_PROXY_TYPE_AUTO:
 583                 *type = CONNECTION_PROXY_TYPE_AUTO;
 584                 break;
 585         case NET_PROXY_TYPE_MANUAL:
 586                 *type = CONNECTION_PROXY_TYPE_MANUAL;
 587                 break;
 588         case NET_PROXY_TYPE_UNKNOWN:
 589         default:
 590                 return CONNECTION_ERROR_OPERATION_FAILED;
 591         }
 592
 593         return CONNECTION_ERROR_NONE;
 594 }
 595
 596 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
 597                 connection_address_family_e address_family, char** proxy_address)
 598 {
 599         if (!(_connection_libnet_check_profile_validity(profile)) ||
 600             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 601              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 602              proxy_address == NULL) {
 603                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 604                 return CONNECTION_ERROR_INVALID_PARAMETER;
 605         }
 606
 607         const char *proxy;
 608         net_profile_info_t *profile_info = profile;
 609         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 610         if (net_info == NULL)
 611                 return CONNECTION_ERROR_OPERATION_FAILED;
 612
 613         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 614                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 615
 616         if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
 617                 proxy = __profile_get_ethernet_proxy();
 618                 if (proxy == NULL)
 619                         return CONNECTION_ERROR_OPERATION_FAILED;
 620
 621                 *proxy_address = g_strdup(proxy);
 622         } else
 623                 *proxy_address = g_strdup(net_info->ProxyAddr);
 624
 625         if (*proxy_address == NULL)
 626                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 627
 628         return CONNECTION_ERROR_NONE;
 629 }
 630
 631 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
 632                 connection_address_family_e address_family, connection_ip_config_type_e type)
 633 {
 634         if (!(_connection_libnet_check_profile_validity(profile)) ||
 635             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 636              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 637                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 638                 return CONNECTION_ERROR_INVALID_PARAMETER;
 639         }
 640
 641         net_profile_info_t *profile_info = profile;
 642         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 643         if (net_info == NULL)
 644                 return CONNECTION_ERROR_OPERATION_FAILED;
 645
 646         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 647                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 648
 649         switch (type) {
 650         case CONNECTION_IP_CONFIG_TYPE_STATIC:
 651                 net_info->IpConfigType = NET_IP_CONFIG_TYPE_STATIC;
 652                 net_info->IpAddr.Data.Ipv4.s_addr = 0;
 653                 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
 654                 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
 655                 break;
 656         case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
 657                 net_info->IpConfigType = NET_IP_CONFIG_TYPE_DYNAMIC;
 658                 break;
 659         case CONNECTION_IP_CONFIG_TYPE_AUTO:
 660                 net_info->IpConfigType = NET_IP_CONFIG_TYPE_AUTO_IP;
 661                 break;
 662         case CONNECTION_IP_CONFIG_TYPE_FIXED:
 663                 net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
 664                 break;
 665         case CONNECTION_IP_CONFIG_TYPE_NONE:
 666                 net_info->IpConfigType = NET_IP_CONFIG_TYPE_OFF;
 667                 break;
 668         default:
 669                 return CONNECTION_ERROR_INVALID_PARAMETER;
 670         }
 671
 672         return CONNECTION_ERROR_NONE;
 673 }
 674
 675 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
 676                 connection_address_family_e address_family, const char* ip_address)
 677 {
 678         if (!(_connection_libnet_check_profile_validity(profile)) ||
 679             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 680              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 681                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 682                 return CONNECTION_ERROR_INVALID_PARAMETER;
 683         }
 684
 685         net_profile_info_t *profile_info = profile;
 686         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 687         if (net_info == NULL)
 688                 return CONNECTION_ERROR_OPERATION_FAILED;
 689
 690         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 691                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 692
 693         if (ip_address == NULL)
 694                 net_info->IpAddr.Data.Ipv4.s_addr = 0;
 695         else if (inet_aton(ip_address, &(net_info->IpAddr.Data.Ipv4)) == 0)
 696                 return CONNECTION_ERROR_INVALID_PARAMETER;
 697
 698         return CONNECTION_ERROR_NONE;
 699 }
 700
 701 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
 702                 connection_address_family_e address_family, const char* subnet_mask)
 703 {
 704         if (!(_connection_libnet_check_profile_validity(profile)) ||
 705             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 706              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 707                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 708                 return CONNECTION_ERROR_INVALID_PARAMETER;
 709         }
 710
 711         net_profile_info_t *profile_info = profile;
 712         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 713         if (net_info == NULL)
 714                 return CONNECTION_ERROR_OPERATION_FAILED;
 715
 716         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 717                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 718
 719         if (subnet_mask == NULL)
 720                 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
 721         else if (inet_aton(subnet_mask, &(net_info->SubnetMask.Data.Ipv4)) == 0)
 722                 return CONNECTION_ERROR_INVALID_PARAMETER;
 723
 724         return CONNECTION_ERROR_NONE;
 725 }
 726
 727 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
 728                 connection_address_family_e address_family, const char* gateway_address)
 729 {
 730         if (!(_connection_libnet_check_profile_validity(profile)) ||
 731             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 732              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 733                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 734                 return CONNECTION_ERROR_INVALID_PARAMETER;
 735         }
 736
 737         net_profile_info_t *profile_info = profile;
 738         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 739         if (net_info == NULL)
 740                 return CONNECTION_ERROR_OPERATION_FAILED;
 741
 742         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 743                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 744
 745         if (gateway_address == NULL)
 746                 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
 747         else if (inet_aton(gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) == 0)
 748                 return CONNECTION_ERROR_INVALID_PARAMETER;
 749
 750         return CONNECTION_ERROR_NONE;
 751 }
 752
 753 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
 754                 connection_address_family_e address_family, const char* dns_address)
 755 {
 756         if (!(_connection_libnet_check_profile_validity(profile)) ||
 757             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 758              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 759             order <= 0 ||
 760             order > NET_DNS_ADDR_MAX) {
 761                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 762                 return CONNECTION_ERROR_INVALID_PARAMETER;
 763         }
 764
 765         net_profile_info_t *profile_info = profile;
 766         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 767         if (net_info == NULL)
 768                 return CONNECTION_ERROR_OPERATION_FAILED;
 769
 770         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 771                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 772
 773         if (dns_address == NULL)
 774                 net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
 775         else if (inet_aton(dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) == 0)
 776                 return CONNECTION_ERROR_INVALID_PARAMETER;
 777
 778         if (net_info->DnsCount < order)
 779                 net_info->DnsCount = order;
 780
 781         return CONNECTION_ERROR_NONE;
 782 }
 783
 784 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
 785 {
 786         if (!(_connection_libnet_check_profile_validity(profile))) {
 787                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 788                 return CONNECTION_ERROR_INVALID_PARAMETER;
 789         }
 790
 791         net_profile_info_t *profile_info = profile;
 792         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 793         if (net_info == NULL)
 794                 return CONNECTION_ERROR_OPERATION_FAILED;
 795
 796         switch (type) {
 797         case CONNECTION_PROXY_TYPE_DIRECT:
 798                 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
 799                 break;
 800         case CONNECTION_PROXY_TYPE_AUTO:
 801                 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
 802                 break;
 803         case CONNECTION_PROXY_TYPE_MANUAL:
 804                 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
 805                 break;
 806         default:
 807                 return CONNECTION_ERROR_INVALID_PARAMETER;
 808         }
 809
 810         return CONNECTION_ERROR_NONE;
 811 }
 812
 813 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
 814                 connection_address_family_e address_family, const char* proxy_address)
 815 {
 816         if (!(_connection_libnet_check_profile_validity(profile)) ||
 817             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 818              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 819                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 820                 return CONNECTION_ERROR_INVALID_PARAMETER;
 821         }
 822
 823         net_profile_info_t *profile_info = profile;
 824         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 825         if (net_info == NULL)
 826                 return CONNECTION_ERROR_OPERATION_FAILED;
 827
 828         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 829                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 830
 831         if (proxy_address == NULL)
 832                 net_info->ProxyAddr[0] = '\0';
 833         else
 834                 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
 835
 836         return CONNECTION_ERROR_NONE;
 837 }
 838
 839 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
 840                 connection_profile_state_changed_cb callback, void* user_data)
 841 {
 842         if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
 843                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 844                 return CONNECTION_ERROR_INVALID_PARAMETER;
 845         }
 846
 847         if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
 848                 return CONNECTION_ERROR_NONE;
 849
 850         return CONNECTION_ERROR_OPERATION_FAILED;
 851 }
 852
 853 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
 854 {
 855         if (!(_connection_libnet_check_profile_cb_validity(profile))) {
 856                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 857                 return CONNECTION_ERROR_INVALID_PARAMETER;
 858         }
 859
 860         if (_connection_libnet_remove_from_profile_cb_list(profile) != true)
 861                 return CONNECTION_ERROR_INVALID_PARAMETER;
 862
 863         return CONNECTION_ERROR_NONE;
 864 }
 865
 866
 867 /* Wi-Fi profile *************************************************************/
 868 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
 869 {
 870         if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
 871                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 872                 return CONNECTION_ERROR_INVALID_PARAMETER;
 873         }
 874
 875         net_profile_info_t *profile_info = profile;
 876
 877         if (profile_info->profile_type != NET_DEVICE_WIFI)
 878                 return CONNECTION_ERROR_INVALID_PARAMETER;
 879
 880         *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
 881         if (*essid == NULL)
 882                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 883
 884         return CONNECTION_ERROR_NONE;
 885 }
 886
 887 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
 888 {
 889         if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
 890                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 891                 return CONNECTION_ERROR_INVALID_PARAMETER;
 892         }
 893
 894         net_profile_info_t *profile_info = profile;
 895
 896         if (profile_info->profile_type != NET_DEVICE_WIFI)
 897                 return CONNECTION_ERROR_INVALID_PARAMETER;
 898
 899         *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
 900         if (*bssid == NULL)
 901                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 902
 903         return CONNECTION_ERROR_NONE;
 904 }
 905
 906 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
 907 {
 908         if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
 909                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 910                 return CONNECTION_ERROR_INVALID_PARAMETER;
 911         }
 912
 913         net_profile_info_t *profile_info = profile;
 914
 915         if (profile_info->profile_type != NET_DEVICE_WIFI)
 916                 return CONNECTION_ERROR_INVALID_PARAMETER;
 917
 918         *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
 919
 920         return CONNECTION_ERROR_NONE;
 921 }
 922
 923 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
 924 {
 925         if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
 926                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 927                 return CONNECTION_ERROR_INVALID_PARAMETER;
 928         }
 929
 930         net_profile_info_t *profile_info = profile;
 931
 932         if (profile_info->profile_type != NET_DEVICE_WIFI)
 933                 return CONNECTION_ERROR_INVALID_PARAMETER;
 934
 935         *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
 936
 937         return CONNECTION_ERROR_NONE;
 938 }
 939
 940 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
 941 {
 942         if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
 943                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 944                 return CONNECTION_ERROR_INVALID_PARAMETER;
 945         }
 946
 947         net_profile_info_t *profile_info = profile;
 948
 949         if (profile_info->profile_type != NET_DEVICE_WIFI)
 950                 return CONNECTION_ERROR_INVALID_PARAMETER;
 951
 952         *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate;
 953
 954         return CONNECTION_ERROR_NONE;
 955 }
 956
 957 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e* type)
 958 {
 959         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 960                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 961                 return CONNECTION_ERROR_INVALID_PARAMETER;
 962         }
 963
 964         net_profile_info_t *profile_info = profile;
 965
 966         if (profile_info->profile_type != NET_DEVICE_WIFI)
 967                 return CONNECTION_ERROR_INVALID_PARAMETER;
 968
 969         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
 970         case WLAN_SEC_MODE_NONE:
 971                 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
 972                 break;
 973         case WLAN_SEC_MODE_WEP:
 974                 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
 975                 break;
 976         case WLAN_SEC_MODE_IEEE8021X:
 977                 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
 978                 break;
 979         case WLAN_SEC_MODE_WPA_PSK:
 980                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
 981                 break;
 982         case WLAN_SEC_MODE_WPA2_PSK:
 983                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
 984                 break;
 985         default:
 986                 return CONNECTION_ERROR_OPERATION_FAILED;
 987         }
 988
 989         return CONNECTION_ERROR_NONE;
 990 }
 991
 992 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e* type)
 993 {
 994         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 995                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 996                 return CONNECTION_ERROR_INVALID_PARAMETER;
 997         }
 998
 999         net_profile_info_t *profile_info = profile;
1000
1001         if (profile_info->profile_type != NET_DEVICE_WIFI)
1002                 return CONNECTION_ERROR_INVALID_PARAMETER;
1003
1004         switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1005         case WLAN_ENC_MODE_NONE:
1006                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1007                 break;
1008         case WLAN_ENC_MODE_WEP:
1009                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1010                 break;
1011         case WLAN_ENC_MODE_TKIP:
1012                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1013                 break;
1014         case WLAN_ENC_MODE_AES:
1015                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1016                 break;
1017         case WLAN_ENC_MODE_TKIP_AES_MIXED:
1018                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1019                 break;
1020         default:
1021                 return CONNECTION_ERROR_OPERATION_FAILED;
1022         }
1023
1024         return CONNECTION_ERROR_NONE;
1025 }
1026
1027 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1028 {
1029         if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1030                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1031                 return CONNECTION_ERROR_INVALID_PARAMETER;
1032         }
1033
1034         net_profile_info_t *profile_info = profile;
1035
1036         if (profile_info->profile_type != NET_DEVICE_WIFI)
1037                 return CONNECTION_ERROR_INVALID_PARAMETER;
1038
1039         if (profile_info->Favourite) {
1040                 *required = false;
1041                 return CONNECTION_ERROR_NONE;
1042         }
1043
1044         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1045         case WLAN_SEC_MODE_NONE:
1046                 *required = false;
1047                 break;
1048         case WLAN_SEC_MODE_WEP:
1049         case WLAN_SEC_MODE_IEEE8021X:
1050         case WLAN_SEC_MODE_WPA_PSK:
1051         case WLAN_SEC_MODE_WPA2_PSK:
1052                 *required = true;
1053                 break;
1054         default:
1055                 return CONNECTION_ERROR_OPERATION_FAILED;
1056         }
1057
1058         return CONNECTION_ERROR_NONE;
1059 }
1060
1061 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1062 {
1063         if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1064                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1065                 return CONNECTION_ERROR_INVALID_PARAMETER;
1066         }
1067
1068         net_profile_info_t *profile_info = profile;
1069
1070         if (profile_info->profile_type != NET_DEVICE_WIFI)
1071                 return CONNECTION_ERROR_INVALID_PARAMETER;
1072
1073         g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1074                                                 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1075
1076         return CONNECTION_ERROR_NONE;
1077 }
1078
1079 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1080 {
1081         if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1082                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1083                 return CONNECTION_ERROR_INVALID_PARAMETER;
1084         }
1085
1086         net_profile_info_t *profile_info = profile;
1087
1088         if (profile_info->profile_type != NET_DEVICE_WIFI)
1089                 return CONNECTION_ERROR_INVALID_PARAMETER;
1090
1091         if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1092                 *supported = true;
1093         else
1094                 *supported = false;
1095
1096         return CONNECTION_ERROR_NONE;
1097 }
1098
1099
1100 /* Cellular profile **********************************************************/
1101 EXPORT_API int connection_profile_get_cellular_network_type(connection_profile_h profile, connection_cellular_network_type_e* type)
1102 {
1103         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1104                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1105                 return CONNECTION_ERROR_INVALID_PARAMETER;
1106         }
1107
1108         int network_type;
1109         net_profile_info_t *profile_info = profile;
1110
1111         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1112                 return CONNECTION_ERROR_INVALID_PARAMETER;
1113
1114         if (vconf_get_int(VCONFKEY_TELEPHONY_SVC_ACT, &network_type)) {
1115                 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed\n");
1116                 return CONNECTION_ERROR_OPERATION_FAILED;
1117         }
1118
1119         CONNECTION_LOG(CONNECTION_INFO, "Cellular network type = %d\n", network_type);
1120
1121         switch (network_type) {
1122         case VCONFKEY_TELEPHONY_SVC_ACT_NONE:
1123                 *type = CONNECTION_CELLULAR_NETWORK_TYPE_UNKNOWN;
1124                 break;
1125         case VCONFKEY_TELEPHONY_SVC_ACT_GPRS:
1126                 *type = CONNECTION_CELLULAR_NETWORK_TYPE_GPRS;
1127                 break;
1128         case VCONFKEY_TELEPHONY_SVC_ACT_EGPRS:
1129                 *type = CONNECTION_CELLULAR_NETWORK_TYPE_EDGE;
1130                 break;
1131         case VCONFKEY_TELEPHONY_SVC_ACT_UMTS:
1132                 *type = CONNECTION_CELLULAR_NETWORK_TYPE_UMTS;
1133                 break;
1134         default:
1135                 return CONNECTION_ERROR_OPERATION_FAILED;
1136         }
1137
1138         return CONNECTION_ERROR_NONE;
1139 }
1140
1141 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1142                                                 connection_cellular_service_type_e* type)
1143 {
1144         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1145                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1146                 return CONNECTION_ERROR_INVALID_PARAMETER;
1147         }
1148
1149         net_profile_info_t *profile_info = profile;
1150
1151         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1152                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type Passed\n");
1153                 return CONNECTION_ERROR_INVALID_PARAMETER;
1154         }
1155
1156         *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1157
1158         if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1159                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed\n");
1160                 return CONNECTION_ERROR_OPERATION_FAILED;
1161         }
1162
1163         return CONNECTION_ERROR_NONE;
1164 }
1165
1166 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1167 {
1168         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1169                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1170                 return CONNECTION_ERROR_INVALID_PARAMETER;
1171         }
1172
1173         net_profile_info_t *profile_info = profile;
1174
1175         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1176                 return CONNECTION_ERROR_INVALID_PARAMETER;
1177
1178         *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1179         if (*apn == NULL)
1180                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1181
1182         return CONNECTION_ERROR_NONE;
1183 }
1184
1185 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1186                 connection_cellular_auth_type_e* type, char** user_name, char** password)
1187 {
1188         if (!(_connection_libnet_check_profile_validity(profile)) ||
1189             type == NULL || user_name == NULL || password == NULL) {
1190                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1191                 return CONNECTION_ERROR_INVALID_PARAMETER;
1192         }
1193
1194         net_profile_info_t *profile_info = profile;
1195
1196         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1197                 return CONNECTION_ERROR_INVALID_PARAMETER;
1198
1199         switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1200         case NET_PDP_AUTH_NONE:
1201                 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1202                 break;
1203         case NET_PDP_AUTH_PAP:
1204                 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1205                 break;
1206         case NET_PDP_AUTH_CHAP:
1207                 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1208                 break;
1209         default:
1210                 return CONNECTION_ERROR_OPERATION_FAILED;
1211         }
1212
1213         *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1214         if (*user_name == NULL)
1215                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1216
1217         *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1218         if (*password == NULL) {
1219                 g_free(*user_name);
1220                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1221         }
1222
1223         return CONNECTION_ERROR_NONE;
1224 }
1225
1226 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1227 {
1228         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1229                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1230                 return CONNECTION_ERROR_INVALID_PARAMETER;
1231         }
1232
1233         net_profile_info_t *profile_info = profile;
1234
1235         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1236                 return CONNECTION_ERROR_INVALID_PARAMETER;
1237
1238         *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1239         if (*home_url == NULL)
1240                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1241
1242         return CONNECTION_ERROR_NONE;
1243 }
1244
1245 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1246 {
1247         if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1248                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1249                 return CONNECTION_ERROR_INVALID_PARAMETER;
1250         }
1251
1252         net_profile_info_t *profile_info = profile;
1253
1254         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1255                 return CONNECTION_ERROR_INVALID_PARAMETER;
1256
1257         if (profile_info->ProfileInfo.Pdp.Roaming)
1258                 *is_roaming = true;
1259         else
1260                 *is_roaming = false;
1261
1262         return CONNECTION_ERROR_NONE;
1263 }
1264
1265 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
1266 {
1267         if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
1268                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1269                 return CONNECTION_ERROR_INVALID_PARAMETER;
1270         }
1271
1272         net_profile_info_t *profile_info = profile;
1273
1274         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1275                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1276                 return CONNECTION_ERROR_INVALID_PARAMETER;
1277         }
1278
1279         if (profile_info->ProfileInfo.Pdp.Hidden)
1280                 *is_hidden = true;
1281         else
1282                 *is_hidden = false;
1283
1284         return CONNECTION_ERROR_NONE;
1285 }
1286
1287 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
1288 {
1289         if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
1290                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1291                 return CONNECTION_ERROR_INVALID_PARAMETER;
1292         }
1293
1294         net_profile_info_t *profile_info = profile;
1295
1296         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1297                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1298                 return CONNECTION_ERROR_INVALID_PARAMETER;
1299         }
1300
1301         if (profile_info->ProfileInfo.Pdp.Editable)
1302                 *is_editable = true;
1303         else
1304                 *is_editable = false;
1305
1306         return CONNECTION_ERROR_NONE;
1307 }
1308
1309 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
1310 {
1311         if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
1312                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1313                 return CONNECTION_ERROR_INVALID_PARAMETER;
1314         }
1315
1316         net_profile_info_t *profile_info = profile;
1317
1318         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1319                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1320                 return CONNECTION_ERROR_INVALID_PARAMETER;
1321         }
1322
1323         if (profile_info->ProfileInfo.Pdp.DefaultConn)
1324                 *is_default = true;
1325         else
1326                 *is_default = false;
1327
1328         return CONNECTION_ERROR_NONE;
1329 }
1330
1331 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
1332                 connection_cellular_service_type_e service_type)
1333 {
1334         if (!(_connection_libnet_check_profile_validity(profile))) {
1335                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1336                 return CONNECTION_ERROR_INVALID_PARAMETER;
1337         }
1338
1339         net_profile_info_t *profile_info = profile;
1340
1341         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1342                 return CONNECTION_ERROR_INVALID_PARAMETER;
1343
1344         switch (service_type) {
1345         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1346                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1347                 break;
1348         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1349                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1350                 break;
1351         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1352                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1353                 break;
1354         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1355                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1356                 break;
1357         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1358                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1359                 break;
1360         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1361                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1362                 break;
1363         case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1364         default:
1365                 return CONNECTION_ERROR_INVALID_PARAMETER;
1366         }
1367
1368         return CONNECTION_ERROR_NONE;
1369 }
1370
1371 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1372 {
1373         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1374                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1375                 return CONNECTION_ERROR_INVALID_PARAMETER;
1376         }
1377
1378         net_profile_info_t *profile_info = profile;
1379
1380         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1381                 return CONNECTION_ERROR_INVALID_PARAMETER;
1382
1383         g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1384
1385         return CONNECTION_ERROR_NONE;
1386 }
1387
1388 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
1389                 connection_cellular_auth_type_e type, const char* user_name, const char* password)
1390 {
1391         if (!(_connection_libnet_check_profile_validity(profile)) ||
1392             user_name == NULL || password == NULL) {
1393                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1394                 return CONNECTION_ERROR_INVALID_PARAMETER;
1395         }
1396
1397         net_profile_info_t *profile_info = profile;
1398
1399         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1400                 return CONNECTION_ERROR_INVALID_PARAMETER;
1401
1402         switch (type) {
1403         case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1404                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1405                 break;
1406         case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1407                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1408                 break;
1409         case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1410                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1411                 break;
1412         default:
1413                 return CONNECTION_ERROR_INVALID_PARAMETER;
1414         }
1415
1416         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
1417         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
1418
1419         return CONNECTION_ERROR_NONE;
1420 }
1421
1422 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1423 {
1424         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1425                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1426                 return CONNECTION_ERROR_INVALID_PARAMETER;
1427         }
1428
1429         net_profile_info_t *profile_info = profile;
1430
1431         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1432                 return CONNECTION_ERROR_INVALID_PARAMETER;
1433
1434         g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1435
1436         return CONNECTION_ERROR_NONE;
1437 }