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