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