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