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