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 //LCOV_EXCL_START
 125 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
 126 {
 127         switch (svc_type) {
 128         case NET_SERVICE_INTERNET:
 129                 return CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
 130         case NET_SERVICE_MMS:
 131                 return CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
 132         case NET_SERVICE_PREPAID_INTERNET:
 133                 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
 134         case NET_SERVICE_PREPAID_MMS:
 135                 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
 136         case NET_SERVICE_TETHERING:
 137                 return CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
 138         case NET_SERVICE_APPLICATION:
 139                 return CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
 140         default:
 141                 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
 142         }
 143 }
 144
 145 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
 146 {
 147         connection_profile_state_e cp_state;
 148
 149         switch (state) {
 150         case NET_STATE_TYPE_ONLINE:
 151         case NET_STATE_TYPE_READY:
 152                 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
 153                 break;
 154         case NET_STATE_TYPE_IDLE:
 155         case NET_STATE_TYPE_FAILURE:
 156         case NET_STATE_TYPE_DISCONNECT:
 157                 cp_state = CONNECTION_PROFILE_STATE_DISCONNECTED;
 158                 break;
 159         case NET_STATE_TYPE_ASSOCIATION:
 160                 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
 161                 break;
 162         case NET_STATE_TYPE_CONFIGURATION:
 163                 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
 164                 break;
 165         default:
 166                 cp_state = -1;
 167         }
 168
 169         return cp_state;
 170 }
 171
 172 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
 173 {
 174         switch (svc_type) {
 175         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
 176                 return NET_SERVICE_INTERNET;
 177         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
 178                 return NET_SERVICE_MMS;
 179         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
 180                 return NET_SERVICE_PREPAID_INTERNET;
 181         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
 182                 return NET_SERVICE_PREPAID_MMS;
 183         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
 184                 return NET_SERVICE_TETHERING;
 185         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
 186                 return NET_SERVICE_APPLICATION;
 187         default:
 188                 return NET_SERVICE_UNKNOWN;
 189         }
 190 }
 191
 192 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
 193 {
 194         net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
 195
 196         switch (state) {
 197         case CONNECTION_PROFILE_STATE_CONNECTED:
 198                 libnet_state = NET_STATE_TYPE_ONLINE;
 199                 break;
 200         case CONNECTION_PROFILE_STATE_DISCONNECTED:
 201                 libnet_state = NET_STATE_TYPE_IDLE;
 202                 break;
 203         case CONNECTION_PROFILE_STATE_ASSOCIATION:
 204                 libnet_state = NET_STATE_TYPE_ASSOCIATION;
 205                 break;
 206         case CONNECTION_PROFILE_STATE_CONFIGURATION:
 207                 libnet_state = NET_STATE_TYPE_CONFIGURATION;
 208                 break;
 209         }
 210
 211         return libnet_state;
 212 }
 213 //LCOV_EXCL_STOP
 214
 215 /* Connection profile ********************************************************/
 216 EXPORT_API int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
 217 {
 218         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
 219
 220         if (type == CONNECTION_PROFILE_TYPE_CELLULAR)
 221                 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 222         else if (type == CONNECTION_PROFILE_TYPE_WIFI)
 223                 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 224
 225         if (type != CONNECTION_PROFILE_TYPE_CELLULAR &&
 226              type != CONNECTION_PROFILE_TYPE_WIFI) {
 227                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 228                 return CONNECTION_ERROR_INVALID_PARAMETER;
 229         }
 230
 231         if (profile == NULL) {
 232                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 233                 return CONNECTION_ERROR_INVALID_PARAMETER;
 234         }
 235
 236         int rv  = _connection_libnet_check_profile_privilege();
 237         if (rv == CONNECTION_ERROR_PERMISSION_DENIED)
 238                 return rv;
 239         else if (rv != CONNECTION_ERROR_NONE) {
 240                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create profile"); //LCOV_EXCL_LINE
 241                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 242         }
 243
 244         net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
 245         if (profile_info == NULL)
 246                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 247
 248         switch (type) {
 249         case CONNECTION_PROFILE_TYPE_CELLULAR:
 250                 if (keyword == NULL) {
 251                         CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 252                         g_free(profile_info);
 253                         return CONNECTION_ERROR_INVALID_PARAMETER;
 254                 }
 255                 __profile_init_cellular_profile(profile_info, keyword);
 256                 break;
 257         case CONNECTION_PROFILE_TYPE_WIFI:
 258                 __profile_init_wifi_profile(profile_info);
 259                 break;
 260         default:
 261                 break;
 262         }
 263
 264         *profile = (connection_profile_h)profile_info;
 265         _connection_libnet_add_to_profile_list(*profile);
 266
 267         return CONNECTION_ERROR_NONE;
 268 }
 269
 270 EXPORT_API int connection_profile_destroy(connection_profile_h profile)
 271 {
 272         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 273
 274         if (!(_connection_libnet_check_profile_validity(profile))) {
 275                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 276                 return CONNECTION_ERROR_INVALID_PARAMETER;
 277         }
 278
 279         _connection_libnet_remove_from_profile_list(profile);
 280
 281         return CONNECTION_ERROR_NONE;
 282 }
 283
 284 EXPORT_API int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
 285 {
 286         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 287
 288         if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
 289                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 290                 return CONNECTION_ERROR_INVALID_PARAMETER;
 291         }
 292
 293         *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
 294         if (*cloned_profile == NULL)
 295                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 296
 297         memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
 298         _connection_libnet_add_to_profile_list(*cloned_profile);
 299
 300         return CONNECTION_ERROR_NONE;
 301 }
 302
 303 EXPORT_API int connection_profile_get_id(connection_profile_h profile, char** profile_id)
 304 {
 305         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 306
 307         if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
 308                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 309                 return CONNECTION_ERROR_INVALID_PARAMETER;
 310         }
 311
 312         net_profile_info_t *profile_info = profile;
 313
 314         char *prof_id = strrchr(profile_info->ProfileName, '/');
 315         if (prof_id == NULL)
 316                 return CONNECTION_ERROR_INVALID_PARAMETER;
 317
 318         prof_id++;
 319         *profile_id = g_strdup(prof_id);
 320
 321         if (*profile_id == NULL)
 322                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 323
 324         return CONNECTION_ERROR_NONE;
 325 }
 326
 327 EXPORT_API int connection_profile_get_name(connection_profile_h profile, char** profile_name)
 328 {
 329         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 330
 331         if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
 332                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 333                 return CONNECTION_ERROR_INVALID_PARAMETER;
 334         }
 335
 336         net_profile_info_t *profile_info = profile;
 337
 338         switch (profile_info->profile_type) {
 339         case NET_DEVICE_CELLULAR:
 340                 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
 341                 break;
 342         case NET_DEVICE_WIFI:
 343                 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
 344                 break;
 345         case NET_DEVICE_ETHERNET:
 346                 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName); //LCOV_EXCL_LINE
 347                 break; //LCOV_EXCL_LINE
 348         case NET_DEVICE_BLUETOOTH: {
 349                 char *bt_name = strrchr(profile_info->ProfileName, '/');
 350                 if (bt_name == NULL)
 351                         return CONNECTION_ERROR_INVALID_PARAMETER;
 352
 353                 bt_name++;
 354                 *profile_name = g_strdup(bt_name);
 355         } break;
 356         default:
 357                 return CONNECTION_ERROR_INVALID_PARAMETER;
 358         }
 359
 360         if (*profile_name == NULL)
 361                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 362
 363         return CONNECTION_ERROR_NONE;
 364 }
 365
 366 EXPORT_API int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e *type)
 367 {
 368         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 369
 370         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 371                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 372                 return CONNECTION_ERROR_INVALID_PARAMETER;
 373         }
 374
 375         net_profile_info_t *profile_info = profile;
 376
 377         switch (profile_info->profile_type) {
 378         case NET_DEVICE_CELLULAR:
 379                 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
 380                 break;
 381         case NET_DEVICE_WIFI:
 382                 *type = CONNECTION_PROFILE_TYPE_WIFI;
 383                 break;
 384         case NET_DEVICE_ETHERNET:
 385                 *type = CONNECTION_PROFILE_TYPE_ETHERNET; //LCOV_EXCL_LINE
 386                 break; //LCOV_EXCL_LINE
 387         case NET_DEVICE_BLUETOOTH:
 388                 *type = CONNECTION_PROFILE_TYPE_BT;
 389                 break;
 390         default:
 391                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type");
 392                 return CONNECTION_ERROR_OPERATION_FAILED;
 393         }
 394
 395         return CONNECTION_ERROR_NONE;
 396 }
 397
 398 EXPORT_API int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
 399 {
 400         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 401
 402         if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
 403                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 404                 return CONNECTION_ERROR_INVALID_PARAMETER;
 405         }
 406
 407         net_profile_info_t *profile_info = profile;
 408         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 409         if (net_info == NULL)
 410                 return CONNECTION_ERROR_INVALID_PARAMETER;
 411
 412         *interface_name = g_strdup(net_info->DevName);
 413         if (*interface_name == NULL)
 414                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 415
 416         return CONNECTION_ERROR_NONE;
 417 }
 418
 419 EXPORT_API int connection_profile_refresh(connection_profile_h profile)
 420 {
 421         int rv;
 422
 423         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 424
 425         if (!(_connection_libnet_check_profile_validity(profile))) {
 426                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 427                 return CONNECTION_ERROR_INVALID_PARAMETER;
 428         }
 429
 430         net_profile_info_t profile_info_local;
 431         net_profile_info_t *profile_info = profile;
 432
 433         rv = net_get_profile_info(profile_info->ProfileName, &profile_info_local);
 434         if (rv == NET_ERR_ACCESS_DENIED) {
 435                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 436                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 437         } else if (rv != NET_ERR_NONE) {
 438                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get profile information"); //LCOV_EXCL_LINE
 439                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 440         }
 441
 442         memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
 443
 444         return CONNECTION_ERROR_NONE;
 445 }
 446
 447 EXPORT_API int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
 448 {
 449         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 450
 451         if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
 452                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 453                 return CONNECTION_ERROR_INVALID_PARAMETER;
 454         }
 455
 456         net_profile_info_t *profile_info = profile;
 457         *state = _profile_convert_to_cp_state(profile_info->ProfileState);
 458
 459         return CONNECTION_ERROR_NONE;
 460 }
 461
 462 EXPORT_API int connection_profile_get_ip_config_type(connection_profile_h profile,
 463                 connection_address_family_e address_family, connection_ip_config_type_e *type)
 464 {
 465         net_ip_config_type_t profile_type;
 466
 467         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 468
 469         if (!(_connection_libnet_check_profile_validity(profile)) ||
 470             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 471              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 472             type == NULL) {
 473                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 474                 return CONNECTION_ERROR_INVALID_PARAMETER;
 475         }
 476
 477         net_profile_info_t *profile_info = profile;
 478         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 479         if (net_info == NULL)
 480                 return CONNECTION_ERROR_OPERATION_FAILED;
 481
 482         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 483                 profile_type = net_info->IpConfigType;
 484         else
 485                 profile_type = net_info->IpConfigType6;
 486
 487         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
 488                 switch (profile_type) {
 489                 //LCOV_EXCL_START
 490                 case NET_IP_CONFIG_TYPE_STATIC:
 491                         *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
 492                         break;
 493
 494                 case NET_IP_CONFIG_TYPE_DYNAMIC:
 495                         *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
 496                         break;
 497
 498                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 499                         *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 500                         break;
 501
 502                 case NET_IP_CONFIG_TYPE_FIXED:
 503                         *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
 504                         break;
 505
 506                 case NET_IP_CONFIG_TYPE_OFF:
 507                         *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 508                         break;
 509                 default:
 510                         return CONNECTION_ERROR_OPERATION_FAILED;
 511                 //LCOV_EXCL_STOP
 512                 }
 513         } else {
 514                 //LCOV_EXCL_START
 515                 switch (profile_type) {
 516                 case NET_IP_CONFIG_TYPE_STATIC:
 517                         *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
 518                         break;
 519
 520                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 521                         *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 522                         break;
 523
 524                 case NET_IP_CONFIG_TYPE_OFF:
 525                         *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 526                         break;
 527
 528                 default:
 529                         return  CONNECTION_ERROR_OPERATION_FAILED;
 530
 531                 }
 532                 //LCOV_EXCL_STOP
 533         }
 534
 535         return CONNECTION_ERROR_NONE;
 536 }
 537
 538 EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
 539                 connection_address_family_e address_family, char** ip_address)
 540 {
 541         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 542
 543         if (!(_connection_libnet_check_profile_validity(profile)) ||
 544             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 545              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 546             ip_address == NULL) {
 547                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 548                 return CONNECTION_ERROR_INVALID_PARAMETER;
 549         }
 550
 551         net_profile_info_t *profile_info = profile;
 552         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 553         if (net_info == NULL)
 554                 return CONNECTION_ERROR_OPERATION_FAILED;
 555
 556         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 557                 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr6,
 558                                 address_family);
 559         else
 560                 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
 561                                 address_family);
 562
 563         if (*ip_address == NULL)
 564                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 565
 566         return CONNECTION_ERROR_NONE;
 567 }
 568
 569 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
 570                 connection_address_family_e address_family, char** subnet_mask)
 571 {
 572         char* prefixlen;
 573
 574         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 575
 576         if (!(_connection_libnet_check_profile_validity(profile)) ||
 577             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 578              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 579             subnet_mask == NULL) {
 580                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 581                 return CONNECTION_ERROR_INVALID_PARAMETER;
 582         }
 583
 584         net_profile_info_t *profile_info = profile;
 585         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 586         if (net_info == NULL)
 587                 return CONNECTION_ERROR_OPERATION_FAILED;
 588
 589         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 590                 //LCOV_EXCL_START
 591                 prefixlen = g_try_malloc0(MAX_PREFIX_LENGTH);
 592                 if (prefixlen != NULL) {
 593                         snprintf(prefixlen, MAX_PREFIX_LENGTH, "%d", net_info->PrefixLen6);
 594                         *subnet_mask = prefixlen;
 595                 } else
 596                         *subnet_mask = NULL;
 597                 //LCOV_EXCL_STOP
 598         } else
 599                 *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask,
 600                                 address_family);
 601
 602         if (*subnet_mask == NULL)
 603                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 604
 605         return CONNECTION_ERROR_NONE;
 606 }
 607
 608 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
 609                 connection_address_family_e address_family, char** gateway_address)
 610 {
 611         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 612
 613         if (!(_connection_libnet_check_profile_validity(profile)) ||
 614             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 615              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 616             gateway_address == NULL) {
 617                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 618                 return CONNECTION_ERROR_INVALID_PARAMETER;
 619         }
 620
 621         net_profile_info_t *profile_info = profile;
 622         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 623         if (net_info == NULL)
 624                 return CONNECTION_ERROR_OPERATION_FAILED;
 625
 626         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 627                 *gateway_address = __profile_convert_ip_to_string(
 628                                         &net_info->GatewayAddr6, address_family);
 629         else
 630                 *gateway_address = __profile_convert_ip_to_string(
 631                                         &net_info->GatewayAddr, address_family);
 632
 633         if (*gateway_address == NULL)
 634                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 635
 636         return CONNECTION_ERROR_NONE;
 637 }
 638
 639 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
 640                 connection_address_family_e address_family, char** dns_address)
 641 {
 642         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 643
 644         if (!(_connection_libnet_check_profile_validity(profile)) ||
 645             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 646              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 647             dns_address == NULL ||
 648             order <= 0 ||
 649             order > NET_DNS_ADDR_MAX) {
 650                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 651                 return CONNECTION_ERROR_INVALID_PARAMETER;
 652         }
 653
 654         net_profile_info_t *profile_info = profile;
 655         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 656         if (net_info == NULL)
 657                 return CONNECTION_ERROR_OPERATION_FAILED;
 658
 659         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 660                 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
 661                                 address_family);
 662         else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) //LCOV_EXCL_LINE
 663                 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1], //LCOV_EXCL_LINE
 664                                 address_family);
 665         else
 666                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid address family\n"); //LCOV_EXCL_LINE
 667
 668         if (*dns_address == NULL)
 669                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 670
 671         return CONNECTION_ERROR_NONE;
 672 }
 673
 674 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e *type)
 675 {
 676         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 677
 678         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 679                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 680                 return CONNECTION_ERROR_INVALID_PARAMETER;
 681         }
 682
 683         const char *proxy;
 684         net_profile_info_t *profile_info = profile;
 685         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 686         if (net_info == NULL)
 687                 return CONNECTION_ERROR_OPERATION_FAILED;
 688
 689         //LCOV_EXCL_START
 690         if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
 691                 proxy = __profile_get_ethernet_proxy();
 692                 if (proxy == NULL)
 693                         *type = CONNECTION_PROXY_TYPE_DIRECT;
 694                 else
 695                         *type = CONNECTION_PROXY_TYPE_MANUAL;
 696
 697                 return CONNECTION_ERROR_NONE;
 698         }
 699         //LCOV_EXCL_STOP
 700
 701         switch (net_info->ProxyMethod) {
 702         //LCOV_EXCL_START
 703         case NET_PROXY_TYPE_DIRECT:
 704                 *type = CONNECTION_PROXY_TYPE_DIRECT;
 705                 break;
 706         case NET_PROXY_TYPE_AUTO:
 707                 *type = CONNECTION_PROXY_TYPE_AUTO;
 708                 break;
 709         case NET_PROXY_TYPE_MANUAL:
 710                 *type = CONNECTION_PROXY_TYPE_MANUAL;
 711                 break;
 712         case NET_PROXY_TYPE_UNKNOWN:
 713         default:
 714                 return CONNECTION_ERROR_OPERATION_FAILED;
 715         //LCOV_EXCL_STOP
 716         }
 717
 718         return CONNECTION_ERROR_NONE;
 719 }
 720
 721 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
 722                 connection_address_family_e address_family, char** proxy_address)
 723 {
 724         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 725
 726         if (!(_connection_libnet_check_profile_validity(profile)) ||
 727             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 728              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 729              proxy_address == NULL) {
 730                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 731                 return CONNECTION_ERROR_INVALID_PARAMETER;
 732         }
 733
 734         net_profile_info_t *profile_info = profile;
 735         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 736         if (net_info == NULL)
 737                 return CONNECTION_ERROR_OPERATION_FAILED;
 738
 739         *proxy_address = g_strdup(net_info->ProxyAddr);
 740
 741         if (*proxy_address == NULL)
 742                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 743
 744         return CONNECTION_ERROR_NONE;
 745 }
 746
 747 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
 748                 connection_address_family_e address_family, connection_ip_config_type_e type)
 749 {
 750         net_ip_config_type_t *profile_type = NULL;
 751
 752         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 753
 754         if (!(_connection_libnet_check_profile_validity(profile)) ||
 755             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 756              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 757                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 758                 return CONNECTION_ERROR_INVALID_PARAMETER;
 759         }
 760
 761         net_profile_info_t *profile_info = profile;
 762         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 763         if (net_info == NULL)
 764                 return CONNECTION_ERROR_OPERATION_FAILED;
 765
 766         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 767                 profile_type = &net_info->IpConfigType ;
 768         else
 769                 profile_type = &net_info->IpConfigType6 ;
 770
 771         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
 772                 switch (type) {
 773                 //LCOV_EXCL_START
 774                 case CONNECTION_IP_CONFIG_TYPE_STATIC:
 775                         *profile_type = NET_IP_CONFIG_TYPE_STATIC;
 776                         net_info->IpAddr.Data.Ipv4.s_addr = 0;
 777                         net_info->SubnetMask.Data.Ipv4.s_addr = 0;
 778                         net_info->GatewayAddr.Data.Ipv4.s_addr = 0 ;
 779                         break;
 780
 781                 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
 782                         *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
 783                         break;
 784
 785                 case CONNECTION_IP_CONFIG_TYPE_AUTO:
 786                         *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
 787                         break;
 788
 789                 case CONNECTION_IP_CONFIG_TYPE_FIXED:
 790                         net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
 791                         break;
 792
 793                 case CONNECTION_IP_CONFIG_TYPE_NONE:
 794                         *profile_type = NET_IP_CONFIG_TYPE_OFF;
 795                         break;
 796
 797                 default:
 798                         return CONNECTION_ERROR_INVALID_PARAMETER;
 799                 //LCOV_EXCL_STOP
 800                 }
 801         } else {
 802                 //LCOV_EXCL_START
 803                 switch (type) {
 804                 case CONNECTION_IP_CONFIG_TYPE_STATIC:
 805                         *profile_type = NET_IP_CONFIG_TYPE_STATIC;
 806                         inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
 807                         net_info->PrefixLen6 = 0 ;
 808                         inet_pton(AF_INET6, "::",
 809                                         &net_info->GatewayAddr6.Data.Ipv6);
 810                         break;
 811
 812                 case CONNECTION_IP_CONFIG_TYPE_AUTO:
 813                         *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
 814                         break;
 815
 816                 case CONNECTION_IP_CONFIG_TYPE_NONE:
 817                         *profile_type = NET_IP_CONFIG_TYPE_OFF;
 818                         break;
 819
 820                 default:
 821                         return CONNECTION_ERROR_INVALID_PARAMETER;
 822                 }
 823                 //LCOV_EXCL_STOP
 824         }
 825
 826         return CONNECTION_ERROR_NONE;
 827 }
 828
 829 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
 830                 connection_address_family_e address_family, const char* ip_address)
 831 {
 832         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 833
 834         if (!(_connection_libnet_check_profile_validity(profile)) ||
 835             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 836              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 837                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 838                 return CONNECTION_ERROR_INVALID_PARAMETER;
 839         }
 840
 841         net_profile_info_t *profile_info = profile;
 842         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 843         if (net_info == NULL)
 844                 return CONNECTION_ERROR_OPERATION_FAILED;
 845
 846         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 847                 //LCOV_EXCL_START
 848                 if (ip_address == NULL)
 849                         inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
 850                 else if (inet_pton(AF_INET6, ip_address,
 851                                         &net_info->IpAddr6.Data.Ipv6) < 1)
 852                         return CONNECTION_ERROR_INVALID_PARAMETER;
 853                 //LCOV_EXCL_STOP
 854         } else {
 855                 if (ip_address == NULL)
 856                         net_info->IpAddr.Data.Ipv4.s_addr = 0;
 857                 else if (inet_pton(AF_INET, ip_address,
 858                                         &net_info->IpAddr.Data.Ipv4) < 1)
 859                         return CONNECTION_ERROR_INVALID_PARAMETER;
 860         }
 861
 862         return CONNECTION_ERROR_NONE;
 863 }
 864
 865 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
 866                 connection_address_family_e address_family, const char* subnet_mask)
 867 {
 868         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 869
 870         if (!(_connection_libnet_check_profile_validity(profile)) ||
 871             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 872              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 873                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 874                 return CONNECTION_ERROR_INVALID_PARAMETER;
 875         }
 876
 877         net_profile_info_t *profile_info = profile;
 878         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 879         if (net_info == NULL)
 880                 return CONNECTION_ERROR_OPERATION_FAILED;
 881
 882         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 883                 //LCOV_EXCL_START
 884                 if (subnet_mask == NULL)
 885                         net_info->PrefixLen6 = 0 ;
 886                 else
 887                         net_info->PrefixLen6 = atoi(subnet_mask) ;
 888                 //LCOV_EXCL_STOP
 889         } else {
 890                 if (subnet_mask == NULL)
 891                         net_info->SubnetMask.Data.Ipv4.s_addr = 0;
 892                 else if (inet_pton(AF_INET, subnet_mask , &net_info->SubnetMask.Data.Ipv4)  < 1)
 893                         return CONNECTION_ERROR_INVALID_PARAMETER;
 894         }
 895
 896         return CONNECTION_ERROR_NONE;
 897 }
 898
 899 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
 900                 connection_address_family_e address_family, const char* gateway_address)
 901 {
 902         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 903
 904         if (!(_connection_libnet_check_profile_validity(profile)) ||
 905             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 906              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 907                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 908                 return CONNECTION_ERROR_INVALID_PARAMETER;
 909         }
 910
 911         net_profile_info_t *profile_info = profile;
 912         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 913         if (net_info == NULL)
 914                 return CONNECTION_ERROR_OPERATION_FAILED;
 915
 916         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 917                 //LCOV_EXCL_START
 918                 if (gateway_address == NULL)
 919                         inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6);
 920                 else if (inet_pton(AF_INET6, gateway_address, &net_info->GatewayAddr6.Data.Ipv6) < 1)
 921                         return CONNECTION_ERROR_INVALID_PARAMETER;
 922                 //LCOV_EXCL_STOP
 923         } else {
 924                 if (gateway_address == NULL)
 925                         net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
 926                 else if (inet_pton(AF_INET, gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) < 1)
 927                         return CONNECTION_ERROR_INVALID_PARAMETER;
 928         }
 929
 930         return CONNECTION_ERROR_NONE;
 931 }
 932
 933 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
 934                 connection_address_family_e address_family, const char* dns_address)
 935 {
 936         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 937
 938         if (!(_connection_libnet_check_profile_validity(profile)) ||
 939             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 940              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 941             order <= 0 ||
 942             order > NET_DNS_ADDR_MAX) {
 943                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 944                 return CONNECTION_ERROR_INVALID_PARAMETER;
 945         }
 946
 947         net_profile_info_t *profile_info = profile;
 948         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 949         if (net_info == NULL)
 950                 return CONNECTION_ERROR_OPERATION_FAILED;
 951
 952         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 953                 //LCOV_EXCL_START
 954                 net_info->DnsAddr6[order-1].Type = NET_ADDR_IPV6;
 955                 if (dns_address == NULL)
 956                         inet_pton(AF_INET6, "::", &net_info->DnsAddr6[order-1].Data.Ipv6);
 957                 else if (inet_pton(AF_INET6, dns_address, &net_info->DnsAddr6[order-1].Data.Ipv6) < 1)
 958                         return CONNECTION_ERROR_INVALID_PARAMETER;
 959                 if (net_info->DnsCount6 < order)
 960                         net_info->DnsCount6 = order;
 961                 //LCOV_EXCL_STOP
 962         } else {
 963                 net_info->DnsAddr[order-1].Type = NET_ADDR_IPV4;
 964                 if (dns_address == NULL)
 965                         net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
 966                 else if (inet_pton(AF_INET, dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) < 1)
 967                         return CONNECTION_ERROR_INVALID_PARAMETER;
 968                 if (net_info->DnsCount < order)
 969                         net_info->DnsCount = order;
 970         }
 971
 972         return CONNECTION_ERROR_NONE;
 973 }
 974
 975 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
 976 {
 977         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 978
 979         if (!(_connection_libnet_check_profile_validity(profile))) {
 980                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 981                 return CONNECTION_ERROR_INVALID_PARAMETER;
 982         }
 983
 984         net_profile_info_t *profile_info = profile;
 985         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 986         if (net_info == NULL)
 987                 return CONNECTION_ERROR_OPERATION_FAILED;
 988
 989         switch (type) {
 990         //LCOV_EXCL_START
 991         case CONNECTION_PROXY_TYPE_DIRECT:
 992                 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
 993                 break;
 994         case CONNECTION_PROXY_TYPE_AUTO:
 995                 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
 996                 break;
 997         case CONNECTION_PROXY_TYPE_MANUAL:
 998                 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
 999                 break;
1000         default:
1001                 return CONNECTION_ERROR_INVALID_PARAMETER;
1002         //LCOV_EXCL_STOP
1003         }
1004
1005         return CONNECTION_ERROR_NONE;
1006 }
1007
1008 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
1009                 connection_address_family_e address_family, const char* proxy_address)
1010 {
1011         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1012
1013         CONNECTION_LOG(CONNECTION_ERROR, "Address Family: ", address_family);
1014         if (!(_connection_libnet_check_profile_validity(profile)) ||
1015             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1016              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1017                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1018                 return CONNECTION_ERROR_INVALID_PARAMETER;
1019         }
1020
1021         net_profile_info_t *profile_info = profile;
1022         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1023         if (net_info == NULL)
1024                 return CONNECTION_ERROR_OPERATION_FAILED;
1025
1026         if (proxy_address == NULL)
1027                 net_info->ProxyAddr[0] = '\0';
1028         else
1029                 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
1030
1031         return CONNECTION_ERROR_NONE;
1032 }
1033
1034 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
1035                 connection_profile_state_changed_cb callback, void* user_data)
1036 {
1037         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1038
1039         if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
1040                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1041                 return CONNECTION_ERROR_INVALID_PARAMETER;
1042         }
1043
1044         if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
1045                 return CONNECTION_ERROR_NONE;
1046
1047         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1048 }
1049
1050 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
1051 {
1052         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1053
1054         if (!(_connection_libnet_check_profile_validity(profile))) {
1055                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1056                 return CONNECTION_ERROR_INVALID_PARAMETER;
1057         }
1058
1059         if (_connection_libnet_remove_from_profile_cb_list(profile) != true)
1060                 return CONNECTION_ERROR_INVALID_PARAMETER;
1061
1062         return CONNECTION_ERROR_NONE;
1063 }
1064
1065
1066 /* Wi-Fi profile *************************************************************/
1067 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
1068 {
1069         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1070
1071         if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
1072                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1073                 return CONNECTION_ERROR_INVALID_PARAMETER;
1074         }
1075
1076         net_profile_info_t *profile_info = profile;
1077
1078         if (profile_info->profile_type != NET_DEVICE_WIFI)
1079                 return CONNECTION_ERROR_INVALID_PARAMETER;
1080
1081         *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
1082         if (*essid == NULL)
1083                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1084
1085         return CONNECTION_ERROR_NONE;
1086 }
1087
1088 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
1089 {
1090         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1091
1092         if (!(_connection_libnet_check_profile_validity(profile)) || bssid == 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         *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
1103         if (*bssid == NULL)
1104                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1105
1106         return CONNECTION_ERROR_NONE;
1107 }
1108
1109 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
1110 {
1111         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1112
1113         if (!(_connection_libnet_check_profile_validity(profile)) || rssi == 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         *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
1124
1125         return CONNECTION_ERROR_NONE;
1126 }
1127
1128 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
1129 {
1130         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1131
1132         if (!(_connection_libnet_check_profile_validity(profile)) || frequency == 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         *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
1143
1144         return CONNECTION_ERROR_NONE;
1145 }
1146
1147 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
1148 {
1149         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1150
1151         if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == 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         *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate / 1000000;
1162
1163         return CONNECTION_ERROR_NONE;
1164 }
1165
1166 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e *type)
1167 {
1168         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1169
1170         if (!(_connection_libnet_check_profile_validity(profile)) || type == 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         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1181         //LCOV_EXCL_START
1182         case WLAN_SEC_MODE_NONE:
1183                 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
1184                 break;
1185         case WLAN_SEC_MODE_WEP:
1186                 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
1187                 break;
1188         case WLAN_SEC_MODE_IEEE8021X:
1189                 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
1190                 break;
1191         case WLAN_SEC_MODE_WPA_PSK:
1192                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
1193                 break;
1194         case WLAN_SEC_MODE_WPA2_PSK:
1195                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
1196                 break;
1197         default:
1198                 return CONNECTION_ERROR_OPERATION_FAILED;
1199         //LCOV_EXCL_STOP
1200         }
1201
1202         return CONNECTION_ERROR_NONE;
1203 }
1204
1205 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e *type)
1206 {
1207         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1208
1209         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1210                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1211                 return CONNECTION_ERROR_INVALID_PARAMETER;
1212         }
1213
1214         net_profile_info_t *profile_info = profile;
1215
1216         if (profile_info->profile_type != NET_DEVICE_WIFI)
1217                 return CONNECTION_ERROR_INVALID_PARAMETER;
1218
1219         switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1220         //LCOV_EXCL_START
1221         case WLAN_ENC_MODE_NONE:
1222                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1223                 break;
1224         case WLAN_ENC_MODE_WEP:
1225                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1226                 break;
1227         case WLAN_ENC_MODE_TKIP:
1228                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1229                 break;
1230         case WLAN_ENC_MODE_AES:
1231                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1232                 break;
1233         case WLAN_ENC_MODE_TKIP_AES_MIXED:
1234                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1235                 break;
1236         default:
1237                 return CONNECTION_ERROR_OPERATION_FAILED;
1238         //LCOV_EXCL_STOP
1239         }
1240
1241         return CONNECTION_ERROR_NONE;
1242 }
1243
1244 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1245 {
1246         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1247
1248         if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1249                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1250                 return CONNECTION_ERROR_INVALID_PARAMETER;
1251         }
1252
1253         net_profile_info_t *profile_info = profile;
1254
1255         if (profile_info->profile_type != NET_DEVICE_WIFI)
1256                 return CONNECTION_ERROR_INVALID_PARAMETER;
1257
1258         if (profile_info->Favourite) {
1259                 *required = false;
1260                 return CONNECTION_ERROR_NONE;
1261         }
1262
1263         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1264         //LCOV_EXCL_START
1265         case WLAN_SEC_MODE_NONE:
1266                 *required = false;
1267                 break;
1268         case WLAN_SEC_MODE_WEP:
1269         case WLAN_SEC_MODE_IEEE8021X:
1270         case WLAN_SEC_MODE_WPA_PSK:
1271         case WLAN_SEC_MODE_WPA2_PSK:
1272                 *required = true;
1273                 break;
1274         default:
1275                 return CONNECTION_ERROR_OPERATION_FAILED;
1276         //LCOV_EXCL_STOP
1277         }
1278
1279         return CONNECTION_ERROR_NONE;
1280 }
1281
1282 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1283 {
1284         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1285
1286         if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1287                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1288                 return CONNECTION_ERROR_INVALID_PARAMETER;
1289         }
1290
1291         net_profile_info_t *profile_info = profile;
1292
1293         if (profile_info->profile_type != NET_DEVICE_WIFI)
1294                 return CONNECTION_ERROR_INVALID_PARAMETER;
1295
1296         g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1297                                                 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1298
1299         return CONNECTION_ERROR_NONE;
1300 }
1301
1302 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1303 {
1304         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1305
1306         if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1307                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1308                 return CONNECTION_ERROR_INVALID_PARAMETER;
1309         }
1310
1311         net_profile_info_t *profile_info = profile;
1312
1313         if (profile_info->profile_type != NET_DEVICE_WIFI)
1314                 return CONNECTION_ERROR_INVALID_PARAMETER;
1315
1316         if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1317                 *supported = true;
1318         else
1319                 *supported = false;
1320
1321         return CONNECTION_ERROR_NONE;
1322 }
1323
1324
1325 /* Cellular profile **********************************************************/
1326 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1327                                                 connection_cellular_service_type_e* type)
1328 {
1329         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1330
1331         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1332                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1333                 return CONNECTION_ERROR_INVALID_PARAMETER;
1334         }
1335
1336         net_profile_info_t *profile_info = profile;
1337
1338         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1339                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1340                 return CONNECTION_ERROR_INVALID_PARAMETER;
1341         }
1342
1343         *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1344
1345         if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1346                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed"); //LCOV_EXCL_LINE
1347                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1348         }
1349
1350         return CONNECTION_ERROR_NONE;
1351 }
1352
1353 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1354 {
1355         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1356
1357         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1358                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1359                 return CONNECTION_ERROR_INVALID_PARAMETER;
1360         }
1361
1362         net_profile_info_t *profile_info = profile;
1363
1364         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1365                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1366                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1367         }
1368
1369         *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1370         if (*apn == NULL)
1371                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1372
1373         return CONNECTION_ERROR_NONE;
1374 }
1375
1376 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1377                 connection_cellular_auth_type_e *type, char** user_name, char** password)
1378 {
1379         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1380
1381         if (!(_connection_libnet_check_profile_validity(profile)) ||
1382             type == NULL || user_name == NULL || password == NULL) {
1383                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1384                 return CONNECTION_ERROR_INVALID_PARAMETER;
1385         }
1386
1387         net_profile_info_t *profile_info = profile;
1388
1389         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1390                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1391                 return CONNECTION_ERROR_INVALID_PARAMETER;
1392         }
1393
1394         switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1395         //LCOV_EXCL_START
1396         case NET_PDP_AUTH_NONE:
1397                 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1398                 break;
1399         case NET_PDP_AUTH_PAP:
1400                 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1401                 break;
1402         case NET_PDP_AUTH_CHAP:
1403                 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1404                 break;
1405         default:
1406                 return CONNECTION_ERROR_OPERATION_FAILED;
1407         //LCOV_EXCL_STOP
1408         }
1409
1410         *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1411         if (*user_name == NULL)
1412                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1413
1414         *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1415         if (*password == NULL) {
1416                 g_free(*user_name); //LCOV_EXCL_LINE
1417                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1418         }
1419
1420         return CONNECTION_ERROR_NONE;
1421 }
1422
1423 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1424 {
1425         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1426
1427         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1428                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1429                 return CONNECTION_ERROR_INVALID_PARAMETER;
1430         }
1431
1432         net_profile_info_t *profile_info = profile;
1433
1434         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1435                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1436                 return CONNECTION_ERROR_INVALID_PARAMETER;
1437         }
1438
1439         *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1440         if (*home_url == NULL)
1441                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1442
1443         return CONNECTION_ERROR_NONE;
1444 }
1445
1446 EXPORT_API int connection_profile_get_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1447 {
1448         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1449
1450         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1451                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1452                 return CONNECTION_ERROR_INVALID_PARAMETER;
1453         }
1454
1455         net_profile_info_t *profile_info = profile;
1456
1457         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1458                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1459                 return CONNECTION_ERROR_INVALID_PARAMETER;
1460         }
1461
1462         switch (profile_info->ProfileInfo.Pdp.PdnType) {
1463         //LCOV_EXCL_START
1464         case NET_PDN_TYPE_UNKNOWN:
1465                 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1466                 break;
1467         case NET_PDN_TYPE_IPV4:
1468                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1469                 break;
1470         case NET_PDN_TYPE_IPV6:
1471                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1472                 break;
1473         case NET_PDN_TYPE_IPV4_IPV6:
1474                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1475                 break;
1476         default:
1477                 return CONNECTION_ERROR_OPERATION_FAILED;
1478         //LCOV_EXCL_STOP
1479         }
1480
1481         return CONNECTION_ERROR_NONE;
1482 }
1483
1484 EXPORT_API int connection_profile_get_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1485 {
1486         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1487
1488         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1489                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1490                 return CONNECTION_ERROR_INVALID_PARAMETER;
1491         }
1492
1493         net_profile_info_t *profile_info = profile;
1494
1495         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1496                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1497                 return CONNECTION_ERROR_INVALID_PARAMETER;
1498         }
1499
1500         switch (profile_info->ProfileInfo.Pdp.RoamPdnType) {
1501         //LCOV_EXCL_START
1502         case NET_PDN_TYPE_UNKNOWN:
1503                 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1504                 break;
1505         case NET_PDN_TYPE_IPV4:
1506                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1507                 break;
1508         case NET_PDN_TYPE_IPV6:
1509                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1510                 break;
1511         case NET_PDN_TYPE_IPV4_IPV6:
1512                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1513                 break;
1514         default:
1515                 return CONNECTION_ERROR_OPERATION_FAILED;
1516         //LCOV_EXCL_STOP
1517         }
1518
1519         return CONNECTION_ERROR_NONE;
1520 }
1521
1522 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1523 {
1524         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1525
1526         if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1527                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1528                 return CONNECTION_ERROR_INVALID_PARAMETER;
1529         }
1530
1531         net_profile_info_t *profile_info = profile;
1532
1533         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1534                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1535                 return CONNECTION_ERROR_INVALID_PARAMETER;
1536         }
1537
1538         if (profile_info->ProfileInfo.Pdp.Roaming)
1539                 *is_roaming = true;
1540         else
1541                 *is_roaming = false;
1542
1543         return CONNECTION_ERROR_NONE;
1544 }
1545
1546 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
1547 {
1548         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1549
1550         if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
1551                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1552                 return CONNECTION_ERROR_INVALID_PARAMETER;
1553         }
1554
1555         net_profile_info_t *profile_info = profile;
1556
1557         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1558                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1559                 return CONNECTION_ERROR_INVALID_PARAMETER;
1560         }
1561
1562         if (profile_info->ProfileInfo.Pdp.Hidden)
1563                 *is_hidden = true;
1564         else
1565                 *is_hidden = false;
1566
1567         return CONNECTION_ERROR_NONE;
1568 }
1569
1570 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
1571 {
1572         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1573
1574         if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
1575                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1576                 return CONNECTION_ERROR_INVALID_PARAMETER;
1577         }
1578
1579         net_profile_info_t *profile_info = profile;
1580
1581         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1582                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1583                 return CONNECTION_ERROR_INVALID_PARAMETER;
1584         }
1585
1586         if (profile_info->ProfileInfo.Pdp.Editable)
1587                 *is_editable = true;
1588         else
1589                 *is_editable = false;
1590
1591         return CONNECTION_ERROR_NONE;
1592 }
1593
1594 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
1595 {
1596         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1597
1598         if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
1599                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1600                 return CONNECTION_ERROR_INVALID_PARAMETER;
1601         }
1602
1603         net_profile_info_t *profile_info = profile;
1604
1605         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1606                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1607                 return CONNECTION_ERROR_INVALID_PARAMETER;
1608         }
1609
1610         if (profile_info->ProfileInfo.Pdp.DefaultConn)
1611                 *is_default = true;
1612         else
1613                 *is_default = false;
1614
1615         return CONNECTION_ERROR_NONE;
1616 }
1617
1618 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
1619                 connection_cellular_service_type_e service_type)
1620 {
1621         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1622
1623         if (!(_connection_libnet_check_profile_validity(profile))) {
1624                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1625                 return CONNECTION_ERROR_INVALID_PARAMETER;
1626         }
1627
1628         net_profile_info_t *profile_info = profile;
1629
1630         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1631                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1632                 return CONNECTION_ERROR_INVALID_PARAMETER;
1633         }
1634
1635         switch (service_type) {
1636         //LCOV_EXCL_START
1637         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1638                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1639                 break;
1640         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1641                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1642                 break;
1643         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1644                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1645                 break;
1646         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1647                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1648                 break;
1649         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1650                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1651                 break;
1652         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1653                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1654                 break;
1655         case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1656         default:
1657                 return CONNECTION_ERROR_INVALID_PARAMETER;
1658         //LCOV_EXCL_STOP
1659         }
1660
1661         return CONNECTION_ERROR_NONE;
1662 }
1663
1664 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1665 {
1666         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1667
1668         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1669                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1670                 return CONNECTION_ERROR_INVALID_PARAMETER;
1671         }
1672
1673         net_profile_info_t *profile_info = profile;
1674
1675         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1676                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1677                 return CONNECTION_ERROR_INVALID_PARAMETER;
1678         }
1679
1680         g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1681
1682         return CONNECTION_ERROR_NONE;
1683 }
1684
1685 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
1686                 connection_cellular_auth_type_e type, const char* user_name, const char* password)
1687 {
1688         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1689
1690         if (!(_connection_libnet_check_profile_validity(profile)) ||
1691             user_name == NULL || password == NULL) {
1692                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1693                 return CONNECTION_ERROR_INVALID_PARAMETER;
1694         }
1695
1696         net_profile_info_t *profile_info = profile;
1697
1698         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1699                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1700                 return CONNECTION_ERROR_INVALID_PARAMETER;
1701         }
1702
1703         switch (type) {
1704         //LCOV_EXCL_START
1705         case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1706                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1707                 break;
1708         case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1709                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1710                 break;
1711         case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1712                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1713                 break;
1714         default:
1715                 return CONNECTION_ERROR_INVALID_PARAMETER;
1716         //LCOV_EXCL_STOP
1717         }
1718
1719         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
1720         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
1721
1722         return CONNECTION_ERROR_NONE;
1723 }
1724
1725 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1726 {
1727         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1728
1729         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1730                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1731                 return CONNECTION_ERROR_INVALID_PARAMETER;
1732         }
1733
1734         net_profile_info_t *profile_info = profile;
1735
1736         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1737                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1738                 return CONNECTION_ERROR_INVALID_PARAMETER;
1739         }
1740
1741         g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1742
1743         return CONNECTION_ERROR_NONE;
1744 }
1745
1746 EXPORT_API int connection_profile_set_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
1747 {
1748         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1749
1750         if (!(_connection_libnet_check_profile_validity(profile))) {
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         switch (type) {
1763         //LCOV_EXCL_START
1764         case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
1765                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4;
1766                 break;
1767         case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
1768                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV6;
1769                 break;
1770         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
1771                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
1772                 break;
1773         default:
1774                 return CONNECTION_ERROR_INVALID_PARAMETER;
1775         //LCOV_EXCL_STOP
1776         }
1777
1778         return CONNECTION_ERROR_NONE;
1779 }
1780
1781 EXPORT_API int connection_profile_set_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
1782 {
1783         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1784
1785         if (!(_connection_libnet_check_profile_validity(profile))) {
1786                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1787                 return CONNECTION_ERROR_INVALID_PARAMETER;
1788         }
1789
1790         net_profile_info_t *profile_info = profile;
1791
1792         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1793                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1794                 return CONNECTION_ERROR_INVALID_PARAMETER;
1795         }
1796
1797         switch (type) {
1798         //LCOV_EXCL_START
1799         case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
1800                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4;
1801                 break;
1802         case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
1803                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV6;
1804                 break;
1805         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
1806                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
1807                 break;
1808         default:
1809                 return CONNECTION_ERROR_INVALID_PARAMETER;
1810         //LCOV_EXCL_STOP
1811         }
1812
1813         return CONNECTION_ERROR_NONE;
1814 }