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; //LCOV_EXCL_LINE
  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                 //LCOV_EXCL_START
  63                 ipaddr = (unsigned char *)&ip_addr->Data.Ipv6.s6_addr;
  64                 ipstr = g_try_malloc0(INET6_ADDRSTRLEN);
  65                 if (ipstr == NULL)
  66                                 return NULL;
  67
  68                 inet_ntop(AF_INET6, ipaddr, ipstr, INET6_ADDRSTRLEN);
  69                 //LCOV_EXCL_STOP
  70         }
  71
  72         return ipstr;
  73 }
  74
  75 static void __profile_init_cellular_profile(net_profile_info_t *profile_info, const char *keyword)
  76 {
  77         int default_subscriber_id = 0;
  78         connection_profile_h profile = NULL;
  79
  80         profile_info->profile_type = NET_DEVICE_CELLULAR;
  81         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
  82         profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_UNKNOWN;
  83         profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_UNKNOWN;
  84         profile_info->ProfileInfo.Pdp.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
  85         profile_info->ProfileInfo.Pdp.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
  86         g_strlcpy(profile_info->ProfileInfo.Pdp.Keyword, keyword, NET_PDP_APN_LEN_MAX);
  87
  88         if (vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE,
  89                                         &default_subscriber_id) != 0)
  90                 CONNECTION_LOG(CONNECTION_ERROR, //LCOV_EXCL_LINE
  91                                                 "Failed to get VCONF_TELEPHONY_DEFAULT_DATA_SERVICE");
  92
  93         profile = (connection_profile_h)profile_info;
  94         _connection_libnet_set_cellular_subscriber_id(profile, default_subscriber_id);
  95 }
  96
  97 static void __profile_init_wifi_profile(net_profile_info_t *profile_info)
  98 {
  99         profile_info->profile_type = NET_DEVICE_WIFI;
 100         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
 101         profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
 102         profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
 103         profile_info->ProfileInfo.Wlan.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
 104         profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
 105         profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
 106 }
 107
 108 //LCOV_EXCL_START
 109 static char* __profile_get_ethernet_proxy(void)
 110 {
 111         char *proxy;
 112
 113         proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
 114
 115         if (proxy == NULL) {
 116                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get system proxy");
 117                 return NULL;
 118         }
 119
 120         return proxy;
 121 }
 122 //LCOV_EXCL_STOP
 123
 124 static int __profile_convert_netmask_to_prefix_len(const char *netmask)
 125 {
 126         if (netmask == NULL)
 127                 return 0;
 128
 129         in_addr_t mask = inet_network(netmask);
 130         int prefix_len = 0;
 131
 132         for (; mask; mask <<= 1)
 133                 ++prefix_len;
 134
 135         return prefix_len;
 136 }
 137
 138 static in_addr_t __profile_convert_prefix_len_to_netmask(int prefix_len)
 139 {
 140         return (prefix_len ? (in_addr_t) 0xFFFFFFFFu >> (32 - prefix_len) : 0);
 141 }
 142
 143 //LCOV_EXCL_START
 144 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
 145 {
 146         switch (svc_type) {
 147         case NET_SERVICE_INTERNET:
 148                 return CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
 149         case NET_SERVICE_MMS:
 150                 return CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
 151         case NET_SERVICE_PREPAID_INTERNET:
 152                 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
 153         case NET_SERVICE_PREPAID_MMS:
 154                 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
 155         case NET_SERVICE_TETHERING:
 156                 return CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
 157         case NET_SERVICE_APPLICATION:
 158                 return CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
 159         default:
 160                 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
 161         }
 162 }
 163
 164 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
 165 {
 166         connection_profile_state_e cp_state;
 167
 168         switch (state) {
 169         case NET_STATE_TYPE_ONLINE:
 170         case NET_STATE_TYPE_READY:
 171                 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
 172                 break;
 173         case NET_STATE_TYPE_IDLE:
 174         case NET_STATE_TYPE_FAILURE:
 175         case NET_STATE_TYPE_DISCONNECT:
 176                 cp_state = CONNECTION_PROFILE_STATE_DISCONNECTED;
 177                 break;
 178         case NET_STATE_TYPE_ASSOCIATION:
 179                 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
 180                 break;
 181         case NET_STATE_TYPE_CONFIGURATION:
 182                 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
 183                 break;
 184         default:
 185                 cp_state = -1;
 186         }
 187
 188         return cp_state;
 189 }
 190
 191 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
 192 {
 193         switch (svc_type) {
 194         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
 195                 return NET_SERVICE_INTERNET;
 196         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
 197                 return NET_SERVICE_MMS;
 198         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
 199                 return NET_SERVICE_PREPAID_INTERNET;
 200         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
 201                 return NET_SERVICE_PREPAID_MMS;
 202         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
 203                 return NET_SERVICE_TETHERING;
 204         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
 205                 return NET_SERVICE_APPLICATION;
 206         default:
 207                 return NET_SERVICE_UNKNOWN;
 208         }
 209 }
 210
 211 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
 212 {
 213         net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
 214
 215         switch (state) {
 216         case CONNECTION_PROFILE_STATE_CONNECTED:
 217                 libnet_state = NET_STATE_TYPE_ONLINE;
 218                 break;
 219         case CONNECTION_PROFILE_STATE_DISCONNECTED:
 220                 libnet_state = NET_STATE_TYPE_IDLE;
 221                 break;
 222         case CONNECTION_PROFILE_STATE_ASSOCIATION:
 223                 libnet_state = NET_STATE_TYPE_ASSOCIATION;
 224                 break;
 225         case CONNECTION_PROFILE_STATE_CONFIGURATION:
 226                 libnet_state = NET_STATE_TYPE_CONFIGURATION;
 227                 break;
 228         }
 229
 230         return libnet_state;
 231 }
 232 //LCOV_EXCL_STOP
 233
 234 /* Connection profile ********************************************************/
 235 EXPORT_API int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
 236 {
 237         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
 238
 239         if (type == CONNECTION_PROFILE_TYPE_CELLULAR)
 240                 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 241         else if (type == CONNECTION_PROFILE_TYPE_WIFI)
 242                 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 243
 244         if (type != CONNECTION_PROFILE_TYPE_CELLULAR &&
 245              type != CONNECTION_PROFILE_TYPE_WIFI) {
 246                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 247                 return CONNECTION_ERROR_INVALID_PARAMETER;
 248         }
 249
 250         if (profile == NULL) {
 251                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 252                 return CONNECTION_ERROR_INVALID_PARAMETER;
 253         }
 254
 255         int rv  = _connection_libnet_check_profile_privilege();
 256         if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
 257                 return rv;
 258         else if (rv != CONNECTION_ERROR_NONE) {
 259                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create profile"); //LCOV_EXCL_LINE
 260                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 261         }
 262
 263         net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
 264         if (profile_info == NULL)
 265                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 266
 267         switch (type) {
 268         case CONNECTION_PROFILE_TYPE_CELLULAR:
 269                 if (keyword == NULL) {
 270                         CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 271                         g_free(profile_info);
 272                         return CONNECTION_ERROR_INVALID_PARAMETER;
 273                 }
 274                 __profile_init_cellular_profile(profile_info, keyword);
 275                 break;
 276         case CONNECTION_PROFILE_TYPE_WIFI:
 277                 __profile_init_wifi_profile(profile_info);
 278                 break;
 279         default:
 280                 break;
 281         }
 282
 283         *profile = (connection_profile_h)profile_info;
 284         _connection_libnet_add_to_profile_list(*profile);
 285
 286         return CONNECTION_ERROR_NONE;
 287 }
 288
 289 EXPORT_API int connection_profile_destroy(connection_profile_h profile)
 290 {
 291         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 292
 293         if (!(_connection_libnet_check_profile_validity(profile))) {
 294                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 295                 return CONNECTION_ERROR_INVALID_PARAMETER;
 296         }
 297
 298         _connection_libnet_remove_from_profile_list(profile);
 299
 300         return CONNECTION_ERROR_NONE;
 301 }
 302
 303 EXPORT_API int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
 304 {
 305         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 306
 307         if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
 308                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 309                 return CONNECTION_ERROR_INVALID_PARAMETER;
 310         }
 311
 312         *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
 313         if (*cloned_profile == NULL)
 314                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 315
 316         memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
 317         _connection_libnet_add_to_profile_list(*cloned_profile);
 318
 319         return CONNECTION_ERROR_NONE;
 320 }
 321
 322 EXPORT_API int connection_profile_get_id(connection_profile_h profile, char** profile_id)
 323 {
 324         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 325
 326         if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
 327                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 328                 return CONNECTION_ERROR_INVALID_PARAMETER;
 329         }
 330
 331         net_profile_info_t *profile_info = profile;
 332
 333         char *prof_id = strrchr(profile_info->ProfileName, '/');
 334         if (prof_id == NULL)
 335                 return CONNECTION_ERROR_INVALID_PARAMETER;
 336
 337         prof_id++;
 338         *profile_id = g_strdup(prof_id);
 339
 340         if (*profile_id == NULL)
 341                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 342
 343         return CONNECTION_ERROR_NONE;
 344 }
 345
 346 EXPORT_API int connection_profile_get_name(connection_profile_h profile, char** profile_name)
 347 {
 348         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 349
 350         if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
 351                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 352                 return CONNECTION_ERROR_INVALID_PARAMETER;
 353         }
 354
 355         net_profile_info_t *profile_info = profile;
 356
 357         switch (profile_info->profile_type) {
 358         case NET_DEVICE_CELLULAR:
 359                 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
 360                 break;
 361         case NET_DEVICE_WIFI:
 362                 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
 363                 break;
 364         case NET_DEVICE_ETHERNET:
 365                 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName); //LCOV_EXCL_LINE
 366                 break; //LCOV_EXCL_LINE
 367         case NET_DEVICE_BLUETOOTH: {
 368                 char *bt_name = strrchr(profile_info->ProfileName, '/');
 369                 if (bt_name == NULL)
 370                         return CONNECTION_ERROR_INVALID_PARAMETER;
 371
 372                 bt_name++;
 373                 *profile_name = g_strdup(bt_name);
 374         } break;
 375         default:
 376                 return CONNECTION_ERROR_INVALID_PARAMETER;
 377         }
 378
 379         if (*profile_name == NULL)
 380                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 381
 382         return CONNECTION_ERROR_NONE;
 383 }
 384
 385 EXPORT_API int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e *type)
 386 {
 387         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 388
 389         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 390                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 391                 return CONNECTION_ERROR_INVALID_PARAMETER;
 392         }
 393
 394         net_profile_info_t *profile_info = profile;
 395
 396         switch (profile_info->profile_type) {
 397         case NET_DEVICE_CELLULAR:
 398                 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
 399                 break;
 400         case NET_DEVICE_WIFI:
 401                 *type = CONNECTION_PROFILE_TYPE_WIFI;
 402                 break;
 403         case NET_DEVICE_ETHERNET:
 404                 *type = CONNECTION_PROFILE_TYPE_ETHERNET; //LCOV_EXCL_LINE
 405                 break; //LCOV_EXCL_LINE
 406         case NET_DEVICE_BLUETOOTH:
 407                 *type = CONNECTION_PROFILE_TYPE_BT;
 408                 break;
 409         default:
 410                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type");
 411                 return CONNECTION_ERROR_OPERATION_FAILED;
 412         }
 413
 414         return CONNECTION_ERROR_NONE;
 415 }
 416
 417 EXPORT_API int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
 418 {
 419         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 420
 421         if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
 422                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 423                 return CONNECTION_ERROR_INVALID_PARAMETER;
 424         }
 425
 426         net_profile_info_t *profile_info = profile;
 427         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 428         if (net_info == NULL)
 429                 return CONNECTION_ERROR_INVALID_PARAMETER;
 430
 431         *interface_name = g_strdup(net_info->DevName);
 432         if (*interface_name == NULL)
 433                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 434
 435         return CONNECTION_ERROR_NONE;
 436 }
 437
 438 EXPORT_API int connection_profile_refresh(connection_profile_h profile)
 439 {
 440         int rv;
 441
 442         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 443
 444         if (!(_connection_libnet_check_profile_validity(profile))) {
 445                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 446                 return CONNECTION_ERROR_INVALID_PARAMETER;
 447         }
 448
 449         net_profile_info_t profile_info_local;
 450         net_profile_info_t *profile_info = profile;
 451
 452         rv = net_get_profile_info(profile_info->ProfileName, &profile_info_local);
 453         if (rv == NET_ERR_ACCESS_DENIED) {
 454                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 455                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 456         } else if (rv != NET_ERR_NONE) {
 457                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get profile information"); //LCOV_EXCL_LINE
 458                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 459         }
 460
 461         memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
 462
 463         return CONNECTION_ERROR_NONE;
 464 }
 465
 466 EXPORT_API int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
 467 {
 468         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 469
 470         if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
 471                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 472                 return CONNECTION_ERROR_INVALID_PARAMETER;
 473         }
 474
 475         net_profile_info_t *profile_info = profile;
 476         *state = _profile_convert_to_cp_state(profile_info->ProfileState);
 477
 478         return CONNECTION_ERROR_NONE;
 479 }
 480
 481 EXPORT_API int connection_profile_get_ip_config_type(connection_profile_h profile,
 482                 connection_address_family_e address_family, connection_ip_config_type_e *type)
 483 {
 484         net_ip_config_type_t profile_type;
 485
 486         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 487
 488         if (!(_connection_libnet_check_profile_validity(profile)) ||
 489             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 490              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 491             type == NULL) {
 492                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 493                 return CONNECTION_ERROR_INVALID_PARAMETER;
 494         }
 495
 496         net_profile_info_t *profile_info = profile;
 497         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 498         if (net_info == NULL)
 499                 return CONNECTION_ERROR_OPERATION_FAILED;
 500
 501         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 502                 profile_type = net_info->IpConfigType;
 503         else
 504                 profile_type = net_info->IpConfigType6;
 505
 506         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
 507                 switch (profile_type) {
 508                 //LCOV_EXCL_START
 509                 case NET_IP_CONFIG_TYPE_STATIC:
 510                         *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
 511                         break;
 512
 513                 case NET_IP_CONFIG_TYPE_DYNAMIC:
 514                         *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
 515                         break;
 516
 517                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 518                         *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 519                         break;
 520
 521                 case NET_IP_CONFIG_TYPE_FIXED:
 522                         *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
 523                         break;
 524
 525                 case NET_IP_CONFIG_TYPE_OFF:
 526                         *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 527                         break;
 528                 default:
 529                         return CONNECTION_ERROR_OPERATION_FAILED;
 530                 //LCOV_EXCL_STOP
 531                 }
 532         } else {
 533                 //LCOV_EXCL_START
 534                 switch (profile_type) {
 535                 case NET_IP_CONFIG_TYPE_STATIC:
 536                         *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
 537                         break;
 538
 539                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 540                         *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 541                         break;
 542
 543                 case NET_IP_CONFIG_TYPE_OFF:
 544                         *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 545                         break;
 546
 547                 default:
 548                         return  CONNECTION_ERROR_OPERATION_FAILED;
 549
 550                 }
 551                 //LCOV_EXCL_STOP
 552         }
 553
 554         return CONNECTION_ERROR_NONE;
 555 }
 556
 557 EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
 558                 connection_address_family_e address_family, char** ip_address)
 559 {
 560         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 561
 562         if (!(_connection_libnet_check_profile_validity(profile)) ||
 563             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 564              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 565             ip_address == NULL) {
 566                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 567                 return CONNECTION_ERROR_INVALID_PARAMETER;
 568         }
 569
 570         net_profile_info_t *profile_info = profile;
 571         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 572         if (net_info == NULL)
 573                 return CONNECTION_ERROR_OPERATION_FAILED;
 574
 575         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 576                 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr6,
 577                                 address_family);
 578         else
 579                 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
 580                                 address_family);
 581
 582         if (*ip_address == NULL)
 583                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 584
 585         return CONNECTION_ERROR_NONE;
 586 }
 587
 588 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
 589                 connection_address_family_e address_family, char** subnet_mask)
 590 {
 591         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 592
 593         if (!(_connection_libnet_check_profile_validity(profile)) ||
 594             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 595              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 596             subnet_mask == NULL) {
 597                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 598                 return CONNECTION_ERROR_INVALID_PARAMETER;
 599         }
 600
 601         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 602                 CONNECTION_LOG(CONNECTION_ERROR,
 603                                 "Please uses connection_profile_get_prefix_length()");
 604                 return CONNECTION_ERROR_NOT_SUPPORTED;
 605         }
 606
 607         net_profile_info_t *profile_info = profile;
 608         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 609         if (net_info == NULL)
 610                 return CONNECTION_ERROR_OPERATION_FAILED;
 611
 612         *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask,
 613                                 address_family);
 614
 615         if (*subnet_mask == NULL)
 616                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 617
 618         return CONNECTION_ERROR_NONE;
 619 }
 620
 621 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
 622                 connection_address_family_e address_family, char** gateway_address)
 623 {
 624         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 625
 626         if (!(_connection_libnet_check_profile_validity(profile)) ||
 627             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 628              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 629             gateway_address == NULL) {
 630                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 631                 return CONNECTION_ERROR_INVALID_PARAMETER;
 632         }
 633
 634         net_profile_info_t *profile_info = profile;
 635         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 636         if (net_info == NULL)
 637                 return CONNECTION_ERROR_OPERATION_FAILED;
 638
 639         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 640                 *gateway_address = __profile_convert_ip_to_string(
 641                                         &net_info->GatewayAddr6, address_family);
 642         else
 643                 *gateway_address = __profile_convert_ip_to_string(
 644                                         &net_info->GatewayAddr, address_family);
 645
 646         if (*gateway_address == NULL)
 647                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 648
 649         return CONNECTION_ERROR_NONE;
 650 }
 651
 652 EXPORT_API int connection_profile_get_dhcp_server_address(
 653                 connection_profile_h profile,
 654                 connection_address_family_e address_family, char** dhcp_server)
 655 {
 656         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 657
 658         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 659                 CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
 660                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 661         }
 662
 663         if (!(_connection_libnet_check_profile_validity(profile)) ||
 664             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4) ||
 665             dhcp_server == NULL) {
 666                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 667                 return CONNECTION_ERROR_INVALID_PARAMETER;
 668         }
 669
 670         net_profile_info_t *profile_info = profile;
 671         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 672         if (net_info == NULL)
 673                 return CONNECTION_ERROR_OPERATION_FAILED;
 674
 675         CONNECTION_LOG(CONNECTION_INFO, "IP Config %d, DHCP Server Address %s",
 676                         net_info->IpConfigType, (net_info->BServerAddr ? "TRUE" : "FALSE"));
 677
 678         *dhcp_server = __profile_convert_ip_to_string(&net_info->ServerAddr,
 679                         address_family);
 680
 681         if (*dhcp_server == NULL)
 682                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 683
 684         return CONNECTION_ERROR_NONE;
 685 }
 686
 687 EXPORT_API int connection_profile_get_dhcp_lease_duration(
 688                 connection_profile_h profile,
 689                 connection_address_family_e address_family, int* dhcp_lease_duration)
 690 {
 691         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 692
 693         if (!(_connection_libnet_check_profile_validity(profile)) ||
 694             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4)) {
 695                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 696                 return CONNECTION_ERROR_INVALID_PARAMETER;
 697         }
 698
 699         net_profile_info_t *profile_info = profile;
 700         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 701         if (net_info == NULL)
 702                 return CONNECTION_ERROR_OPERATION_FAILED;
 703
 704         CONNECTION_LOG(CONNECTION_INFO, "Lease duration : %d",
 705                         net_info->DHCPLeaseDuration);
 706
 707         *dhcp_lease_duration = net_info->DHCPLeaseDuration;
 708
 709         return CONNECTION_ERROR_NONE;
 710 }
 711
 712 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
 713                 connection_address_family_e address_family, char** dns_address)
 714 {
 715         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 716
 717         if (!(_connection_libnet_check_profile_validity(profile)) ||
 718             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 719              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 720             dns_address == NULL ||
 721             order <= 0 ||
 722             order > NET_DNS_ADDR_MAX) {
 723                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 724                 return CONNECTION_ERROR_INVALID_PARAMETER;
 725         }
 726
 727         net_profile_info_t *profile_info = profile;
 728         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 729         if (net_info == NULL)
 730                 return CONNECTION_ERROR_OPERATION_FAILED;
 731
 732         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 733                 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
 734                                 address_family);
 735         else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) //LCOV_EXCL_LINE
 736                 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1], //LCOV_EXCL_LINE
 737                                 address_family);
 738
 739         if (*dns_address == NULL)
 740                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 741
 742         return CONNECTION_ERROR_NONE;
 743 }
 744
 745 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e *type)
 746 {
 747         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 748
 749         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 750                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 751                 return CONNECTION_ERROR_INVALID_PARAMETER;
 752         }
 753
 754         net_profile_info_t *profile_info = profile;
 755         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 756         if (net_info == NULL)
 757                 return CONNECTION_ERROR_OPERATION_FAILED;
 758
 759         //LCOV_EXCL_START
 760         if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
 761                 char *proxy = __profile_get_ethernet_proxy();
 762                 if (proxy == NULL) {
 763                         *type = CONNECTION_PROXY_TYPE_DIRECT;
 764                 } else {
 765                         *type = CONNECTION_PROXY_TYPE_MANUAL;
 766                         free(proxy);
 767                 }
 768
 769                 return CONNECTION_ERROR_NONE;
 770         }
 771         //LCOV_EXCL_STOP
 772
 773         switch (net_info->ProxyMethod) {
 774         //LCOV_EXCL_START
 775         case NET_PROXY_TYPE_DIRECT:
 776                 *type = CONNECTION_PROXY_TYPE_DIRECT;
 777                 break;
 778         case NET_PROXY_TYPE_AUTO:
 779                 *type = CONNECTION_PROXY_TYPE_AUTO;
 780                 break;
 781         case NET_PROXY_TYPE_MANUAL:
 782                 *type = CONNECTION_PROXY_TYPE_MANUAL;
 783                 break;
 784         case NET_PROXY_TYPE_UNKNOWN:
 785         default:
 786                 return CONNECTION_ERROR_OPERATION_FAILED;
 787         //LCOV_EXCL_STOP
 788         }
 789
 790         return CONNECTION_ERROR_NONE;
 791 }
 792
 793 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
 794                 connection_address_family_e address_family, char** proxy_address)
 795 {
 796         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 797
 798         if (!(_connection_libnet_check_profile_validity(profile)) ||
 799             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 800              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 801              proxy_address == NULL) {
 802                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 803                 return CONNECTION_ERROR_INVALID_PARAMETER;
 804         }
 805
 806         net_profile_info_t *profile_info = profile;
 807         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 808         if (net_info == NULL)
 809                 return CONNECTION_ERROR_OPERATION_FAILED;
 810
 811         *proxy_address = g_strdup(net_info->ProxyAddr);
 812
 813         if (*proxy_address == NULL)
 814                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 815
 816         return CONNECTION_ERROR_NONE;
 817 }
 818
 819 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
 820                 connection_address_family_e address_family, connection_ip_config_type_e type)
 821 {
 822         net_ip_config_type_t *profile_type = NULL;
 823
 824         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 825
 826         if (!(_connection_libnet_check_profile_validity(profile)) ||
 827             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 828              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 829                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 830                 return CONNECTION_ERROR_INVALID_PARAMETER;
 831         }
 832
 833         net_profile_info_t *profile_info = profile;
 834         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 835         if (net_info == NULL)
 836                 return CONNECTION_ERROR_OPERATION_FAILED;
 837
 838         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 839                 profile_type = &net_info->IpConfigType ;
 840         else
 841                 profile_type = &net_info->IpConfigType6 ;
 842
 843         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
 844                 switch (type) {
 845                 //LCOV_EXCL_START
 846                 case CONNECTION_IP_CONFIG_TYPE_STATIC:
 847                         *profile_type = NET_IP_CONFIG_TYPE_STATIC;
 848                         net_info->IpAddr.Data.Ipv4.s_addr = 0;
 849                         net_info->SubnetMask.Data.Ipv4.s_addr = 0;
 850                         net_info->GatewayAddr.Data.Ipv4.s_addr = 0 ;
 851                         break;
 852
 853                 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
 854                         *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
 855                         break;
 856
 857                 case CONNECTION_IP_CONFIG_TYPE_AUTO:
 858                         *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
 859                         break;
 860
 861                 case CONNECTION_IP_CONFIG_TYPE_FIXED:
 862                         net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
 863                         break;
 864
 865                 case CONNECTION_IP_CONFIG_TYPE_NONE:
 866                         *profile_type = NET_IP_CONFIG_TYPE_OFF;
 867                         break;
 868
 869                 default:
 870                         return CONNECTION_ERROR_INVALID_PARAMETER;
 871                 //LCOV_EXCL_STOP
 872                 }
 873         } else {
 874                 //LCOV_EXCL_START
 875                 switch (type) {
 876                 case CONNECTION_IP_CONFIG_TYPE_STATIC:
 877                         *profile_type = NET_IP_CONFIG_TYPE_STATIC;
 878                         inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
 879                         net_info->PrefixLen6 = 0 ;
 880                         inet_pton(AF_INET6, "::",
 881                                         &net_info->GatewayAddr6.Data.Ipv6);
 882                         break;
 883
 884                 case CONNECTION_IP_CONFIG_TYPE_AUTO:
 885                         *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
 886                         break;
 887
 888                 case CONNECTION_IP_CONFIG_TYPE_NONE:
 889                         *profile_type = NET_IP_CONFIG_TYPE_OFF;
 890                         break;
 891
 892                 default:
 893                         return CONNECTION_ERROR_INVALID_PARAMETER;
 894                 }
 895                 //LCOV_EXCL_STOP
 896         }
 897
 898         return CONNECTION_ERROR_NONE;
 899 }
 900
 901 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
 902                 connection_address_family_e address_family, const char* ip_address)
 903 {
 904         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 905
 906         if (!(_connection_libnet_check_profile_validity(profile)) ||
 907             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 908              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 909                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 910                 return CONNECTION_ERROR_INVALID_PARAMETER;
 911         }
 912
 913         net_profile_info_t *profile_info = profile;
 914         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 915         if (net_info == NULL)
 916                 return CONNECTION_ERROR_OPERATION_FAILED;
 917
 918         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 919                 //LCOV_EXCL_START
 920                 if (ip_address == NULL)
 921                         inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
 922                 else if (inet_pton(AF_INET6, ip_address,
 923                                         &net_info->IpAddr6.Data.Ipv6) < 1)
 924                         return CONNECTION_ERROR_INVALID_PARAMETER;
 925                 //LCOV_EXCL_STOP
 926         } else {
 927                 if (ip_address == NULL)
 928                         net_info->IpAddr.Data.Ipv4.s_addr = 0;
 929                 else if (inet_pton(AF_INET, ip_address,
 930                                         &net_info->IpAddr.Data.Ipv4) < 1)
 931                         return CONNECTION_ERROR_INVALID_PARAMETER;
 932         }
 933
 934         return CONNECTION_ERROR_NONE;
 935 }
 936
 937 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
 938                 connection_address_family_e address_family, const char* subnet_mask)
 939 {
 940         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 941
 942         if (!(_connection_libnet_check_profile_validity(profile)) ||
 943                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 944                          address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 945                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 946                 return CONNECTION_ERROR_INVALID_PARAMETER;
 947         }
 948
 949         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 950                 CONNECTION_LOG(CONNECTION_ERROR,
 951                                 "Please uses connection_profile_set_prefix_length()");
 952                 return CONNECTION_ERROR_NOT_SUPPORTED;
 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         if (subnet_mask == NULL)
 961                 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
 962         else if (inet_pton(AF_INET, subnet_mask , &net_info->SubnetMask.Data.Ipv4) < 1)
 963                 return CONNECTION_ERROR_INVALID_PARAMETER;
 964
 965         net_info->PrefixLen = __profile_convert_netmask_to_prefix_len(subnet_mask);
 966
 967         return CONNECTION_ERROR_NONE;
 968 }
 969
 970 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
 971                 connection_address_family_e address_family, const char* gateway_address)
 972 {
 973         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 974
 975         if (!(_connection_libnet_check_profile_validity(profile)) ||
 976             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 977              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 978                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 979                 return CONNECTION_ERROR_INVALID_PARAMETER;
 980         }
 981
 982         net_profile_info_t *profile_info = profile;
 983         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 984         if (net_info == NULL)
 985                 return CONNECTION_ERROR_OPERATION_FAILED;
 986
 987         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 988                 //LCOV_EXCL_START
 989                 if (gateway_address == NULL)
 990                         inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6);
 991                 else if (inet_pton(AF_INET6, gateway_address, &net_info->GatewayAddr6.Data.Ipv6) < 1)
 992                         return CONNECTION_ERROR_INVALID_PARAMETER;
 993                 //LCOV_EXCL_STOP
 994         } else {
 995                 if (gateway_address == NULL)
 996                         net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
 997                 else if (inet_pton(AF_INET, gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) < 1)
 998                         return CONNECTION_ERROR_INVALID_PARAMETER;
 999         }
1000
1001         return CONNECTION_ERROR_NONE;
1002 }
1003
1004 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
1005                 connection_address_family_e address_family, const char* dns_address)
1006 {
1007         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1008
1009         if (!(_connection_libnet_check_profile_validity(profile)) ||
1010             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1011              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1012             order <= 0 ||
1013             order > NET_DNS_ADDR_MAX) {
1014                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1015                 return CONNECTION_ERROR_INVALID_PARAMETER;
1016         }
1017
1018         net_profile_info_t *profile_info = profile;
1019         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1020         if (net_info == NULL)
1021                 return CONNECTION_ERROR_OPERATION_FAILED;
1022
1023         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1024                 //LCOV_EXCL_START
1025                 net_info->DnsAddr6[order-1].Type = NET_ADDR_IPV6;
1026                 if (dns_address == NULL)
1027                         inet_pton(AF_INET6, "::", &net_info->DnsAddr6[order-1].Data.Ipv6);
1028                 else if (inet_pton(AF_INET6, dns_address, &net_info->DnsAddr6[order-1].Data.Ipv6) < 1)
1029                         return CONNECTION_ERROR_INVALID_PARAMETER;
1030                 if (net_info->DnsCount6 < order)
1031                         net_info->DnsCount6 = order;
1032                 //LCOV_EXCL_STOP
1033         } else {
1034                 net_info->DnsAddr[order-1].Type = NET_ADDR_IPV4;
1035                 if (dns_address == NULL)
1036                         net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
1037                 else if (inet_pton(AF_INET, dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) < 1)
1038                         return CONNECTION_ERROR_INVALID_PARAMETER;
1039                 if (net_info->DnsCount < order)
1040                         net_info->DnsCount = order;
1041         }
1042
1043         return CONNECTION_ERROR_NONE;
1044 }
1045
1046 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
1047 {
1048         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1049
1050         if (!(_connection_libnet_check_profile_validity(profile))) {
1051                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1052                 return CONNECTION_ERROR_INVALID_PARAMETER;
1053         }
1054
1055         net_profile_info_t *profile_info = profile;
1056         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1057         if (net_info == NULL)
1058                 return CONNECTION_ERROR_OPERATION_FAILED;
1059
1060         switch (type) {
1061         //LCOV_EXCL_START
1062         case CONNECTION_PROXY_TYPE_DIRECT:
1063                 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
1064                 break;
1065         case CONNECTION_PROXY_TYPE_AUTO:
1066                 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
1067                 break;
1068         case CONNECTION_PROXY_TYPE_MANUAL:
1069                 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
1070                 break;
1071         default:
1072                 return CONNECTION_ERROR_INVALID_PARAMETER;
1073         //LCOV_EXCL_STOP
1074         }
1075
1076         return CONNECTION_ERROR_NONE;
1077 }
1078
1079 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
1080                 connection_address_family_e address_family, const char* proxy_address)
1081 {
1082         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1083
1084         CONNECTION_LOG(CONNECTION_ERROR, "Address Family: ", address_family);
1085         if (!(_connection_libnet_check_profile_validity(profile)) ||
1086             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1087              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1088                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1089                 return CONNECTION_ERROR_INVALID_PARAMETER;
1090         }
1091
1092         net_profile_info_t *profile_info = profile;
1093         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1094         if (net_info == NULL)
1095                 return CONNECTION_ERROR_OPERATION_FAILED;
1096
1097         if (proxy_address == NULL)
1098                 net_info->ProxyAddr[0] = '\0';
1099         else
1100                 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
1101
1102         return CONNECTION_ERROR_NONE;
1103 }
1104
1105 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
1106                 connection_profile_state_changed_cb callback, void* user_data)
1107 {
1108         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1109
1110         if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
1111                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1112                 return CONNECTION_ERROR_INVALID_PARAMETER;
1113         }
1114
1115         if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
1116                 return CONNECTION_ERROR_NONE;
1117
1118         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1119 }
1120
1121 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
1122 {
1123         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1124
1125         if (!(_connection_libnet_check_profile_validity(profile))) {
1126                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1127                 return CONNECTION_ERROR_INVALID_PARAMETER;
1128         }
1129
1130         if (_connection_libnet_remove_from_profile_cb_list(profile) != true)
1131                 return CONNECTION_ERROR_INVALID_PARAMETER;
1132
1133         return CONNECTION_ERROR_NONE;
1134 }
1135
1136
1137 /* Wi-Fi profile *************************************************************/
1138 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
1139 {
1140         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1141
1142         if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
1143                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1144                 return CONNECTION_ERROR_INVALID_PARAMETER;
1145         }
1146
1147         net_profile_info_t *profile_info = profile;
1148
1149         if (profile_info->profile_type != NET_DEVICE_WIFI)
1150                 return CONNECTION_ERROR_INVALID_PARAMETER;
1151
1152         *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
1153         if (*essid == NULL)
1154                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1155
1156         return CONNECTION_ERROR_NONE;
1157 }
1158
1159 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
1160 {
1161         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1162
1163         if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
1164                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1165                 return CONNECTION_ERROR_INVALID_PARAMETER;
1166         }
1167
1168         net_profile_info_t *profile_info = profile;
1169
1170         if (profile_info->profile_type != NET_DEVICE_WIFI)
1171                 return CONNECTION_ERROR_INVALID_PARAMETER;
1172
1173         *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
1174         if (*bssid == NULL)
1175                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1176
1177         return CONNECTION_ERROR_NONE;
1178 }
1179
1180 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
1181 {
1182         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1183
1184         if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
1185                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1186                 return CONNECTION_ERROR_INVALID_PARAMETER;
1187         }
1188
1189         net_profile_info_t *profile_info = profile;
1190
1191         if (profile_info->profile_type != NET_DEVICE_WIFI)
1192                 return CONNECTION_ERROR_INVALID_PARAMETER;
1193
1194         *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
1195
1196         return CONNECTION_ERROR_NONE;
1197 }
1198
1199 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
1200 {
1201         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1202
1203         if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
1204                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1205                 return CONNECTION_ERROR_INVALID_PARAMETER;
1206         }
1207
1208         net_profile_info_t *profile_info = profile;
1209
1210         if (profile_info->profile_type != NET_DEVICE_WIFI)
1211                 return CONNECTION_ERROR_INVALID_PARAMETER;
1212
1213         *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
1214
1215         return CONNECTION_ERROR_NONE;
1216 }
1217
1218 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
1219 {
1220         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1221
1222         if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
1223                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1224                 return CONNECTION_ERROR_INVALID_PARAMETER;
1225         }
1226
1227         net_profile_info_t *profile_info = profile;
1228
1229         if (profile_info->profile_type != NET_DEVICE_WIFI)
1230                 return CONNECTION_ERROR_INVALID_PARAMETER;
1231
1232         *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate / 1000000;
1233
1234         return CONNECTION_ERROR_NONE;
1235 }
1236
1237 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e *type)
1238 {
1239         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1240
1241         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1242                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1243                 return CONNECTION_ERROR_INVALID_PARAMETER;
1244         }
1245
1246         net_profile_info_t *profile_info = profile;
1247
1248         if (profile_info->profile_type != NET_DEVICE_WIFI)
1249                 return CONNECTION_ERROR_INVALID_PARAMETER;
1250
1251         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1252         //LCOV_EXCL_START
1253         case WLAN_SEC_MODE_NONE:
1254                 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
1255                 break;
1256         case WLAN_SEC_MODE_WEP:
1257                 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
1258                 break;
1259         case WLAN_SEC_MODE_IEEE8021X:
1260                 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
1261                 break;
1262         case WLAN_SEC_MODE_WPA_PSK:
1263                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
1264                 break;
1265         case WLAN_SEC_MODE_WPA2_PSK:
1266                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
1267                 break;
1268         default:
1269                 return CONNECTION_ERROR_OPERATION_FAILED;
1270         //LCOV_EXCL_STOP
1271         }
1272
1273         return CONNECTION_ERROR_NONE;
1274 }
1275
1276 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e *type)
1277 {
1278         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1279
1280         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1281                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1282                 return CONNECTION_ERROR_INVALID_PARAMETER;
1283         }
1284
1285         net_profile_info_t *profile_info = profile;
1286
1287         if (profile_info->profile_type != NET_DEVICE_WIFI)
1288                 return CONNECTION_ERROR_INVALID_PARAMETER;
1289
1290         switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1291         //LCOV_EXCL_START
1292         case WLAN_ENC_MODE_NONE:
1293                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1294                 break;
1295         case WLAN_ENC_MODE_WEP:
1296                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1297                 break;
1298         case WLAN_ENC_MODE_TKIP:
1299                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1300                 break;
1301         case WLAN_ENC_MODE_AES:
1302                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1303                 break;
1304         case WLAN_ENC_MODE_TKIP_AES_MIXED:
1305                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1306                 break;
1307         default:
1308                 return CONNECTION_ERROR_OPERATION_FAILED;
1309         //LCOV_EXCL_STOP
1310         }
1311
1312         return CONNECTION_ERROR_NONE;
1313 }
1314
1315 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1316 {
1317         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1318
1319         if (!(_connection_libnet_check_profile_validity(profile)) || required == 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_WIFI)
1327                 return CONNECTION_ERROR_INVALID_PARAMETER;
1328
1329         if (profile_info->Favourite) {
1330                 *required = false;
1331                 return CONNECTION_ERROR_NONE;
1332         }
1333
1334         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1335         //LCOV_EXCL_START
1336         case WLAN_SEC_MODE_NONE:
1337                 *required = false;
1338                 break;
1339         case WLAN_SEC_MODE_WEP:
1340         case WLAN_SEC_MODE_IEEE8021X:
1341         case WLAN_SEC_MODE_WPA_PSK:
1342         case WLAN_SEC_MODE_WPA2_PSK:
1343                 *required = true;
1344                 break;
1345         default:
1346                 return CONNECTION_ERROR_OPERATION_FAILED;
1347         //LCOV_EXCL_STOP
1348         }
1349
1350         return CONNECTION_ERROR_NONE;
1351 }
1352
1353 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1354 {
1355         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1356
1357         if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1358                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1359                 return CONNECTION_ERROR_INVALID_PARAMETER;
1360         }
1361
1362         net_profile_info_t *profile_info = profile;
1363
1364         if (profile_info->profile_type != NET_DEVICE_WIFI)
1365                 return CONNECTION_ERROR_INVALID_PARAMETER;
1366
1367         g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1368                                                 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1369
1370         return CONNECTION_ERROR_NONE;
1371 }
1372
1373 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1374 {
1375         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1376
1377         if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1378                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1379                 return CONNECTION_ERROR_INVALID_PARAMETER;
1380         }
1381
1382         net_profile_info_t *profile_info = profile;
1383
1384         if (profile_info->profile_type != NET_DEVICE_WIFI)
1385                 return CONNECTION_ERROR_INVALID_PARAMETER;
1386
1387         if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1388                 *supported = true;
1389         else
1390                 *supported = false;
1391
1392         return CONNECTION_ERROR_NONE;
1393 }
1394
1395
1396 /* Cellular profile **********************************************************/
1397 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1398                                                 connection_cellular_service_type_e* type)
1399 {
1400         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1401
1402         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1403                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1404                 return CONNECTION_ERROR_INVALID_PARAMETER;
1405         }
1406
1407         net_profile_info_t *profile_info = profile;
1408
1409         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1410                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1411                 return CONNECTION_ERROR_INVALID_PARAMETER;
1412         }
1413
1414         *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1415
1416         if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1417                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed"); //LCOV_EXCL_LINE
1418                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1419         }
1420
1421         return CONNECTION_ERROR_NONE;
1422 }
1423
1424 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1425 {
1426         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1427
1428         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1429                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1430                 return CONNECTION_ERROR_INVALID_PARAMETER;
1431         }
1432
1433         net_profile_info_t *profile_info = profile;
1434
1435         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1436                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1437                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1438         }
1439
1440         *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1441         if (*apn == NULL)
1442                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1443
1444         return CONNECTION_ERROR_NONE;
1445 }
1446
1447 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1448                 connection_cellular_auth_type_e *type, char** user_name, char** password)
1449 {
1450         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1451
1452         if (!(_connection_libnet_check_profile_validity(profile)) ||
1453             type == NULL || user_name == NULL || password == NULL) {
1454                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1455                 return CONNECTION_ERROR_INVALID_PARAMETER;
1456         }
1457
1458         net_profile_info_t *profile_info = profile;
1459
1460         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1461                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1462                 return CONNECTION_ERROR_INVALID_PARAMETER;
1463         }
1464
1465         switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1466         //LCOV_EXCL_START
1467         case NET_PDP_AUTH_NONE:
1468                 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1469                 break;
1470         case NET_PDP_AUTH_PAP:
1471                 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1472                 break;
1473         case NET_PDP_AUTH_CHAP:
1474                 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1475                 break;
1476         default:
1477                 return CONNECTION_ERROR_OPERATION_FAILED;
1478         //LCOV_EXCL_STOP
1479         }
1480
1481         *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1482         if (*user_name == NULL)
1483                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1484
1485         *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1486         if (*password == NULL) {
1487                 g_free(*user_name); //LCOV_EXCL_LINE
1488                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1489         }
1490
1491         return CONNECTION_ERROR_NONE;
1492 }
1493
1494 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1495 {
1496         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1497
1498         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1499                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1500                 return CONNECTION_ERROR_INVALID_PARAMETER;
1501         }
1502
1503         net_profile_info_t *profile_info = profile;
1504
1505         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1506                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1507                 return CONNECTION_ERROR_INVALID_PARAMETER;
1508         }
1509
1510         *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1511         if (*home_url == NULL)
1512                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1513
1514         return CONNECTION_ERROR_NONE;
1515 }
1516
1517 EXPORT_API int connection_profile_get_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1518 {
1519         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1520
1521         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1522                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1523                 return CONNECTION_ERROR_INVALID_PARAMETER;
1524         }
1525
1526         net_profile_info_t *profile_info = profile;
1527
1528         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1529                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1530                 return CONNECTION_ERROR_INVALID_PARAMETER;
1531         }
1532
1533         switch (profile_info->ProfileInfo.Pdp.PdnType) {
1534         //LCOV_EXCL_START
1535         case NET_PDN_TYPE_UNKNOWN:
1536                 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1537                 break;
1538         case NET_PDN_TYPE_IPV4:
1539                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1540                 break;
1541         case NET_PDN_TYPE_IPV6:
1542                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1543                 break;
1544         case NET_PDN_TYPE_IPV4_IPV6:
1545                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1546                 break;
1547         default:
1548                 return CONNECTION_ERROR_OPERATION_FAILED;
1549         //LCOV_EXCL_STOP
1550         }
1551
1552         return CONNECTION_ERROR_NONE;
1553 }
1554
1555 EXPORT_API int connection_profile_get_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1556 {
1557         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1558
1559         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1560                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1561                 return CONNECTION_ERROR_INVALID_PARAMETER;
1562         }
1563
1564         net_profile_info_t *profile_info = profile;
1565
1566         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1567                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1568                 return CONNECTION_ERROR_INVALID_PARAMETER;
1569         }
1570
1571         switch (profile_info->ProfileInfo.Pdp.RoamPdnType) {
1572         //LCOV_EXCL_START
1573         case NET_PDN_TYPE_UNKNOWN:
1574                 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1575                 break;
1576         case NET_PDN_TYPE_IPV4:
1577                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1578                 break;
1579         case NET_PDN_TYPE_IPV6:
1580                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1581                 break;
1582         case NET_PDN_TYPE_IPV4_IPV6:
1583                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1584                 break;
1585         default:
1586                 return CONNECTION_ERROR_OPERATION_FAILED;
1587         //LCOV_EXCL_STOP
1588         }
1589
1590         return CONNECTION_ERROR_NONE;
1591 }
1592
1593 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1594 {
1595         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1596
1597         if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1598                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1599                 return CONNECTION_ERROR_INVALID_PARAMETER;
1600         }
1601
1602         net_profile_info_t *profile_info = profile;
1603
1604         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1605                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1606                 return CONNECTION_ERROR_INVALID_PARAMETER;
1607         }
1608
1609         if (profile_info->ProfileInfo.Pdp.Roaming)
1610                 *is_roaming = true;
1611         else
1612                 *is_roaming = false;
1613
1614         return CONNECTION_ERROR_NONE;
1615 }
1616
1617 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
1618 {
1619         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1620
1621         if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
1622                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1623                 return CONNECTION_ERROR_INVALID_PARAMETER;
1624         }
1625
1626         net_profile_info_t *profile_info = profile;
1627
1628         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1629                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1630                 return CONNECTION_ERROR_INVALID_PARAMETER;
1631         }
1632
1633         if (profile_info->ProfileInfo.Pdp.Hidden)
1634                 *is_hidden = true;
1635         else
1636                 *is_hidden = false;
1637
1638         return CONNECTION_ERROR_NONE;
1639 }
1640
1641 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
1642 {
1643         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1644
1645         if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
1646                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1647                 return CONNECTION_ERROR_INVALID_PARAMETER;
1648         }
1649
1650         net_profile_info_t *profile_info = profile;
1651
1652         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1653                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1654                 return CONNECTION_ERROR_INVALID_PARAMETER;
1655         }
1656
1657         if (profile_info->ProfileInfo.Pdp.Editable)
1658                 *is_editable = true;
1659         else
1660                 *is_editable = false;
1661
1662         return CONNECTION_ERROR_NONE;
1663 }
1664
1665 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
1666 {
1667         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1668
1669         if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
1670                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1671                 return CONNECTION_ERROR_INVALID_PARAMETER;
1672         }
1673
1674         net_profile_info_t *profile_info = profile;
1675
1676         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1677                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1678                 return CONNECTION_ERROR_INVALID_PARAMETER;
1679         }
1680
1681         if (profile_info->ProfileInfo.Pdp.DefaultConn)
1682                 *is_default = true;
1683         else
1684                 *is_default = false;
1685
1686         return CONNECTION_ERROR_NONE;
1687 }
1688
1689 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
1690                 connection_cellular_service_type_e service_type)
1691 {
1692         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1693
1694         if (!(_connection_libnet_check_profile_validity(profile))) {
1695                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1696                 return CONNECTION_ERROR_INVALID_PARAMETER;
1697         }
1698
1699         net_profile_info_t *profile_info = profile;
1700
1701         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1702                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1703                 return CONNECTION_ERROR_INVALID_PARAMETER;
1704         }
1705
1706         switch (service_type) {
1707         //LCOV_EXCL_START
1708         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1709                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1710                 break;
1711         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1712                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1713                 break;
1714         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1715                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1716                 break;
1717         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1718                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1719                 break;
1720         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1721                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1722                 break;
1723         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1724                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1725                 break;
1726         case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1727         default:
1728                 return CONNECTION_ERROR_INVALID_PARAMETER;
1729         //LCOV_EXCL_STOP
1730         }
1731
1732         return CONNECTION_ERROR_NONE;
1733 }
1734
1735 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1736 {
1737         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1738
1739         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1740                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1741                 return CONNECTION_ERROR_INVALID_PARAMETER;
1742         }
1743
1744         net_profile_info_t *profile_info = profile;
1745
1746         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1747                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1748                 return CONNECTION_ERROR_INVALID_PARAMETER;
1749         }
1750
1751         g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1752
1753         return CONNECTION_ERROR_NONE;
1754 }
1755
1756 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
1757                 connection_cellular_auth_type_e type, const char* user_name, const char* password)
1758 {
1759         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1760
1761         if (!(_connection_libnet_check_profile_validity(profile)) ||
1762             user_name == NULL || password == NULL) {
1763                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1764                 return CONNECTION_ERROR_INVALID_PARAMETER;
1765         }
1766
1767         net_profile_info_t *profile_info = profile;
1768
1769         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1770                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1771                 return CONNECTION_ERROR_INVALID_PARAMETER;
1772         }
1773
1774         switch (type) {
1775         //LCOV_EXCL_START
1776         case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1777                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1778                 break;
1779         case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1780                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1781                 break;
1782         case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1783                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1784                 break;
1785         default:
1786                 return CONNECTION_ERROR_INVALID_PARAMETER;
1787         //LCOV_EXCL_STOP
1788         }
1789
1790         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
1791         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
1792
1793         return CONNECTION_ERROR_NONE;
1794 }
1795
1796 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1797 {
1798         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1799
1800         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1801                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1802                 return CONNECTION_ERROR_INVALID_PARAMETER;
1803         }
1804
1805         net_profile_info_t *profile_info = profile;
1806
1807         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1808                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1809                 return CONNECTION_ERROR_INVALID_PARAMETER;
1810         }
1811
1812         g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1813
1814         return CONNECTION_ERROR_NONE;
1815 }
1816
1817 EXPORT_API int connection_profile_set_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
1818 {
1819         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1820
1821         if (!(_connection_libnet_check_profile_validity(profile))) {
1822                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1823                 return CONNECTION_ERROR_INVALID_PARAMETER;
1824         }
1825
1826         net_profile_info_t *profile_info = profile;
1827
1828         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1829                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1830                 return CONNECTION_ERROR_INVALID_PARAMETER;
1831         }
1832
1833         switch (type) {
1834         //LCOV_EXCL_START
1835         case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
1836                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4;
1837                 break;
1838         case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
1839                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV6;
1840                 break;
1841         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
1842                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
1843                 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
1844                                                 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
1845                 break;
1846         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
1847                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
1848                 break;
1849         default:
1850                 return CONNECTION_ERROR_INVALID_PARAMETER;
1851         //LCOV_EXCL_STOP
1852         }
1853
1854         return CONNECTION_ERROR_NONE;
1855 }
1856
1857 EXPORT_API int connection_profile_set_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
1858 {
1859         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1860
1861         if (!(_connection_libnet_check_profile_validity(profile))) {
1862                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1863                 return CONNECTION_ERROR_INVALID_PARAMETER;
1864         }
1865
1866         net_profile_info_t *profile_info = profile;
1867
1868         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1869                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1870                 return CONNECTION_ERROR_INVALID_PARAMETER;
1871         }
1872
1873         switch (type) {
1874         //LCOV_EXCL_START
1875         case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
1876                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4;
1877                 break;
1878         case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
1879                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV6;
1880                 break;
1881         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
1882                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
1883                 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
1884                                                 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
1885                 break;
1886         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
1887                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
1888                 break;
1889         default:
1890                 return CONNECTION_ERROR_INVALID_PARAMETER;
1891         //LCOV_EXCL_STOP
1892         }
1893
1894         return CONNECTION_ERROR_NONE;
1895 }
1896
1897 EXPORT_API int connection_profile_get_ipv6_state(connection_profile_h profile, connection_profile_state_e *state)
1898 {
1899         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1900                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1901
1902         if (!(_connection_libnet_check_profile_validity(profile)) ||
1903                         state == NULL) {
1904                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1905                 return CONNECTION_ERROR_INVALID_PARAMETER;
1906         }
1907
1908         net_profile_info_t *profile_info = profile;
1909         *state = _profile_convert_to_cp_state(profile_info->ProfileState6);
1910         if (*state < 0)
1911                 return CONNECTION_ERROR_OPERATION_FAILED;
1912
1913         return CONNECTION_ERROR_NONE;
1914 }
1915
1916 EXPORT_API int connection_profile_set_dns_config_type(connection_profile_h profile,
1917                 connection_address_family_e address_family, connection_dns_config_type_e type)
1918 {
1919         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1920                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1921
1922         if (!(_connection_libnet_check_profile_validity(profile))) {
1923                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1924                 return CONNECTION_ERROR_INVALID_PARAMETER;
1925         }
1926
1927         if ((address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1928                                 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1929                         (type != CONNECTION_DNS_CONFIG_TYPE_STATIC &&
1930                          type != CONNECTION_DNS_CONFIG_TYPE_DYNAMIC)) {
1931                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1932                 return CONNECTION_ERROR_INVALID_PARAMETER;
1933         }
1934
1935         net_dns_config_type_t *profileType = NULL;
1936         net_dns_config_type_t *profileType6 = NULL;
1937         net_profile_info_t *profile_info = profile;
1938
1939         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1940         if (net_info == NULL)
1941                 return CONNECTION_ERROR_OPERATION_FAILED;
1942
1943         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1944                 profileType = &net_info->DnsConfigType;
1945                 net_info->DnsAddr[0].Data.Ipv4.s_addr = 0;
1946                 net_info->DnsAddr[1].Data.Ipv4.s_addr = 0;
1947                 *profileType = type;
1948         } else {
1949                 profileType6 = &net_info->DnsConfigType6;
1950                 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[0].Data.Ipv6);
1951                 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[1].Data.Ipv6);
1952                 *profileType6 = type;
1953         }
1954
1955         return CONNECTION_ERROR_NONE;
1956 }
1957
1958 EXPORT_API int connection_profile_get_dns_config_type(connection_profile_h profile,
1959                 connection_address_family_e address_family, connection_dns_config_type_e *type)
1960 {
1961         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1962                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1963
1964         if (!(_connection_libnet_check_profile_validity(profile)) ||
1965                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1966                          address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1967                         type == NULL) {
1968                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1969                 return CONNECTION_ERROR_INVALID_PARAMETER;
1970         }
1971
1972         net_dns_config_type_t profileType;
1973         net_profile_info_t *profile_info = profile;
1974         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1975         if (net_info == NULL)
1976                 return CONNECTION_ERROR_OPERATION_FAILED;
1977
1978         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
1979                 profileType = net_info->DnsConfigType;
1980         else
1981                 profileType = net_info->DnsConfigType6;
1982
1983         switch (profileType) {
1984         case NET_DNS_CONFIG_TYPE_STATIC:
1985                 *type = CONNECTION_DNS_CONFIG_TYPE_STATIC;
1986                 break;
1987         case NET_DNS_CONFIG_TYPE_DYNAMIC:
1988                 *type = CONNECTION_DNS_CONFIG_TYPE_DYNAMIC;
1989                 break;
1990         default:
1991                 *type = CONNECTION_DNS_CONFIG_TYPE_NONE;
1992                 break;
1993         }
1994
1995         return CONNECTION_ERROR_NONE;
1996 }
1997
1998 EXPORT_API int connection_profile_set_prefix_length(connection_profile_h profile,
1999                 connection_address_family_e address_family, int prefix_len)
2000 {
2001         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2002                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2003
2004         if (!(_connection_libnet_check_profile_validity(profile)) ||
2005                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2006                         address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
2007                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2008                 return CONNECTION_ERROR_INVALID_PARAMETER;
2009         }
2010
2011         net_profile_info_t *profile_info = profile;
2012         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2013         if (net_info == NULL)
2014                 return CONNECTION_ERROR_OPERATION_FAILED;
2015
2016         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
2017                 net_info->PrefixLen = prefix_len;
2018                 net_info->SubnetMask.Data.Ipv4.s_addr = __profile_convert_prefix_len_to_netmask(prefix_len);
2019         } else
2020                 net_info->PrefixLen6 = prefix_len;
2021
2022         return CONNECTION_ERROR_NONE;
2023 }
2024
2025 EXPORT_API int connection_profile_get_prefix_length(connection_profile_h profile,
2026                 connection_address_family_e address_family, int *prefix_len)
2027 {
2028         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2029                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2030
2031         if (!(_connection_libnet_check_profile_validity(profile)) ||
2032                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2033                         address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2034                         prefix_len == NULL) {
2035                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2036                 return CONNECTION_ERROR_INVALID_PARAMETER;
2037         }
2038
2039         net_profile_info_t *profile_info = profile;
2040         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2041         if (net_info == NULL)
2042                 return CONNECTION_ERROR_OPERATION_FAILED;
2043
2044         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
2045                 *prefix_len =  net_info->PrefixLen;
2046         else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
2047                 *prefix_len =  net_info->PrefixLen6;
2048
2049         return CONNECTION_ERROR_NONE;
2050 }