src/connection_profile.c

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