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