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