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