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