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_dns_address(connection_profile_h profile, int order,
 688                 connection_address_family_e address_family, char** dns_address)
 689 {
 690         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 691
 692         if (!(_connection_libnet_check_profile_validity(profile)) ||
 693             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 694              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 695             dns_address == NULL ||
 696             order <= 0 ||
 697             order > NET_DNS_ADDR_MAX) {
 698                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 699                 return CONNECTION_ERROR_INVALID_PARAMETER;
 700         }
 701
 702         net_profile_info_t *profile_info = profile;
 703         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 704         if (net_info == NULL)
 705                 return CONNECTION_ERROR_OPERATION_FAILED;
 706
 707         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 708                 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
 709                                 address_family);
 710         else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) //LCOV_EXCL_LINE
 711                 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1], //LCOV_EXCL_LINE
 712                                 address_family);
 713
 714         if (*dns_address == NULL)
 715                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 716
 717         return CONNECTION_ERROR_NONE;
 718 }
 719
 720 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e *type)
 721 {
 722         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 723
 724         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 725                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 726                 return CONNECTION_ERROR_INVALID_PARAMETER;
 727         }
 728
 729         net_profile_info_t *profile_info = profile;
 730         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 731         if (net_info == NULL)
 732                 return CONNECTION_ERROR_OPERATION_FAILED;
 733
 734         //LCOV_EXCL_START
 735         if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
 736                 char *proxy = __profile_get_ethernet_proxy();
 737                 if (proxy == NULL) {
 738                         *type = CONNECTION_PROXY_TYPE_DIRECT;
 739                 } else {
 740                         *type = CONNECTION_PROXY_TYPE_MANUAL;
 741                         free(proxy);
 742                 }
 743
 744                 return CONNECTION_ERROR_NONE;
 745         }
 746         //LCOV_EXCL_STOP
 747
 748         switch (net_info->ProxyMethod) {
 749         //LCOV_EXCL_START
 750         case NET_PROXY_TYPE_DIRECT:
 751                 *type = CONNECTION_PROXY_TYPE_DIRECT;
 752                 break;
 753         case NET_PROXY_TYPE_AUTO:
 754                 *type = CONNECTION_PROXY_TYPE_AUTO;
 755                 break;
 756         case NET_PROXY_TYPE_MANUAL:
 757                 *type = CONNECTION_PROXY_TYPE_MANUAL;
 758                 break;
 759         case NET_PROXY_TYPE_UNKNOWN:
 760         default:
 761                 return CONNECTION_ERROR_OPERATION_FAILED;
 762         //LCOV_EXCL_STOP
 763         }
 764
 765         return CONNECTION_ERROR_NONE;
 766 }
 767
 768 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
 769                 connection_address_family_e address_family, char** proxy_address)
 770 {
 771         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 772
 773         if (!(_connection_libnet_check_profile_validity(profile)) ||
 774             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 775              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 776              proxy_address == NULL) {
 777                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 778                 return CONNECTION_ERROR_INVALID_PARAMETER;
 779         }
 780
 781         net_profile_info_t *profile_info = profile;
 782         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 783         if (net_info == NULL)
 784                 return CONNECTION_ERROR_OPERATION_FAILED;
 785
 786         *proxy_address = g_strdup(net_info->ProxyAddr);
 787
 788         if (*proxy_address == NULL)
 789                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 790
 791         return CONNECTION_ERROR_NONE;
 792 }
 793
 794 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
 795                 connection_address_family_e address_family, connection_ip_config_type_e type)
 796 {
 797         net_ip_config_type_t *profile_type = NULL;
 798
 799         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 800
 801         if (!(_connection_libnet_check_profile_validity(profile)) ||
 802             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 803              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 804                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 805                 return CONNECTION_ERROR_INVALID_PARAMETER;
 806         }
 807
 808         net_profile_info_t *profile_info = profile;
 809         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 810         if (net_info == NULL)
 811                 return CONNECTION_ERROR_OPERATION_FAILED;
 812
 813         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 814                 profile_type = &net_info->IpConfigType ;
 815         else
 816                 profile_type = &net_info->IpConfigType6 ;
 817
 818         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
 819                 switch (type) {
 820                 //LCOV_EXCL_START
 821                 case CONNECTION_IP_CONFIG_TYPE_STATIC:
 822                         *profile_type = NET_IP_CONFIG_TYPE_STATIC;
 823                         net_info->IpAddr.Data.Ipv4.s_addr = 0;
 824                         net_info->SubnetMask.Data.Ipv4.s_addr = 0;
 825                         net_info->GatewayAddr.Data.Ipv4.s_addr = 0 ;
 826                         break;
 827
 828                 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
 829                         *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
 830                         break;
 831
 832                 case CONNECTION_IP_CONFIG_TYPE_AUTO:
 833                         *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
 834                         break;
 835
 836                 case CONNECTION_IP_CONFIG_TYPE_FIXED:
 837                         net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
 838                         break;
 839
 840                 case CONNECTION_IP_CONFIG_TYPE_NONE:
 841                         *profile_type = NET_IP_CONFIG_TYPE_OFF;
 842                         break;
 843
 844                 default:
 845                         return CONNECTION_ERROR_INVALID_PARAMETER;
 846                 //LCOV_EXCL_STOP
 847                 }
 848         } else {
 849                 //LCOV_EXCL_START
 850                 switch (type) {
 851                 case CONNECTION_IP_CONFIG_TYPE_STATIC:
 852                         *profile_type = NET_IP_CONFIG_TYPE_STATIC;
 853                         inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
 854                         net_info->PrefixLen6 = 0 ;
 855                         inet_pton(AF_INET6, "::",
 856                                         &net_info->GatewayAddr6.Data.Ipv6);
 857                         break;
 858
 859                 case CONNECTION_IP_CONFIG_TYPE_AUTO:
 860                         *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
 861                         break;
 862
 863                 case CONNECTION_IP_CONFIG_TYPE_NONE:
 864                         *profile_type = NET_IP_CONFIG_TYPE_OFF;
 865                         break;
 866
 867                 default:
 868                         return CONNECTION_ERROR_INVALID_PARAMETER;
 869                 }
 870                 //LCOV_EXCL_STOP
 871         }
 872
 873         return CONNECTION_ERROR_NONE;
 874 }
 875
 876 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
 877                 connection_address_family_e address_family, const char* ip_address)
 878 {
 879         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 880
 881         if (!(_connection_libnet_check_profile_validity(profile)) ||
 882             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 883              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 884                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 885                 return CONNECTION_ERROR_INVALID_PARAMETER;
 886         }
 887
 888         net_profile_info_t *profile_info = profile;
 889         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 890         if (net_info == NULL)
 891                 return CONNECTION_ERROR_OPERATION_FAILED;
 892
 893         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 894                 //LCOV_EXCL_START
 895                 if (ip_address == NULL)
 896                         inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
 897                 else if (inet_pton(AF_INET6, ip_address,
 898                                         &net_info->IpAddr6.Data.Ipv6) < 1)
 899                         return CONNECTION_ERROR_INVALID_PARAMETER;
 900                 //LCOV_EXCL_STOP
 901         } else {
 902                 if (ip_address == NULL)
 903                         net_info->IpAddr.Data.Ipv4.s_addr = 0;
 904                 else if (inet_pton(AF_INET, ip_address,
 905                                         &net_info->IpAddr.Data.Ipv4) < 1)
 906                         return CONNECTION_ERROR_INVALID_PARAMETER;
 907         }
 908
 909         return CONNECTION_ERROR_NONE;
 910 }
 911
 912 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
 913                 connection_address_family_e address_family, const char* subnet_mask)
 914 {
 915         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 916
 917         if (!(_connection_libnet_check_profile_validity(profile)) ||
 918                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 919                          address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 920                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 921                 return CONNECTION_ERROR_INVALID_PARAMETER;
 922         }
 923
 924         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 925                 CONNECTION_LOG(CONNECTION_ERROR,
 926                                 "Please uses connection_profile_set_prefix_length()");
 927                 return CONNECTION_ERROR_NOT_SUPPORTED;
 928         }
 929
 930         net_profile_info_t *profile_info = profile;
 931         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 932         if (net_info == NULL)
 933                 return CONNECTION_ERROR_OPERATION_FAILED;
 934
 935         if (subnet_mask == NULL)
 936                 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
 937         else if (inet_pton(AF_INET, subnet_mask , &net_info->SubnetMask.Data.Ipv4) < 1)
 938                 return CONNECTION_ERROR_INVALID_PARAMETER;
 939
 940         net_info->PrefixLen = __profile_convert_netmask_to_prefix_len(subnet_mask);
 941
 942         return CONNECTION_ERROR_NONE;
 943 }
 944
 945 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
 946                 connection_address_family_e address_family, const char* gateway_address)
 947 {
 948         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 949
 950         if (!(_connection_libnet_check_profile_validity(profile)) ||
 951             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 952              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 953                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 954                 return CONNECTION_ERROR_INVALID_PARAMETER;
 955         }
 956
 957         net_profile_info_t *profile_info = profile;
 958         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 959         if (net_info == NULL)
 960                 return CONNECTION_ERROR_OPERATION_FAILED;
 961
 962         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 963                 //LCOV_EXCL_START
 964                 if (gateway_address == NULL)
 965                         inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6);
 966                 else if (inet_pton(AF_INET6, gateway_address, &net_info->GatewayAddr6.Data.Ipv6) < 1)
 967                         return CONNECTION_ERROR_INVALID_PARAMETER;
 968                 //LCOV_EXCL_STOP
 969         } else {
 970                 if (gateway_address == NULL)
 971                         net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
 972                 else if (inet_pton(AF_INET, gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) < 1)
 973                         return CONNECTION_ERROR_INVALID_PARAMETER;
 974         }
 975
 976         return CONNECTION_ERROR_NONE;
 977 }
 978
 979 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
 980                 connection_address_family_e address_family, const char* dns_address)
 981 {
 982         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 983
 984         if (!(_connection_libnet_check_profile_validity(profile)) ||
 985             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 986              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 987             order <= 0 ||
 988             order > NET_DNS_ADDR_MAX) {
 989                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 990                 return CONNECTION_ERROR_INVALID_PARAMETER;
 991         }
 992
 993         net_profile_info_t *profile_info = profile;
 994         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 995         if (net_info == NULL)
 996                 return CONNECTION_ERROR_OPERATION_FAILED;
 997
 998         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 999                 //LCOV_EXCL_START
1000                 net_info->DnsAddr6[order-1].Type = NET_ADDR_IPV6;
1001                 if (dns_address == NULL)
1002                         inet_pton(AF_INET6, "::", &net_info->DnsAddr6[order-1].Data.Ipv6);
1003                 else if (inet_pton(AF_INET6, dns_address, &net_info->DnsAddr6[order-1].Data.Ipv6) < 1)
1004                         return CONNECTION_ERROR_INVALID_PARAMETER;
1005                 if (net_info->DnsCount6 < order)
1006                         net_info->DnsCount6 = order;
1007                 //LCOV_EXCL_STOP
1008         } else {
1009                 net_info->DnsAddr[order-1].Type = NET_ADDR_IPV4;
1010                 if (dns_address == NULL)
1011                         net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
1012                 else if (inet_pton(AF_INET, dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) < 1)
1013                         return CONNECTION_ERROR_INVALID_PARAMETER;
1014                 if (net_info->DnsCount < order)
1015                         net_info->DnsCount = order;
1016         }
1017
1018         return CONNECTION_ERROR_NONE;
1019 }
1020
1021 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
1022 {
1023         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1024
1025         if (!(_connection_libnet_check_profile_validity(profile))) {
1026                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1027                 return CONNECTION_ERROR_INVALID_PARAMETER;
1028         }
1029
1030         net_profile_info_t *profile_info = profile;
1031         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1032         if (net_info == NULL)
1033                 return CONNECTION_ERROR_OPERATION_FAILED;
1034
1035         switch (type) {
1036         //LCOV_EXCL_START
1037         case CONNECTION_PROXY_TYPE_DIRECT:
1038                 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
1039                 break;
1040         case CONNECTION_PROXY_TYPE_AUTO:
1041                 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
1042                 break;
1043         case CONNECTION_PROXY_TYPE_MANUAL:
1044                 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
1045                 break;
1046         default:
1047                 return CONNECTION_ERROR_INVALID_PARAMETER;
1048         //LCOV_EXCL_STOP
1049         }
1050
1051         return CONNECTION_ERROR_NONE;
1052 }
1053
1054 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
1055                 connection_address_family_e address_family, const char* proxy_address)
1056 {
1057         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1058
1059         CONNECTION_LOG(CONNECTION_ERROR, "Address Family: ", address_family);
1060         if (!(_connection_libnet_check_profile_validity(profile)) ||
1061             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1062              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1063                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1064                 return CONNECTION_ERROR_INVALID_PARAMETER;
1065         }
1066
1067         net_profile_info_t *profile_info = profile;
1068         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1069         if (net_info == NULL)
1070                 return CONNECTION_ERROR_OPERATION_FAILED;
1071
1072         if (proxy_address == NULL)
1073                 net_info->ProxyAddr[0] = '\0';
1074         else
1075                 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
1076
1077         return CONNECTION_ERROR_NONE;
1078 }
1079
1080 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
1081                 connection_profile_state_changed_cb callback, void* user_data)
1082 {
1083         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1084
1085         if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
1086                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1087                 return CONNECTION_ERROR_INVALID_PARAMETER;
1088         }
1089
1090         if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
1091                 return CONNECTION_ERROR_NONE;
1092
1093         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1094 }
1095
1096 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
1097 {
1098         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1099
1100         if (!(_connection_libnet_check_profile_validity(profile))) {
1101                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1102                 return CONNECTION_ERROR_INVALID_PARAMETER;
1103         }
1104
1105         if (_connection_libnet_remove_from_profile_cb_list(profile) != true)
1106                 return CONNECTION_ERROR_INVALID_PARAMETER;
1107
1108         return CONNECTION_ERROR_NONE;
1109 }
1110
1111
1112 /* Wi-Fi profile *************************************************************/
1113 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
1114 {
1115         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1116
1117         if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
1118                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1119                 return CONNECTION_ERROR_INVALID_PARAMETER;
1120         }
1121
1122         net_profile_info_t *profile_info = profile;
1123
1124         if (profile_info->profile_type != NET_DEVICE_WIFI)
1125                 return CONNECTION_ERROR_INVALID_PARAMETER;
1126
1127         *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
1128         if (*essid == NULL)
1129                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1130
1131         return CONNECTION_ERROR_NONE;
1132 }
1133
1134 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
1135 {
1136         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1137
1138         if (!(_connection_libnet_check_profile_validity(profile)) || bssid == 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         *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
1149         if (*bssid == NULL)
1150                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1151
1152         return CONNECTION_ERROR_NONE;
1153 }
1154
1155 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
1156 {
1157         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1158
1159         if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
1160                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1161                 return CONNECTION_ERROR_INVALID_PARAMETER;
1162         }
1163
1164         net_profile_info_t *profile_info = profile;
1165
1166         if (profile_info->profile_type != NET_DEVICE_WIFI)
1167                 return CONNECTION_ERROR_INVALID_PARAMETER;
1168
1169         *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
1170
1171         return CONNECTION_ERROR_NONE;
1172 }
1173
1174 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
1175 {
1176         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1177
1178         if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
1179                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1180                 return CONNECTION_ERROR_INVALID_PARAMETER;
1181         }
1182
1183         net_profile_info_t *profile_info = profile;
1184
1185         if (profile_info->profile_type != NET_DEVICE_WIFI)
1186                 return CONNECTION_ERROR_INVALID_PARAMETER;
1187
1188         *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
1189
1190         return CONNECTION_ERROR_NONE;
1191 }
1192
1193 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
1194 {
1195         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1196
1197         if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
1198                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1199                 return CONNECTION_ERROR_INVALID_PARAMETER;
1200         }
1201
1202         net_profile_info_t *profile_info = profile;
1203
1204         if (profile_info->profile_type != NET_DEVICE_WIFI)
1205                 return CONNECTION_ERROR_INVALID_PARAMETER;
1206
1207         *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate / 1000000;
1208
1209         return CONNECTION_ERROR_NONE;
1210 }
1211
1212 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e *type)
1213 {
1214         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1215
1216         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1217                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1218                 return CONNECTION_ERROR_INVALID_PARAMETER;
1219         }
1220
1221         net_profile_info_t *profile_info = profile;
1222
1223         if (profile_info->profile_type != NET_DEVICE_WIFI)
1224                 return CONNECTION_ERROR_INVALID_PARAMETER;
1225
1226         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1227         //LCOV_EXCL_START
1228         case WLAN_SEC_MODE_NONE:
1229                 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
1230                 break;
1231         case WLAN_SEC_MODE_WEP:
1232                 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
1233                 break;
1234         case WLAN_SEC_MODE_IEEE8021X:
1235                 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
1236                 break;
1237         case WLAN_SEC_MODE_WPA_PSK:
1238                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
1239                 break;
1240         case WLAN_SEC_MODE_WPA2_PSK:
1241                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
1242                 break;
1243         default:
1244                 return CONNECTION_ERROR_OPERATION_FAILED;
1245         //LCOV_EXCL_STOP
1246         }
1247
1248         return CONNECTION_ERROR_NONE;
1249 }
1250
1251 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e *type)
1252 {
1253         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1254
1255         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1256                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1257                 return CONNECTION_ERROR_INVALID_PARAMETER;
1258         }
1259
1260         net_profile_info_t *profile_info = profile;
1261
1262         if (profile_info->profile_type != NET_DEVICE_WIFI)
1263                 return CONNECTION_ERROR_INVALID_PARAMETER;
1264
1265         switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1266         //LCOV_EXCL_START
1267         case WLAN_ENC_MODE_NONE:
1268                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1269                 break;
1270         case WLAN_ENC_MODE_WEP:
1271                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1272                 break;
1273         case WLAN_ENC_MODE_TKIP:
1274                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1275                 break;
1276         case WLAN_ENC_MODE_AES:
1277                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1278                 break;
1279         case WLAN_ENC_MODE_TKIP_AES_MIXED:
1280                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1281                 break;
1282         default:
1283                 return CONNECTION_ERROR_OPERATION_FAILED;
1284         //LCOV_EXCL_STOP
1285         }
1286
1287         return CONNECTION_ERROR_NONE;
1288 }
1289
1290 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1291 {
1292         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1293
1294         if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1295                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1296                 return CONNECTION_ERROR_INVALID_PARAMETER;
1297         }
1298
1299         net_profile_info_t *profile_info = profile;
1300
1301         if (profile_info->profile_type != NET_DEVICE_WIFI)
1302                 return CONNECTION_ERROR_INVALID_PARAMETER;
1303
1304         if (profile_info->Favourite) {
1305                 *required = false;
1306                 return CONNECTION_ERROR_NONE;
1307         }
1308
1309         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1310         //LCOV_EXCL_START
1311         case WLAN_SEC_MODE_NONE:
1312                 *required = false;
1313                 break;
1314         case WLAN_SEC_MODE_WEP:
1315         case WLAN_SEC_MODE_IEEE8021X:
1316         case WLAN_SEC_MODE_WPA_PSK:
1317         case WLAN_SEC_MODE_WPA2_PSK:
1318                 *required = true;
1319                 break;
1320         default:
1321                 return CONNECTION_ERROR_OPERATION_FAILED;
1322         //LCOV_EXCL_STOP
1323         }
1324
1325         return CONNECTION_ERROR_NONE;
1326 }
1327
1328 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1329 {
1330         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1331
1332         if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1333                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1334                 return CONNECTION_ERROR_INVALID_PARAMETER;
1335         }
1336
1337         net_profile_info_t *profile_info = profile;
1338
1339         if (profile_info->profile_type != NET_DEVICE_WIFI)
1340                 return CONNECTION_ERROR_INVALID_PARAMETER;
1341
1342         g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1343                                                 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1344
1345         return CONNECTION_ERROR_NONE;
1346 }
1347
1348 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1349 {
1350         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1351
1352         if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1353                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1354                 return CONNECTION_ERROR_INVALID_PARAMETER;
1355         }
1356
1357         net_profile_info_t *profile_info = profile;
1358
1359         if (profile_info->profile_type != NET_DEVICE_WIFI)
1360                 return CONNECTION_ERROR_INVALID_PARAMETER;
1361
1362         if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1363                 *supported = true;
1364         else
1365                 *supported = false;
1366
1367         return CONNECTION_ERROR_NONE;
1368 }
1369
1370
1371 /* Cellular profile **********************************************************/
1372 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1373                                                 connection_cellular_service_type_e* type)
1374 {
1375         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1376
1377         if (!(_connection_libnet_check_profile_validity(profile)) || type == 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_CELLULAR) {
1385                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1386                 return CONNECTION_ERROR_INVALID_PARAMETER;
1387         }
1388
1389         *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1390
1391         if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1392                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed"); //LCOV_EXCL_LINE
1393                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1394         }
1395
1396         return CONNECTION_ERROR_NONE;
1397 }
1398
1399 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1400 {
1401         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1402
1403         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1404                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1405                 return CONNECTION_ERROR_INVALID_PARAMETER;
1406         }
1407
1408         net_profile_info_t *profile_info = profile;
1409
1410         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1411                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1412                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1413         }
1414
1415         *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1416         if (*apn == NULL)
1417                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1418
1419         return CONNECTION_ERROR_NONE;
1420 }
1421
1422 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1423                 connection_cellular_auth_type_e *type, char** user_name, char** password)
1424 {
1425         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1426
1427         if (!(_connection_libnet_check_profile_validity(profile)) ||
1428             type == NULL || user_name == NULL || password == 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");
1437                 return CONNECTION_ERROR_INVALID_PARAMETER;
1438         }
1439
1440         switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1441         //LCOV_EXCL_START
1442         case NET_PDP_AUTH_NONE:
1443                 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1444                 break;
1445         case NET_PDP_AUTH_PAP:
1446                 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1447                 break;
1448         case NET_PDP_AUTH_CHAP:
1449                 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1450                 break;
1451         default:
1452                 return CONNECTION_ERROR_OPERATION_FAILED;
1453         //LCOV_EXCL_STOP
1454         }
1455
1456         *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1457         if (*user_name == NULL)
1458                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1459
1460         *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1461         if (*password == NULL) {
1462                 g_free(*user_name); //LCOV_EXCL_LINE
1463                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1464         }
1465
1466         return CONNECTION_ERROR_NONE;
1467 }
1468
1469 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1470 {
1471         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1472
1473         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1474                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1475                 return CONNECTION_ERROR_INVALID_PARAMETER;
1476         }
1477
1478         net_profile_info_t *profile_info = profile;
1479
1480         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1481                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1482                 return CONNECTION_ERROR_INVALID_PARAMETER;
1483         }
1484
1485         *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1486         if (*home_url == NULL)
1487                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1488
1489         return CONNECTION_ERROR_NONE;
1490 }
1491
1492 EXPORT_API int connection_profile_get_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1493 {
1494         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1495
1496         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1497                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1498                 return CONNECTION_ERROR_INVALID_PARAMETER;
1499         }
1500
1501         net_profile_info_t *profile_info = profile;
1502
1503         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1504                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1505                 return CONNECTION_ERROR_INVALID_PARAMETER;
1506         }
1507
1508         switch (profile_info->ProfileInfo.Pdp.PdnType) {
1509         //LCOV_EXCL_START
1510         case NET_PDN_TYPE_UNKNOWN:
1511                 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1512                 break;
1513         case NET_PDN_TYPE_IPV4:
1514                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1515                 break;
1516         case NET_PDN_TYPE_IPV6:
1517                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1518                 break;
1519         case NET_PDN_TYPE_IPV4_IPV6:
1520                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1521                 break;
1522         default:
1523                 return CONNECTION_ERROR_OPERATION_FAILED;
1524         //LCOV_EXCL_STOP
1525         }
1526
1527         return CONNECTION_ERROR_NONE;
1528 }
1529
1530 EXPORT_API int connection_profile_get_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1531 {
1532         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1533
1534         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1535                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1536                 return CONNECTION_ERROR_INVALID_PARAMETER;
1537         }
1538
1539         net_profile_info_t *profile_info = profile;
1540
1541         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1542                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1543                 return CONNECTION_ERROR_INVALID_PARAMETER;
1544         }
1545
1546         switch (profile_info->ProfileInfo.Pdp.RoamPdnType) {
1547         //LCOV_EXCL_START
1548         case NET_PDN_TYPE_UNKNOWN:
1549                 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1550                 break;
1551         case NET_PDN_TYPE_IPV4:
1552                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1553                 break;
1554         case NET_PDN_TYPE_IPV6:
1555                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1556                 break;
1557         case NET_PDN_TYPE_IPV4_IPV6:
1558                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1559                 break;
1560         default:
1561                 return CONNECTION_ERROR_OPERATION_FAILED;
1562         //LCOV_EXCL_STOP
1563         }
1564
1565         return CONNECTION_ERROR_NONE;
1566 }
1567
1568 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1569 {
1570         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1571
1572         if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1573                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1574                 return CONNECTION_ERROR_INVALID_PARAMETER;
1575         }
1576
1577         net_profile_info_t *profile_info = profile;
1578
1579         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1580                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1581                 return CONNECTION_ERROR_INVALID_PARAMETER;
1582         }
1583
1584         if (profile_info->ProfileInfo.Pdp.Roaming)
1585                 *is_roaming = true;
1586         else
1587                 *is_roaming = false;
1588
1589         return CONNECTION_ERROR_NONE;
1590 }
1591
1592 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
1593 {
1594         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1595
1596         if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
1597                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1598                 return CONNECTION_ERROR_INVALID_PARAMETER;
1599         }
1600
1601         net_profile_info_t *profile_info = profile;
1602
1603         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1604                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1605                 return CONNECTION_ERROR_INVALID_PARAMETER;
1606         }
1607
1608         if (profile_info->ProfileInfo.Pdp.Hidden)
1609                 *is_hidden = true;
1610         else
1611                 *is_hidden = false;
1612
1613         return CONNECTION_ERROR_NONE;
1614 }
1615
1616 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
1617 {
1618         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1619
1620         if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
1621                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1622                 return CONNECTION_ERROR_INVALID_PARAMETER;
1623         }
1624
1625         net_profile_info_t *profile_info = profile;
1626
1627         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1628                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1629                 return CONNECTION_ERROR_INVALID_PARAMETER;
1630         }
1631
1632         if (profile_info->ProfileInfo.Pdp.Editable)
1633                 *is_editable = true;
1634         else
1635                 *is_editable = false;
1636
1637         return CONNECTION_ERROR_NONE;
1638 }
1639
1640 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
1641 {
1642         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1643
1644         if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
1645                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1646                 return CONNECTION_ERROR_INVALID_PARAMETER;
1647         }
1648
1649         net_profile_info_t *profile_info = profile;
1650
1651         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1652                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1653                 return CONNECTION_ERROR_INVALID_PARAMETER;
1654         }
1655
1656         if (profile_info->ProfileInfo.Pdp.DefaultConn)
1657                 *is_default = true;
1658         else
1659                 *is_default = false;
1660
1661         return CONNECTION_ERROR_NONE;
1662 }
1663
1664 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
1665                 connection_cellular_service_type_e service_type)
1666 {
1667         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1668
1669         if (!(_connection_libnet_check_profile_validity(profile))) {
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         switch (service_type) {
1682         //LCOV_EXCL_START
1683         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1684                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1685                 break;
1686         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1687                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1688                 break;
1689         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1690                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1691                 break;
1692         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1693                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1694                 break;
1695         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1696                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1697                 break;
1698         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1699                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1700                 break;
1701         case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1702         default:
1703                 return CONNECTION_ERROR_INVALID_PARAMETER;
1704         //LCOV_EXCL_STOP
1705         }
1706
1707         return CONNECTION_ERROR_NONE;
1708 }
1709
1710 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1711 {
1712         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1713
1714         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1715                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1716                 return CONNECTION_ERROR_INVALID_PARAMETER;
1717         }
1718
1719         net_profile_info_t *profile_info = profile;
1720
1721         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1722                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1723                 return CONNECTION_ERROR_INVALID_PARAMETER;
1724         }
1725
1726         g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1727
1728         return CONNECTION_ERROR_NONE;
1729 }
1730
1731 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
1732                 connection_cellular_auth_type_e type, const char* user_name, const char* password)
1733 {
1734         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1735
1736         if (!(_connection_libnet_check_profile_validity(profile)) ||
1737             user_name == NULL || password == NULL) {
1738                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1739                 return CONNECTION_ERROR_INVALID_PARAMETER;
1740         }
1741
1742         net_profile_info_t *profile_info = profile;
1743
1744         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1745                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1746                 return CONNECTION_ERROR_INVALID_PARAMETER;
1747         }
1748
1749         switch (type) {
1750         //LCOV_EXCL_START
1751         case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1752                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1753                 break;
1754         case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1755                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1756                 break;
1757         case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1758                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1759                 break;
1760         default:
1761                 return CONNECTION_ERROR_INVALID_PARAMETER;
1762         //LCOV_EXCL_STOP
1763         }
1764
1765         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
1766         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
1767
1768         return CONNECTION_ERROR_NONE;
1769 }
1770
1771 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1772 {
1773         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1774
1775         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1776                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1777                 return CONNECTION_ERROR_INVALID_PARAMETER;
1778         }
1779
1780         net_profile_info_t *profile_info = profile;
1781
1782         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1783                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1784                 return CONNECTION_ERROR_INVALID_PARAMETER;
1785         }
1786
1787         g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1788
1789         return CONNECTION_ERROR_NONE;
1790 }
1791
1792 EXPORT_API int connection_profile_set_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
1793 {
1794         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1795
1796         if (!(_connection_libnet_check_profile_validity(profile))) {
1797                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1798                 return CONNECTION_ERROR_INVALID_PARAMETER;
1799         }
1800
1801         net_profile_info_t *profile_info = profile;
1802
1803         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1804                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1805                 return CONNECTION_ERROR_INVALID_PARAMETER;
1806         }
1807
1808         switch (type) {
1809         //LCOV_EXCL_START
1810         case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
1811                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4;
1812                 break;
1813         case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
1814                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV6;
1815                 break;
1816         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
1817                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
1818                 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
1819                                                 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
1820                 break;
1821         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
1822                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
1823                 break;
1824         default:
1825                 return CONNECTION_ERROR_INVALID_PARAMETER;
1826         //LCOV_EXCL_STOP
1827         }
1828
1829         return CONNECTION_ERROR_NONE;
1830 }
1831
1832 EXPORT_API int connection_profile_set_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
1833 {
1834         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1835
1836         if (!(_connection_libnet_check_profile_validity(profile))) {
1837                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1838                 return CONNECTION_ERROR_INVALID_PARAMETER;
1839         }
1840
1841         net_profile_info_t *profile_info = profile;
1842
1843         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1844                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1845                 return CONNECTION_ERROR_INVALID_PARAMETER;
1846         }
1847
1848         switch (type) {
1849         //LCOV_EXCL_START
1850         case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
1851                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4;
1852                 break;
1853         case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
1854                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV6;
1855                 break;
1856         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
1857                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
1858                 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
1859                                                 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
1860                 break;
1861         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
1862                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
1863                 break;
1864         default:
1865                 return CONNECTION_ERROR_INVALID_PARAMETER;
1866         //LCOV_EXCL_STOP
1867         }
1868
1869         return CONNECTION_ERROR_NONE;
1870 }
1871
1872 EXPORT_API int connection_profile_get_ipv6_state(connection_profile_h profile, connection_profile_state_e *state)
1873 {
1874         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1875                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1876
1877         if (!(_connection_libnet_check_profile_validity(profile)) ||
1878                         state == NULL) {
1879                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1880                 return CONNECTION_ERROR_INVALID_PARAMETER;
1881         }
1882
1883         net_profile_info_t *profile_info = profile;
1884         *state = _profile_convert_to_cp_state(profile_info->ProfileState6);
1885         if (*state < 0)
1886                 return CONNECTION_ERROR_OPERATION_FAILED;
1887
1888         return CONNECTION_ERROR_NONE;
1889 }
1890
1891 EXPORT_API int connection_profile_set_dns_config_type(connection_profile_h profile,
1892                 connection_address_family_e address_family, connection_dns_config_type_e type)
1893 {
1894         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1895                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1896
1897         if (!(_connection_libnet_check_profile_validity(profile))) {
1898                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1899                 return CONNECTION_ERROR_INVALID_PARAMETER;
1900         }
1901
1902         if ((address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1903                                 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1904                         (type != CONNECTION_DNS_CONFIG_TYPE_STATIC &&
1905                          type != CONNECTION_DNS_CONFIG_TYPE_DYNAMIC)) {
1906                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1907                 return CONNECTION_ERROR_INVALID_PARAMETER;
1908         }
1909
1910         net_dns_config_type_t *profileType = NULL;
1911         net_dns_config_type_t *profileType6 = NULL;
1912         net_profile_info_t *profile_info = profile;
1913
1914         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1915         if (net_info == NULL)
1916                 return CONNECTION_ERROR_OPERATION_FAILED;
1917
1918         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1919                 profileType = &net_info->DnsConfigType;
1920                 net_info->DnsAddr[0].Data.Ipv4.s_addr = 0;
1921                 net_info->DnsAddr[1].Data.Ipv4.s_addr = 0;
1922                 *profileType = type;
1923         } else {
1924                 profileType6 = &net_info->DnsConfigType6;
1925                 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[0].Data.Ipv6);
1926                 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[1].Data.Ipv6);
1927                 *profileType6 = type;
1928         }
1929
1930         return CONNECTION_ERROR_NONE;
1931 }
1932
1933 EXPORT_API int connection_profile_get_dns_config_type(connection_profile_h profile,
1934                 connection_address_family_e address_family, connection_dns_config_type_e *type)
1935 {
1936         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1937                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1938
1939         if (!(_connection_libnet_check_profile_validity(profile)) ||
1940                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1941                          address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1942                         type == NULL) {
1943                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1944                 return CONNECTION_ERROR_INVALID_PARAMETER;
1945         }
1946
1947         net_dns_config_type_t profileType;
1948         net_profile_info_t *profile_info = profile;
1949         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1950         if (net_info == NULL)
1951                 return CONNECTION_ERROR_OPERATION_FAILED;
1952
1953         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
1954                 profileType = net_info->DnsConfigType;
1955         else
1956                 profileType = net_info->DnsConfigType6;
1957
1958         switch (profileType) {
1959         case NET_DNS_CONFIG_TYPE_STATIC:
1960                 *type = CONNECTION_DNS_CONFIG_TYPE_STATIC;
1961                 break;
1962         case NET_DNS_CONFIG_TYPE_DYNAMIC:
1963                 *type = CONNECTION_DNS_CONFIG_TYPE_DYNAMIC;
1964                 break;
1965         default:
1966                 *type = CONNECTION_DNS_CONFIG_TYPE_NONE;
1967                 break;
1968         }
1969
1970         return CONNECTION_ERROR_NONE;
1971 }
1972
1973 EXPORT_API int connection_profile_set_prefix_length(connection_profile_h profile,
1974                 connection_address_family_e address_family, int prefix_len)
1975 {
1976         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
1977                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1978
1979         if (!(_connection_libnet_check_profile_validity(profile)) ||
1980                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1981                         address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1982                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1983                 return CONNECTION_ERROR_INVALID_PARAMETER;
1984         }
1985
1986         net_profile_info_t *profile_info = profile;
1987         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1988         if (net_info == NULL)
1989                 return CONNECTION_ERROR_OPERATION_FAILED;
1990
1991         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1992                 net_info->PrefixLen = prefix_len;
1993                 net_info->SubnetMask.Data.Ipv4.s_addr = __profile_convert_prefix_len_to_netmask(prefix_len);
1994         } else
1995                 net_info->PrefixLen6 = prefix_len;
1996
1997         return CONNECTION_ERROR_NONE;
1998 }
1999
2000 EXPORT_API int connection_profile_get_prefix_length(connection_profile_h profile,
2001                 connection_address_family_e address_family, int *prefix_len)
2002 {
2003         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2004                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2005
2006         if (!(_connection_libnet_check_profile_validity(profile)) ||
2007                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2008                         address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2009                         prefix_len == NULL) {
2010                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2011                 return CONNECTION_ERROR_INVALID_PARAMETER;
2012         }
2013
2014         net_profile_info_t *profile_info = profile;
2015         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2016         if (net_info == NULL)
2017                 return CONNECTION_ERROR_OPERATION_FAILED;
2018
2019         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
2020                 *prefix_len =  net_info->PrefixLen;
2021         else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
2022                 *prefix_len =  net_info->PrefixLen6;
2023
2024         return CONNECTION_ERROR_NONE;
2025 }