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