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