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