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
 452         return CONNECTION_ERROR_NONE;
 453 }
 454
 455 EXPORT_API int connection_profile_get_ip_config_type(connection_profile_h profile,
 456                 connection_address_family_e address_family, connection_ip_config_type_e* type)
 457 {
 458         net_ip_config_type_t profile_type;
 459
 460         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 461
 462         if (!(_connection_libnet_check_profile_validity(profile)) ||
 463             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 464              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 465             type == NULL) {
 466                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 467                 return CONNECTION_ERROR_INVALID_PARAMETER;
 468         }
 469
 470         net_profile_info_t *profile_info = profile;
 471         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 472         if (net_info == NULL)
 473                 return CONNECTION_ERROR_OPERATION_FAILED;
 474
 475         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 476                 profile_type = net_info->IpConfigType;
 477         else
 478                 profile_type = net_info->IpConfigType6;
 479
 480         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
 481                 switch (profile_type) {
 482                 case NET_IP_CONFIG_TYPE_STATIC:
 483                         *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
 484                         break;
 485
 486                 case NET_IP_CONFIG_TYPE_DYNAMIC:
 487                         *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
 488                         break;
 489
 490                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 491                         *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 492                         break;
 493
 494                 case NET_IP_CONFIG_TYPE_FIXED:
 495                         *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
 496                         break;
 497
 498                 case NET_IP_CONFIG_TYPE_OFF:
 499                         *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 500                         break;
 501                 default:
 502                         return CONNECTION_ERROR_OPERATION_FAILED;
 503                 }
 504         } else {
 505                 switch (profile_type) {
 506                 case NET_IP_CONFIG_TYPE_STATIC:
 507                         *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
 508                         break;
 509
 510                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 511                         *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 512                         break;
 513
 514                 case NET_IP_CONFIG_TYPE_OFF:
 515                         *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 516                         break;
 517
 518                 default:
 519                         return  CONNECTION_ERROR_OPERATION_FAILED;
 520
 521                 }
 522         }
 523
 524         return CONNECTION_ERROR_NONE;
 525 }
 526
 527 EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
 528                 connection_address_family_e address_family, char** ip_address)
 529 {
 530         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 531
 532         if (!(_connection_libnet_check_profile_validity(profile)) ||
 533             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 534              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 535             ip_address == NULL) {
 536                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 537                 return CONNECTION_ERROR_INVALID_PARAMETER;
 538         }
 539
 540         net_profile_info_t *profile_info = profile;
 541         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 542         if (net_info == NULL)
 543                 return CONNECTION_ERROR_OPERATION_FAILED;
 544
 545         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 546                 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr6,
 547                                 address_family);
 548         else
 549                 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
 550                                 address_family);
 551
 552         if (*ip_address == NULL)
 553                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 554
 555         return CONNECTION_ERROR_NONE;
 556 }
 557
 558 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
 559                 connection_address_family_e address_family, char** subnet_mask)
 560 {
 561         char* prefixlen;
 562
 563         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 564
 565         if (!(_connection_libnet_check_profile_validity(profile)) ||
 566             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 567              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 568             subnet_mask == NULL) {
 569                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 570                 return CONNECTION_ERROR_INVALID_PARAMETER;
 571         }
 572
 573         net_profile_info_t *profile_info = profile;
 574         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 575         if (net_info == NULL)
 576                 return CONNECTION_ERROR_OPERATION_FAILED;
 577
 578         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 579                 prefixlen = g_try_malloc0(MAX_PREFIX_LENGTH);
 580                 if (prefixlen != NULL) {
 581                         snprintf(prefixlen, MAX_PREFIX_LENGTH, "%d", net_info->PrefixLen6);
 582                         *subnet_mask = prefixlen;
 583                 } else
 584                         *subnet_mask = NULL;
 585         } else
 586                 *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask,
 587                                 address_family);
 588
 589         if (*subnet_mask == NULL)
 590                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 591
 592         return CONNECTION_ERROR_NONE;
 593 }
 594
 595 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
 596                 connection_address_family_e address_family, char** gateway_address)
 597 {
 598         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 599
 600         if (!(_connection_libnet_check_profile_validity(profile)) ||
 601             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 602              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 603             gateway_address == NULL) {
 604                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 605                 return CONNECTION_ERROR_INVALID_PARAMETER;
 606         }
 607
 608         net_profile_info_t *profile_info = profile;
 609         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 610         if (net_info == NULL)
 611                 return CONNECTION_ERROR_OPERATION_FAILED;
 612
 613         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 614                 *gateway_address = __profile_convert_ip_to_string(
 615                                         &net_info->GatewayAddr6, address_family);
 616         else
 617                 *gateway_address = __profile_convert_ip_to_string(
 618                                         &net_info->GatewayAddr, address_family);
 619
 620         if (*gateway_address == NULL)
 621                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 622
 623         return CONNECTION_ERROR_NONE;
 624 }
 625
 626 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
 627                 connection_address_family_e address_family, char** dns_address)
 628 {
 629         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 630
 631         if (!(_connection_libnet_check_profile_validity(profile)) ||
 632             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 633              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 634             dns_address == NULL ||
 635             order <= 0 ||
 636             order > NET_DNS_ADDR_MAX) {
 637                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 638                 return CONNECTION_ERROR_INVALID_PARAMETER;
 639         }
 640
 641         net_profile_info_t *profile_info = profile;
 642         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 643         if (net_info == NULL)
 644                 return CONNECTION_ERROR_OPERATION_FAILED;
 645
 646         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 647                 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
 648                                 address_family);
 649         else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 650                 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1],
 651                                 address_family);
 652         else
 653                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid address family\n");
 654
 655         if (*dns_address == NULL)
 656                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 657
 658         return CONNECTION_ERROR_NONE;
 659 }
 660
 661 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e* type)
 662 {
 663         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 664
 665         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 666                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 667                 return CONNECTION_ERROR_INVALID_PARAMETER;
 668         }
 669
 670         const char *proxy;
 671         net_profile_info_t *profile_info = profile;
 672         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 673         if (net_info == NULL)
 674                 return CONNECTION_ERROR_OPERATION_FAILED;
 675
 676         if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
 677                 proxy = __profile_get_ethernet_proxy();
 678                 if (proxy == NULL)
 679                         *type = CONNECTION_PROXY_TYPE_DIRECT;
 680                 else
 681                         *type = CONNECTION_PROXY_TYPE_MANUAL;
 682
 683                 return CONNECTION_ERROR_NONE;
 684         }
 685
 686         switch (net_info->ProxyMethod) {
 687         case NET_PROXY_TYPE_DIRECT:
 688                 *type = CONNECTION_PROXY_TYPE_DIRECT;
 689                 break;
 690         case NET_PROXY_TYPE_AUTO:
 691                 *type = CONNECTION_PROXY_TYPE_AUTO;
 692                 break;
 693         case NET_PROXY_TYPE_MANUAL:
 694                 *type = CONNECTION_PROXY_TYPE_MANUAL;
 695                 break;
 696         case NET_PROXY_TYPE_UNKNOWN:
 697         default:
 698                 return CONNECTION_ERROR_OPERATION_FAILED;
 699         }
 700
 701         return CONNECTION_ERROR_NONE;
 702 }
 703
 704 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
 705                 connection_address_family_e address_family, char** proxy_address)
 706 {
 707         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 708
 709         if (!(_connection_libnet_check_profile_validity(profile)) ||
 710             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 711              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 712              proxy_address == NULL) {
 713                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 714                 return CONNECTION_ERROR_INVALID_PARAMETER;
 715         }
 716
 717         net_profile_info_t *profile_info = profile;
 718         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 719         if (net_info == NULL)
 720                 return CONNECTION_ERROR_OPERATION_FAILED;
 721
 722         *proxy_address = g_strdup(net_info->ProxyAddr);
 723
 724         if (*proxy_address == NULL)
 725                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 726
 727         return CONNECTION_ERROR_NONE;
 728 }
 729
 730 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
 731                 connection_address_family_e address_family, connection_ip_config_type_e type)
 732 {
 733         net_ip_config_type_t *profile_type = NULL;
 734
 735         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 736
 737         if (!(_connection_libnet_check_profile_validity(profile)) ||
 738             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 739              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 740                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 741                 return CONNECTION_ERROR_INVALID_PARAMETER;
 742         }
 743
 744         net_profile_info_t *profile_info = profile;
 745         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 746         if (net_info == NULL)
 747                 return CONNECTION_ERROR_OPERATION_FAILED;
 748
 749         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 750                 profile_type = &net_info->IpConfigType ;
 751         else
 752                 profile_type = &net_info->IpConfigType6 ;
 753
 754         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
 755                 switch (type) {
 756                 case CONNECTION_IP_CONFIG_TYPE_STATIC:
 757                         *profile_type = NET_IP_CONFIG_TYPE_STATIC;
 758                         net_info->IpAddr.Data.Ipv4.s_addr = 0;
 759                         net_info->SubnetMask.Data.Ipv4.s_addr = 0;
 760                         net_info->GatewayAddr.Data.Ipv4.s_addr = 0 ;
 761                         break;
 762
 763                 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
 764                         *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
 765                         break;
 766
 767                 case CONNECTION_IP_CONFIG_TYPE_AUTO:
 768                         *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
 769                         break;
 770
 771                 case CONNECTION_IP_CONFIG_TYPE_FIXED:
 772                         net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
 773                         break;
 774
 775                 case CONNECTION_IP_CONFIG_TYPE_NONE:
 776                         *profile_type = NET_IP_CONFIG_TYPE_OFF;
 777                         break;
 778
 779                 default:
 780                         return CONNECTION_ERROR_INVALID_PARAMETER;
 781                 }
 782         } else {
 783                 switch (type) {
 784                 case CONNECTION_IP_CONFIG_TYPE_STATIC:
 785                         *profile_type = NET_IP_CONFIG_TYPE_STATIC;
 786                         inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
 787                         net_info->PrefixLen6 = 0 ;
 788                         inet_pton(AF_INET6, "::",
 789                                         &net_info->GatewayAddr6.Data.Ipv6);
 790                         break;
 791
 792                 case CONNECTION_IP_CONFIG_TYPE_AUTO:
 793                         *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
 794                         break;
 795
 796                 case CONNECTION_IP_CONFIG_TYPE_NONE:
 797                         *profile_type = NET_IP_CONFIG_TYPE_OFF;
 798                         break;
 799
 800                 default:
 801                         return CONNECTION_ERROR_INVALID_PARAMETER;
 802                 }
 803         }
 804
 805         return CONNECTION_ERROR_NONE;
 806 }
 807
 808 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
 809                 connection_address_family_e address_family, const char* ip_address)
 810 {
 811         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 812
 813         if (!(_connection_libnet_check_profile_validity(profile)) ||
 814             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 815              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 816                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 817                 return CONNECTION_ERROR_INVALID_PARAMETER;
 818         }
 819
 820         net_profile_info_t *profile_info = profile;
 821         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 822         if (net_info == NULL)
 823                 return CONNECTION_ERROR_OPERATION_FAILED;
 824
 825         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 826                 if (ip_address == NULL)
 827                         inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
 828                 else if (inet_pton(AF_INET6, ip_address,
 829                                         &net_info->IpAddr6.Data.Ipv6) < 1)
 830                         return CONNECTION_ERROR_INVALID_PARAMETER;
 831         } else {
 832                 if (ip_address == NULL)
 833                         net_info->IpAddr.Data.Ipv4.s_addr = 0;
 834                 else if (inet_pton(AF_INET, ip_address,
 835                                         &net_info->IpAddr.Data.Ipv4) < 1)
 836                         return CONNECTION_ERROR_INVALID_PARAMETER;
 837         }
 838
 839         return CONNECTION_ERROR_NONE;
 840 }
 841
 842 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
 843                 connection_address_family_e address_family, const char* subnet_mask)
 844 {
 845         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 846
 847         if (!(_connection_libnet_check_profile_validity(profile)) ||
 848             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 849              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 850                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 851                 return CONNECTION_ERROR_INVALID_PARAMETER;
 852         }
 853
 854         net_profile_info_t *profile_info = profile;
 855         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 856         if (net_info == NULL)
 857                 return CONNECTION_ERROR_OPERATION_FAILED;
 858
 859         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 860                 if (subnet_mask == NULL)
 861                         net_info->PrefixLen6 = 0 ;
 862                 else
 863                         net_info->PrefixLen6 = atoi(subnet_mask) ;
 864         } else {
 865                 if (subnet_mask == NULL)
 866                         net_info->SubnetMask.Data.Ipv4.s_addr = 0;
 867                 else if (inet_pton(AF_INET, subnet_mask , &net_info->SubnetMask.Data.Ipv4)  < 1)
 868                         return CONNECTION_ERROR_INVALID_PARAMETER;
 869         }
 870
 871         return CONNECTION_ERROR_NONE;
 872 }
 873
 874 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
 875                 connection_address_family_e address_family, const char* gateway_address)
 876 {
 877         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 878
 879         if (!(_connection_libnet_check_profile_validity(profile)) ||
 880             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 881              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 882                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 883                 return CONNECTION_ERROR_INVALID_PARAMETER;
 884         }
 885
 886         net_profile_info_t *profile_info = profile;
 887         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 888         if (net_info == NULL)
 889                 return CONNECTION_ERROR_OPERATION_FAILED;
 890
 891         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 892                 if (gateway_address == NULL)
 893                         inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6);
 894                 else if (inet_pton(AF_INET6, gateway_address, &net_info->GatewayAddr6.Data.Ipv6) < 1)
 895                         return CONNECTION_ERROR_INVALID_PARAMETER;
 896         } else {
 897                 if (gateway_address == NULL)
 898                         net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
 899                 else if (inet_pton(AF_INET, gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) < 1)
 900                         return CONNECTION_ERROR_INVALID_PARAMETER;
 901         }
 902
 903         return CONNECTION_ERROR_NONE;
 904 }
 905
 906 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
 907                 connection_address_family_e address_family, const char* dns_address)
 908 {
 909         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 910
 911         if (!(_connection_libnet_check_profile_validity(profile)) ||
 912             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 913              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 914             order <= 0 ||
 915             order > NET_DNS_ADDR_MAX) {
 916                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 917                 return CONNECTION_ERROR_INVALID_PARAMETER;
 918         }
 919
 920         net_profile_info_t *profile_info = profile;
 921         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 922         if (net_info == NULL)
 923                 return CONNECTION_ERROR_OPERATION_FAILED;
 924
 925         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 926                 net_info->DnsAddr6[order-1].Type = NET_ADDR_IPV6;
 927                 if (dns_address == NULL)
 928                         inet_pton(AF_INET6, "::", &net_info->DnsAddr6[order-1].Data.Ipv6);
 929                 else if (inet_pton(AF_INET6, dns_address, &net_info->DnsAddr6[order-1].Data.Ipv6) < 1)
 930                         return CONNECTION_ERROR_INVALID_PARAMETER;
 931                 if (net_info->DnsCount6 < order)
 932                         net_info->DnsCount6 = order;
 933         } else {
 934                 net_info->DnsAddr[order-1].Type = NET_ADDR_IPV4;
 935                 if (dns_address == NULL)
 936                         net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
 937                 else if (inet_pton(AF_INET, dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) < 1)
 938                         return CONNECTION_ERROR_INVALID_PARAMETER;
 939                 if (net_info->DnsCount < order)
 940                         net_info->DnsCount = order;
 941         }
 942
 943         return CONNECTION_ERROR_NONE;
 944 }
 945
 946 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
 947 {
 948         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 949
 950         if (!(_connection_libnet_check_profile_validity(profile))) {
 951                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 952                 return CONNECTION_ERROR_INVALID_PARAMETER;
 953         }
 954
 955         net_profile_info_t *profile_info = profile;
 956         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 957         if (net_info == NULL)
 958                 return CONNECTION_ERROR_OPERATION_FAILED;
 959
 960         switch (type) {
 961         case CONNECTION_PROXY_TYPE_DIRECT:
 962                 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
 963                 break;
 964         case CONNECTION_PROXY_TYPE_AUTO:
 965                 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
 966                 break;
 967         case CONNECTION_PROXY_TYPE_MANUAL:
 968                 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
 969                 break;
 970         default:
 971                 return CONNECTION_ERROR_INVALID_PARAMETER;
 972         }
 973
 974         return CONNECTION_ERROR_NONE;
 975 }
 976
 977 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
 978                 connection_address_family_e address_family, const char* proxy_address)
 979 {
 980         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 981
 982         if (!(_connection_libnet_check_profile_validity(profile)) ||
 983             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 984              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 985                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 986                 return CONNECTION_ERROR_INVALID_PARAMETER;
 987         }
 988
 989         net_profile_info_t *profile_info = profile;
 990         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 991         if (net_info == NULL)
 992                 return CONNECTION_ERROR_OPERATION_FAILED;
 993
 994         if (proxy_address == NULL)
 995                 net_info->ProxyAddr[0] = '\0';
 996         else
 997                 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
 998
 999         return CONNECTION_ERROR_NONE;
1000 }
1001
1002 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
1003                 connection_profile_state_changed_cb callback, void* user_data)
1004 {
1005         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1006
1007         if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
1008                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1009                 return CONNECTION_ERROR_INVALID_PARAMETER;
1010         }
1011
1012         if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
1013                 return CONNECTION_ERROR_NONE;
1014
1015         return CONNECTION_ERROR_OPERATION_FAILED;
1016 }
1017
1018 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
1019 {
1020         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1021
1022         if (!(_connection_libnet_check_profile_validity(profile))) {
1023                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1024                 return CONNECTION_ERROR_INVALID_PARAMETER;
1025         }
1026
1027         if (_connection_libnet_remove_from_profile_cb_list(profile) != true)
1028                 return CONNECTION_ERROR_INVALID_PARAMETER;
1029
1030         return CONNECTION_ERROR_NONE;
1031 }
1032
1033
1034 /* Wi-Fi profile *************************************************************/
1035 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
1036 {
1037         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1038
1039         if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
1040                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1041                 return CONNECTION_ERROR_INVALID_PARAMETER;
1042         }
1043
1044         net_profile_info_t *profile_info = profile;
1045
1046         if (profile_info->profile_type != NET_DEVICE_WIFI)
1047                 return CONNECTION_ERROR_INVALID_PARAMETER;
1048
1049         *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
1050         if (*essid == NULL)
1051                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1052
1053         return CONNECTION_ERROR_NONE;
1054 }
1055
1056 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
1057 {
1058         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1059
1060         if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
1061                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1062                 return CONNECTION_ERROR_INVALID_PARAMETER;
1063         }
1064
1065         net_profile_info_t *profile_info = profile;
1066
1067         if (profile_info->profile_type != NET_DEVICE_WIFI)
1068                 return CONNECTION_ERROR_INVALID_PARAMETER;
1069
1070         *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
1071         if (*bssid == NULL)
1072                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1073
1074         return CONNECTION_ERROR_NONE;
1075 }
1076
1077 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
1078 {
1079         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1080
1081         if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
1082                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1083                 return CONNECTION_ERROR_INVALID_PARAMETER;
1084         }
1085
1086         net_profile_info_t *profile_info = profile;
1087
1088         if (profile_info->profile_type != NET_DEVICE_WIFI)
1089                 return CONNECTION_ERROR_INVALID_PARAMETER;
1090
1091         *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
1092
1093         return CONNECTION_ERROR_NONE;
1094 }
1095
1096 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
1097 {
1098         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1099
1100         if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
1101                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1102                 return CONNECTION_ERROR_INVALID_PARAMETER;
1103         }
1104
1105         net_profile_info_t *profile_info = profile;
1106
1107         if (profile_info->profile_type != NET_DEVICE_WIFI)
1108                 return CONNECTION_ERROR_INVALID_PARAMETER;
1109
1110         *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
1111
1112         return CONNECTION_ERROR_NONE;
1113 }
1114
1115 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
1116 {
1117         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1118
1119         if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
1120                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1121                 return CONNECTION_ERROR_INVALID_PARAMETER;
1122         }
1123
1124         net_profile_info_t *profile_info = profile;
1125
1126         if (profile_info->profile_type != NET_DEVICE_WIFI)
1127                 return CONNECTION_ERROR_INVALID_PARAMETER;
1128
1129         *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate;
1130
1131         return CONNECTION_ERROR_NONE;
1132 }
1133
1134 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e* type)
1135 {
1136         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1137
1138         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1139                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1140                 return CONNECTION_ERROR_INVALID_PARAMETER;
1141         }
1142
1143         net_profile_info_t *profile_info = profile;
1144
1145         if (profile_info->profile_type != NET_DEVICE_WIFI)
1146                 return CONNECTION_ERROR_INVALID_PARAMETER;
1147
1148         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1149         case WLAN_SEC_MODE_NONE:
1150                 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
1151                 break;
1152         case WLAN_SEC_MODE_WEP:
1153                 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
1154                 break;
1155         case WLAN_SEC_MODE_IEEE8021X:
1156                 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
1157                 break;
1158         case WLAN_SEC_MODE_WPA_PSK:
1159                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
1160                 break;
1161         case WLAN_SEC_MODE_WPA2_PSK:
1162                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
1163                 break;
1164         default:
1165                 return CONNECTION_ERROR_OPERATION_FAILED;
1166         }
1167
1168         return CONNECTION_ERROR_NONE;
1169 }
1170
1171 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e* type)
1172 {
1173         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1174
1175         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1176                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1177                 return CONNECTION_ERROR_INVALID_PARAMETER;
1178         }
1179
1180         net_profile_info_t *profile_info = profile;
1181
1182         if (profile_info->profile_type != NET_DEVICE_WIFI)
1183                 return CONNECTION_ERROR_INVALID_PARAMETER;
1184
1185         switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1186         case WLAN_ENC_MODE_NONE:
1187                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1188                 break;
1189         case WLAN_ENC_MODE_WEP:
1190                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1191                 break;
1192         case WLAN_ENC_MODE_TKIP:
1193                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1194                 break;
1195         case WLAN_ENC_MODE_AES:
1196                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1197                 break;
1198         case WLAN_ENC_MODE_TKIP_AES_MIXED:
1199                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1200                 break;
1201         default:
1202                 return CONNECTION_ERROR_OPERATION_FAILED;
1203         }
1204
1205         return CONNECTION_ERROR_NONE;
1206 }
1207
1208 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1209 {
1210         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1211
1212         if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1213                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1214                 return CONNECTION_ERROR_INVALID_PARAMETER;
1215         }
1216
1217         net_profile_info_t *profile_info = profile;
1218
1219         if (profile_info->profile_type != NET_DEVICE_WIFI)
1220                 return CONNECTION_ERROR_INVALID_PARAMETER;
1221
1222         if (profile_info->Favourite) {
1223                 *required = false;
1224                 return CONNECTION_ERROR_NONE;
1225         }
1226
1227         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1228         case WLAN_SEC_MODE_NONE:
1229                 *required = false;
1230                 break;
1231         case WLAN_SEC_MODE_WEP:
1232         case WLAN_SEC_MODE_IEEE8021X:
1233         case WLAN_SEC_MODE_WPA_PSK:
1234         case WLAN_SEC_MODE_WPA2_PSK:
1235                 *required = true;
1236                 break;
1237         default:
1238                 return CONNECTION_ERROR_OPERATION_FAILED;
1239         }
1240
1241         return CONNECTION_ERROR_NONE;
1242 }
1243
1244 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1245 {
1246         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1247
1248         if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1249                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1250                 return CONNECTION_ERROR_INVALID_PARAMETER;
1251         }
1252
1253         net_profile_info_t *profile_info = profile;
1254
1255         if (profile_info->profile_type != NET_DEVICE_WIFI)
1256                 return CONNECTION_ERROR_INVALID_PARAMETER;
1257
1258         g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1259                                                 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1260
1261         return CONNECTION_ERROR_NONE;
1262 }
1263
1264 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1265 {
1266         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1267
1268         if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1269                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1270                 return CONNECTION_ERROR_INVALID_PARAMETER;
1271         }
1272
1273         net_profile_info_t *profile_info = profile;
1274
1275         if (profile_info->profile_type != NET_DEVICE_WIFI)
1276                 return CONNECTION_ERROR_INVALID_PARAMETER;
1277
1278         if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1279                 *supported = true;
1280         else
1281                 *supported = false;
1282
1283         return CONNECTION_ERROR_NONE;
1284 }
1285
1286
1287 /* Cellular profile **********************************************************/
1288 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1289                                                 connection_cellular_service_type_e* type)
1290 {
1291         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1292
1293         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1294                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1295                 return CONNECTION_ERROR_INVALID_PARAMETER;
1296         }
1297
1298         net_profile_info_t *profile_info = profile;
1299
1300         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1301                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1302                 return CONNECTION_ERROR_INVALID_PARAMETER;
1303         }
1304
1305         *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1306
1307         if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1308                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed");
1309                 return CONNECTION_ERROR_OPERATION_FAILED;
1310         }
1311
1312         return CONNECTION_ERROR_NONE;
1313 }
1314
1315 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1316 {
1317         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1318
1319         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1320                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1321                 return CONNECTION_ERROR_INVALID_PARAMETER;
1322         }
1323
1324         net_profile_info_t *profile_info = profile;
1325
1326         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1327                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1328                 return CONNECTION_ERROR_INVALID_PARAMETER;
1329         }
1330
1331         *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1332         if (*apn == NULL)
1333                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1334
1335         return CONNECTION_ERROR_NONE;
1336 }
1337
1338 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1339                 connection_cellular_auth_type_e* type, char** user_name, char** password)
1340 {
1341         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1342
1343         if (!(_connection_libnet_check_profile_validity(profile)) ||
1344             type == NULL || user_name == NULL || password == NULL) {
1345                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1346                 return CONNECTION_ERROR_INVALID_PARAMETER;
1347         }
1348
1349         net_profile_info_t *profile_info = profile;
1350
1351         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1352                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1353                 return CONNECTION_ERROR_INVALID_PARAMETER;
1354         }
1355
1356         switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1357         case NET_PDP_AUTH_NONE:
1358                 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1359                 break;
1360         case NET_PDP_AUTH_PAP:
1361                 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1362                 break;
1363         case NET_PDP_AUTH_CHAP:
1364                 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1365                 break;
1366         default:
1367                 return CONNECTION_ERROR_OPERATION_FAILED;
1368         }
1369
1370         *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1371         if (*user_name == NULL)
1372                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1373
1374         *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1375         if (*password == NULL) {
1376                 g_free(*user_name);
1377                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1378         }
1379
1380         return CONNECTION_ERROR_NONE;
1381 }
1382
1383 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1384 {
1385         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1386
1387         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1388                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1389                 return CONNECTION_ERROR_INVALID_PARAMETER;
1390         }
1391
1392         net_profile_info_t *profile_info = profile;
1393
1394         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1395                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1396                 return CONNECTION_ERROR_INVALID_PARAMETER;
1397         }
1398
1399         *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1400         if (*home_url == NULL)
1401                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1402
1403         return CONNECTION_ERROR_NONE;
1404 }
1405
1406 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1407 {
1408         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1409
1410         if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1411                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
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                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1419                 return CONNECTION_ERROR_INVALID_PARAMETER;
1420         }
1421
1422         if (profile_info->ProfileInfo.Pdp.Roaming)
1423                 *is_roaming = true;
1424         else
1425                 *is_roaming = false;
1426
1427         return CONNECTION_ERROR_NONE;
1428 }
1429
1430 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
1431 {
1432         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1433
1434         if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
1435                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1436                 return CONNECTION_ERROR_INVALID_PARAMETER;
1437         }
1438
1439         net_profile_info_t *profile_info = profile;
1440
1441         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1442                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1443                 return CONNECTION_ERROR_INVALID_PARAMETER;
1444         }
1445
1446         if (profile_info->ProfileInfo.Pdp.Hidden)
1447                 *is_hidden = true;
1448         else
1449                 *is_hidden = false;
1450
1451         return CONNECTION_ERROR_NONE;
1452 }
1453
1454 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
1455 {
1456         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1457
1458         if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
1459                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1460                 return CONNECTION_ERROR_INVALID_PARAMETER;
1461         }
1462
1463         net_profile_info_t *profile_info = profile;
1464
1465         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1466                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1467                 return CONNECTION_ERROR_INVALID_PARAMETER;
1468         }
1469
1470         if (profile_info->ProfileInfo.Pdp.Editable)
1471                 *is_editable = true;
1472         else
1473                 *is_editable = false;
1474
1475         return CONNECTION_ERROR_NONE;
1476 }
1477
1478 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
1479 {
1480         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1481
1482         if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
1483                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1484                 return CONNECTION_ERROR_INVALID_PARAMETER;
1485         }
1486
1487         net_profile_info_t *profile_info = profile;
1488
1489         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1490                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1491                 return CONNECTION_ERROR_INVALID_PARAMETER;
1492         }
1493
1494         if (profile_info->ProfileInfo.Pdp.DefaultConn)
1495                 *is_default = true;
1496         else
1497                 *is_default = false;
1498
1499         return CONNECTION_ERROR_NONE;
1500 }
1501
1502 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
1503                 connection_cellular_service_type_e service_type)
1504 {
1505         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1506
1507         if (!(_connection_libnet_check_profile_validity(profile))) {
1508                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1509                 return CONNECTION_ERROR_INVALID_PARAMETER;
1510         }
1511
1512         net_profile_info_t *profile_info = profile;
1513
1514         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1515                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1516                 return CONNECTION_ERROR_INVALID_PARAMETER;
1517         }
1518
1519         switch (service_type) {
1520         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1521                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1522                 break;
1523         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1524                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1525                 break;
1526         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1527                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1528                 break;
1529         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1530                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1531                 break;
1532         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1533                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1534                 break;
1535         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1536                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1537                 break;
1538         case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1539         default:
1540                 return CONNECTION_ERROR_INVALID_PARAMETER;
1541         }
1542
1543         return CONNECTION_ERROR_NONE;
1544 }
1545
1546 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1547 {
1548         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1549
1550         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1551                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1552                 return CONNECTION_ERROR_INVALID_PARAMETER;
1553         }
1554
1555         net_profile_info_t *profile_info = profile;
1556
1557         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1558                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1559                 return CONNECTION_ERROR_INVALID_PARAMETER;
1560         }
1561
1562         g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1563
1564         return CONNECTION_ERROR_NONE;
1565 }
1566
1567 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
1568                 connection_cellular_auth_type_e type, const char* user_name, const char* password)
1569 {
1570         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1571
1572         if (!(_connection_libnet_check_profile_validity(profile)) ||
1573             user_name == NULL || password == NULL) {
1574                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1575                 return CONNECTION_ERROR_INVALID_PARAMETER;
1576         }
1577
1578         net_profile_info_t *profile_info = profile;
1579
1580         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1581                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1582                 return CONNECTION_ERROR_INVALID_PARAMETER;
1583         }
1584
1585         switch (type) {
1586         case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1587                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1588                 break;
1589         case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1590                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1591                 break;
1592         case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1593                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1594                 break;
1595         default:
1596                 return CONNECTION_ERROR_INVALID_PARAMETER;
1597         }
1598
1599         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
1600         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
1601
1602         return CONNECTION_ERROR_NONE;
1603 }
1604
1605 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1606 {
1607         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1608
1609         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1610                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1611                 return CONNECTION_ERROR_INVALID_PARAMETER;
1612         }
1613
1614         net_profile_info_t *profile_info = profile;
1615
1616         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1617                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1618                 return CONNECTION_ERROR_INVALID_PARAMETER;
1619         }
1620
1621         g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1622
1623         return CONNECTION_ERROR_NONE;
1624 }