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 #include "connection_extension.h"
  26
  27 #define HTTP_PROXY "http_proxy"
  28 #define MAX_PREFIX_LENGTH 6
  29
  30 static net_dev_info_t* __profile_get_net_info(net_profile_info_t *profile_info)
  31 {
  32         switch (profile_info->profile_type) {
  33         case NET_DEVICE_CELLULAR:
  34                 return &profile_info->ProfileInfo.Pdp.net_info;
  35         case NET_DEVICE_WIFI:
  36                 return &profile_info->ProfileInfo.Wlan.net_info;
  37         case NET_DEVICE_ETHERNET:
  38                 return &profile_info->ProfileInfo.Ethernet.net_info; //LCOV_EXCL_LINE
  39         case NET_DEVICE_BLUETOOTH:
  40                 return &profile_info->ProfileInfo.Bluetooth.net_info;
  41         case NET_DEVICE_MESH:
  42                 return &profile_info->ProfileInfo.Mesh.net_info;
  43         case NET_DEVICE_DEFAULT:
  44         case NET_DEVICE_USB:
  45         case NET_DEVICE_UNKNOWN:
  46         case NET_DEVICE_MAX:
  47         default:
  48                 return NULL;
  49         }
  50 }
  51
  52 static char *__profile_convert_ip_to_string(net_addr_t *ip_addr, connection_address_family_e address_family)
  53 {
  54         unsigned char *ipaddr = NULL;
  55         char *ipstr = NULL;
  56
  57         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
  58                 ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr;
  59                 ipstr = g_try_malloc0(INET_ADDRSTRLEN);
  60                 if (ipstr == NULL)
  61                         return NULL;
  62
  63                 inet_ntop(AF_INET, ipaddr, ipstr, INET_ADDRSTRLEN);
  64         } else {
  65                 //LCOV_EXCL_START
  66                 ipaddr = (unsigned char *)&ip_addr->Data.Ipv6.s6_addr;
  67                 ipstr = g_try_malloc0(INET6_ADDRSTRLEN);
  68                 if (ipstr == NULL)
  69                                 return NULL;
  70
  71                 inet_ntop(AF_INET6, ipaddr, ipstr, INET6_ADDRSTRLEN);
  72                 //LCOV_EXCL_STOP
  73         }
  74
  75         return ipstr;
  76 }
  77
  78 static void __profile_init_cellular_profile(net_profile_info_t *profile_info, const char *keyword)
  79 {
  80         int default_subscriber_id = 0;
  81         connection_profile_h profile = NULL;
  82
  83         profile_info->profile_type = NET_DEVICE_CELLULAR;
  84         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
  85         profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_UNKNOWN;
  86         profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_UNKNOWN;
  87         profile_info->ProfileInfo.Pdp.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
  88         profile_info->ProfileInfo.Pdp.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
  89         g_strlcpy(profile_info->ProfileInfo.Pdp.Keyword, keyword, NET_PDP_APN_LEN_MAX);
  90
  91         if (vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE,
  92                                         &default_subscriber_id) != 0)
  93                 CONNECTION_LOG(CONNECTION_ERROR, //LCOV_EXCL_LINE
  94                                                 "Failed to get VCONF_TELEPHONY_DEFAULT_DATA_SERVICE");
  95
  96         profile = (connection_profile_h)profile_info;
  97         _connection_libnet_set_cellular_subscriber_id(profile, default_subscriber_id);
  98 }
  99
 100 static void __profile_init_wifi_profile(net_profile_info_t *profile_info)
 101 {
 102         profile_info->profile_type = NET_DEVICE_WIFI;
 103         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
 104         profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
 105         profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
 106         profile_info->ProfileInfo.Wlan.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
 107         profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
 108         profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
 109 }
 110
 111 //LCOV_EXCL_START
 112 static char* __profile_get_ethernet_proxy(void)
 113 {
 114         char *proxy;
 115
 116         proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
 117
 118         if (proxy == NULL) {
 119                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get system proxy");
 120                 return NULL;
 121         }
 122
 123         return proxy;
 124 }
 125 //LCOV_EXCL_STOP
 126
 127 static unsigned char __profile_convert_netmask_to_prefix_len(const char *netmask)
 128 {
 129         if (netmask == NULL)
 130                 return 0;
 131
 132         in_addr_t mask = inet_network(netmask);
 133         in_addr_t host = ~mask;
 134         unsigned char prefix_len = 0;
 135
 136         /* a valid netmask must be 2^n - 1 */
 137         if ((host & (host + 1)) != 0)
 138                 return -1;
 139
 140         for (; mask; mask <<= 1)
 141                 ++prefix_len;
 142
 143         return prefix_len;
 144 }
 145
 146 static in_addr_t __profile_convert_prefix_len_to_netmask(int prefix_len)
 147 {
 148         return (prefix_len ? (in_addr_t) 0xFFFFFFFFu >> (32 - prefix_len) : 0);
 149 }
 150
 151 //LCOV_EXCL_START
 152 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
 153 {
 154         switch (svc_type) {
 155         case NET_SERVICE_INTERNET:
 156                 return CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
 157         case NET_SERVICE_MMS:
 158                 return CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
 159         case NET_SERVICE_PREPAID_INTERNET:
 160                 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
 161         case NET_SERVICE_PREPAID_MMS:
 162                 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
 163         case NET_SERVICE_TETHERING:
 164                 return CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
 165         case NET_SERVICE_APPLICATION:
 166                 return CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
 167         default:
 168                 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
 169         }
 170 }
 171
 172 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
 173 {
 174         connection_profile_state_e cp_state;
 175
 176         switch (state) {
 177         case NET_STATE_TYPE_ONLINE:
 178         case NET_STATE_TYPE_READY:
 179                 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
 180                 break;
 181         case NET_STATE_TYPE_IDLE:
 182         case NET_STATE_TYPE_FAILURE:
 183         case NET_STATE_TYPE_DISCONNECT:
 184                 cp_state = CONNECTION_PROFILE_STATE_DISCONNECTED;
 185                 break;
 186         case NET_STATE_TYPE_ASSOCIATION:
 187                 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
 188                 break;
 189         case NET_STATE_TYPE_CONFIGURATION:
 190                 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
 191                 break;
 192         default:
 193                 cp_state = -1;
 194         }
 195
 196         return cp_state;
 197 }
 198
 199 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
 200 {
 201         switch (svc_type) {
 202         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
 203                 return NET_SERVICE_INTERNET;
 204         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
 205                 return NET_SERVICE_MMS;
 206         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
 207                 return NET_SERVICE_PREPAID_INTERNET;
 208         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
 209                 return NET_SERVICE_PREPAID_MMS;
 210         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
 211                 return NET_SERVICE_TETHERING;
 212         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
 213                 return NET_SERVICE_APPLICATION;
 214         default:
 215                 return NET_SERVICE_UNKNOWN;
 216         }
 217 }
 218
 219 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
 220 {
 221         net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
 222
 223         switch (state) {
 224         case CONNECTION_PROFILE_STATE_CONNECTED:
 225                 libnet_state = NET_STATE_TYPE_ONLINE;
 226                 break;
 227         case CONNECTION_PROFILE_STATE_DISCONNECTED:
 228                 libnet_state = NET_STATE_TYPE_IDLE;
 229                 break;
 230         case CONNECTION_PROFILE_STATE_ASSOCIATION:
 231                 libnet_state = NET_STATE_TYPE_ASSOCIATION;
 232                 break;
 233         case CONNECTION_PROFILE_STATE_CONFIGURATION:
 234                 libnet_state = NET_STATE_TYPE_CONFIGURATION;
 235                 break;
 236         }
 237
 238         return libnet_state;
 239 }
 240 //LCOV_EXCL_STOP
 241
 242 /* Connection profile ********************************************************/
 243 EXPORT_API int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
 244 {
 245         CONN_LOCK;
 246
 247         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
 248
 249         if (type == CONNECTION_PROFILE_TYPE_CELLULAR)
 250                 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 251         else if (type == CONNECTION_PROFILE_TYPE_WIFI)
 252                 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 253
 254         if (type != CONNECTION_PROFILE_TYPE_CELLULAR &&
 255              type != CONNECTION_PROFILE_TYPE_WIFI) {
 256                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 257                 CONN_UNLOCK;
 258                 return CONNECTION_ERROR_INVALID_PARAMETER;
 259         }
 260
 261         if (profile == NULL) {
 262                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 263                 CONN_UNLOCK;
 264                 return CONNECTION_ERROR_INVALID_PARAMETER;
 265         }
 266
 267         int rv  = _connection_libnet_check_profile_privilege();
 268         if (rv == CONNECTION_ERROR_PERMISSION_DENIED) {
 269                 CONN_UNLOCK;
 270                 return rv;
 271         } else if (rv != CONNECTION_ERROR_NONE) {
 272                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create profile"); //LCOV_EXCL_LINE
 273                 CONN_UNLOCK;
 274                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 275         }
 276
 277         net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
 278         if (profile_info == NULL) {
 279                 CONN_UNLOCK;
 280                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 281         }
 282
 283         if (type == CONNECTION_PROFILE_TYPE_CELLULAR) {
 284                 if (keyword == NULL) {
 285                         CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 286                         g_free(profile_info);
 287                         CONN_UNLOCK;
 288                         return CONNECTION_ERROR_INVALID_PARAMETER;
 289                 }
 290                 __profile_init_cellular_profile(profile_info, keyword);
 291         } else if (type ==  CONNECTION_PROFILE_TYPE_WIFI) {
 292                 __profile_init_wifi_profile(profile_info);
 293         }
 294
 295         *profile = (connection_profile_h)profile_info;
 296         _connection_libnet_add_to_profile_list(*profile);
 297
 298         CONN_UNLOCK;
 299         return CONNECTION_ERROR_NONE;
 300 }
 301
 302 EXPORT_API int connection_profile_destroy(connection_profile_h profile)
 303 {
 304         CONN_LOCK;
 305
 306         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 307
 308         if (!(_connection_libnet_check_profile_validity(profile))) {
 309                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 310                 CONN_UNLOCK;
 311                 return CONNECTION_ERROR_INVALID_PARAMETER;
 312         }
 313
 314         _connection_libnet_remove_from_profile_list(profile);
 315
 316         CONN_UNLOCK;
 317         return CONNECTION_ERROR_NONE;
 318 }
 319
 320 EXPORT_API int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
 321 {
 322         CONN_LOCK;
 323
 324         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 325
 326         if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
 327                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 328                 CONN_UNLOCK;
 329                 return CONNECTION_ERROR_INVALID_PARAMETER;
 330         }
 331
 332         *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
 333         if (*cloned_profile == NULL) {
 334                 CONN_UNLOCK;
 335                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 336         }
 337
 338         memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
 339         _connection_libnet_add_to_profile_list(*cloned_profile);
 340
 341         CONN_UNLOCK;
 342         return CONNECTION_ERROR_NONE;
 343 }
 344
 345 EXPORT_API int connection_profile_get_id(connection_profile_h profile, char** profile_id)
 346 {
 347         CONN_LOCK;
 348
 349         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 350
 351         if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
 352                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 353                 CONN_UNLOCK;
 354                 return CONNECTION_ERROR_INVALID_PARAMETER;
 355         }
 356
 357         net_profile_info_t *profile_info = profile;
 358
 359         char *prof_id = strrchr(profile_info->ProfileName, '/');
 360         if (prof_id == NULL) {
 361                 CONN_UNLOCK;
 362                 return CONNECTION_ERROR_INVALID_PARAMETER;
 363         }
 364
 365         prof_id++;
 366         *profile_id = g_strdup(prof_id);
 367
 368         if (*profile_id == NULL) {
 369                 CONN_UNLOCK;
 370                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 371         }
 372
 373         CONN_UNLOCK;
 374         return CONNECTION_ERROR_NONE;
 375 }
 376
 377 EXPORT_API int connection_profile_get_name(connection_profile_h profile, char** profile_name)
 378 {
 379         CONN_LOCK;
 380
 381         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 382
 383         if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
 384                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 385                 CONN_UNLOCK;
 386                 return CONNECTION_ERROR_INVALID_PARAMETER;
 387         }
 388
 389         net_profile_info_t *profile_info = profile;
 390
 391         switch (profile_info->profile_type) {
 392         case NET_DEVICE_CELLULAR:
 393                 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
 394                 break;
 395         case NET_DEVICE_WIFI:
 396                 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
 397                 break;
 398         case NET_DEVICE_ETHERNET:
 399                 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName); //LCOV_EXCL_LINE
 400                 break; //LCOV_EXCL_LINE
 401         case NET_DEVICE_BLUETOOTH: {
 402                 char *bt_name = strrchr(profile_info->ProfileName, '/');
 403                 if (bt_name == NULL) {
 404                         CONN_UNLOCK;
 405                         return CONNECTION_ERROR_INVALID_PARAMETER;
 406                 }
 407
 408                 bt_name++;
 409                 *profile_name = g_strdup(bt_name);
 410         } break;
 411         case NET_DEVICE_MESH:
 412                 *profile_name = g_strdup(profile_info->ProfileInfo.Mesh.essid);
 413                 break;
 414         default:
 415                 CONN_UNLOCK;
 416                 return CONNECTION_ERROR_INVALID_PARAMETER;
 417         }
 418
 419         if (*profile_name == NULL) {
 420                 CONN_UNLOCK;
 421                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 422         }
 423
 424         CONN_UNLOCK;
 425         return CONNECTION_ERROR_NONE;
 426 }
 427
 428 EXPORT_API int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e *type)
 429 {
 430         CONN_LOCK;
 431
 432         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 433
 434         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 435                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 436                 CONN_UNLOCK;
 437                 return CONNECTION_ERROR_INVALID_PARAMETER;
 438         }
 439
 440         net_profile_info_t *profile_info = profile;
 441
 442         switch (profile_info->profile_type) {
 443         case NET_DEVICE_CELLULAR:
 444                 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
 445                 break;
 446         case NET_DEVICE_WIFI:
 447                 *type = CONNECTION_PROFILE_TYPE_WIFI;
 448                 break;
 449         case NET_DEVICE_ETHERNET:
 450                 *type = CONNECTION_PROFILE_TYPE_ETHERNET; //LCOV_EXCL_LINE
 451                 break; //LCOV_EXCL_LINE
 452         case NET_DEVICE_BLUETOOTH:
 453                 *type = CONNECTION_PROFILE_TYPE_BT;
 454                 break;
 455         case NET_DEVICE_MESH:
 456                 *type = CONNECTION_PROFILE_TYPE_MESH;
 457                 break;
 458         default:
 459                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type");
 460                 CONN_UNLOCK;
 461                 return CONNECTION_ERROR_OPERATION_FAILED;
 462         }
 463
 464         CONN_UNLOCK;
 465         return CONNECTION_ERROR_NONE;
 466 }
 467
 468 EXPORT_API int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
 469 {
 470         CONN_LOCK;
 471
 472         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 473
 474         if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
 475                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 476                 CONN_UNLOCK;
 477                 return CONNECTION_ERROR_INVALID_PARAMETER;
 478         }
 479
 480         net_profile_info_t *profile_info = profile;
 481         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 482         if (net_info == NULL) {
 483                 CONN_UNLOCK;
 484                 return CONNECTION_ERROR_INVALID_PARAMETER;
 485         }
 486
 487         *interface_name = g_strdup(net_info->DevName);
 488         if (*interface_name == NULL) {
 489                 CONN_UNLOCK;
 490                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 491         }
 492
 493         CONN_UNLOCK;
 494         return CONNECTION_ERROR_NONE;
 495 }
 496
 497 EXPORT_API int connection_profile_refresh(connection_profile_h profile)
 498 {
 499         int rv;
 500
 501         CONN_LOCK;
 502
 503         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 504
 505         if (!(_connection_libnet_check_profile_validity(profile))) {
 506                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 507                 CONN_UNLOCK;
 508                 return CONNECTION_ERROR_INVALID_PARAMETER;
 509         }
 510
 511         net_profile_info_t profile_info_local;
 512         net_profile_info_t *profile_info = profile;
 513
 514         rv = net_get_profile_info(NULL, profile_info->ProfileName, &profile_info_local);
 515         if (rv == NET_ERR_ACCESS_DENIED) {
 516                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 517                 CONN_UNLOCK;
 518                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 519         } else if (rv != NET_ERR_NONE) {
 520                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get profile information"); //LCOV_EXCL_LINE
 521                 CONN_UNLOCK;
 522                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 523         }
 524
 525         memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
 526
 527         CONN_UNLOCK;
 528         return CONNECTION_ERROR_NONE;
 529 }
 530
 531 EXPORT_API int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
 532 {
 533         CONN_LOCK;
 534
 535         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 536
 537         if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
 538                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 539                 CONN_UNLOCK;
 540                 return CONNECTION_ERROR_INVALID_PARAMETER;
 541         }
 542
 543         net_profile_info_t *profile_info = profile;
 544         *state = _profile_convert_to_cp_state(profile_info->ProfileState);
 545
 546         CONN_UNLOCK;
 547         return CONNECTION_ERROR_NONE;
 548 }
 549
 550 EXPORT_API int connection_profile_get_internet_state(connection_profile_h profile,
 551                 connection_internet_state_e *state)
 552 {
 553         CONN_LOCK;
 554
 555         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 556
 557         if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
 558                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 559                 CONN_UNLOCK;
 560                 return CONNECTION_ERROR_INVALID_PARAMETER;
 561         }
 562
 563         net_profile_info_t *profile_info = profile;
 564         if (profile_info->ProfileState == NET_STATE_TYPE_ONLINE)
 565                 *state = CONNECTION_INTERNET_STATE_ONLINE;
 566         else
 567                 *state = CONNECTION_INTERNET_STATE_OFFLINE;
 568
 569         CONN_UNLOCK;
 570         return CONNECTION_ERROR_NONE;
 571 }
 572
 573 EXPORT_API int connection_profile_get_ip_config_type(connection_profile_h profile,
 574                 connection_address_family_e address_family, connection_ip_config_type_e *type)
 575 {
 576         net_ip_config_type_t profile_type;
 577
 578         CONN_LOCK;
 579
 580         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 581
 582         if (!(_connection_libnet_check_profile_validity(profile)) ||
 583             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 584              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 585             type == NULL) {
 586                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 587                 CONN_UNLOCK;
 588                 return CONNECTION_ERROR_INVALID_PARAMETER;
 589         }
 590
 591         net_profile_info_t *profile_info = profile;
 592         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 593         if (net_info == NULL) {
 594                 CONN_UNLOCK;
 595                 return CONNECTION_ERROR_OPERATION_FAILED;
 596         }
 597
 598         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 599                 profile_type = net_info->IpConfigType;
 600         else
 601                 profile_type = net_info->IpConfigType6;
 602
 603         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
 604                 switch (profile_type) {
 605                 //LCOV_EXCL_START
 606                 case NET_IP_CONFIG_TYPE_STATIC:
 607                         *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
 608                         break;
 609
 610                 case NET_IP_CONFIG_TYPE_DYNAMIC:
 611                         *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
 612                         break;
 613
 614                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 615                         *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 616                         break;
 617
 618                 case NET_IP_CONFIG_TYPE_FIXED:
 619                         *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
 620                         break;
 621
 622                 case NET_IP_CONFIG_TYPE_OFF:
 623                         *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 624                         break;
 625                 default:
 626                         CONN_UNLOCK;
 627                         return CONNECTION_ERROR_OPERATION_FAILED;
 628                 //LCOV_EXCL_STOP
 629                 }
 630         } else {
 631                 //LCOV_EXCL_START
 632                 switch (profile_type) {
 633                 case NET_IP_CONFIG_TYPE_STATIC:
 634                         *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
 635                         break;
 636
 637                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 638                         *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 639                         break;
 640
 641                 case NET_IP_CONFIG_TYPE_OFF:
 642                         *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 643                         break;
 644
 645                 default:
 646                         CONN_UNLOCK;
 647                         return  CONNECTION_ERROR_OPERATION_FAILED;
 648
 649                 }
 650                 //LCOV_EXCL_STOP
 651         }
 652
 653         CONN_UNLOCK;
 654         return CONNECTION_ERROR_NONE;
 655 }
 656
 657 EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
 658                 connection_address_family_e address_family, char** ip_address)
 659 {
 660         CONN_LOCK;
 661
 662         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 663
 664         if (!(_connection_libnet_check_profile_validity(profile)) ||
 665             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 666              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 667             ip_address == NULL) {
 668                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 669                 CONN_UNLOCK;
 670                 return CONNECTION_ERROR_INVALID_PARAMETER;
 671         }
 672
 673         net_profile_info_t *profile_info = profile;
 674         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 675         if (net_info == NULL) {
 676                 CONN_UNLOCK;
 677                 return CONNECTION_ERROR_OPERATION_FAILED;
 678         }
 679
 680         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
 681                 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
 682                                 address_family);
 683         } else {
 684                 if (net_get_preferred_ipv6_address(net_info->ProfileName, ip_address) != NET_ERR_NONE) {
 685                         CONNECTION_LOG(CONNECTION_ERROR, "Failed to get preferred ipv6 address");
 686                         *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr6,
 687                                         address_family);
 688                 }
 689         }
 690
 691         if (*ip_address == NULL) {
 692                 CONN_UNLOCK;
 693                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 694         }
 695
 696         CONN_UNLOCK;
 697         return CONNECTION_ERROR_NONE;
 698 }
 699
 700 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
 701                 connection_address_family_e address_family, char** subnet_mask)
 702 {
 703         CONN_LOCK;
 704
 705         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 706
 707         if (!(_connection_libnet_check_profile_validity(profile)) ||
 708             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 709              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 710             subnet_mask == NULL) {
 711                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 712                 CONN_UNLOCK;
 713                 return CONNECTION_ERROR_INVALID_PARAMETER;
 714         }
 715
 716         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 717                 CONNECTION_LOG(CONNECTION_ERROR,
 718                                 "Please uses connection_profile_get_prefix_length()");
 719                 CONN_UNLOCK;
 720                 return CONNECTION_ERROR_NOT_SUPPORTED;
 721         }
 722
 723         net_profile_info_t *profile_info = profile;
 724         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 725         if (net_info == NULL) {
 726                 CONN_UNLOCK;
 727                 return CONNECTION_ERROR_OPERATION_FAILED;
 728         }
 729
 730         *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask,
 731                                 address_family);
 732
 733         if (*subnet_mask == NULL) {
 734                 CONN_UNLOCK;
 735                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 736         }
 737
 738         CONN_UNLOCK;
 739         return CONNECTION_ERROR_NONE;
 740 }
 741
 742 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
 743                 connection_address_family_e address_family, char** gateway_address)
 744 {
 745         CONN_LOCK;
 746
 747         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 748
 749         if (!(_connection_libnet_check_profile_validity(profile)) ||
 750             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 751              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 752             gateway_address == NULL) {
 753                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 754                 CONN_UNLOCK;
 755                 return CONNECTION_ERROR_INVALID_PARAMETER;
 756         }
 757
 758         net_profile_info_t *profile_info = profile;
 759         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 760         if (net_info == NULL) {
 761                 CONN_UNLOCK;
 762                 return CONNECTION_ERROR_OPERATION_FAILED;
 763         }
 764
 765         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 766                 *gateway_address = __profile_convert_ip_to_string(
 767                                         &net_info->GatewayAddr6, address_family);
 768         else
 769                 *gateway_address = __profile_convert_ip_to_string(
 770                                         &net_info->GatewayAddr, address_family);
 771
 772         if (*gateway_address == NULL) {
 773                 CONN_UNLOCK;
 774                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 775         }
 776
 777         CONN_UNLOCK;
 778         return CONNECTION_ERROR_NONE;
 779 }
 780
 781 EXPORT_API int connection_profile_get_dhcp_server_address(
 782                 connection_profile_h profile,
 783                 connection_address_family_e address_family, char** dhcp_server)
 784 {
 785         CONN_LOCK;
 786
 787         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 788
 789         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 790                 CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
 791                 CONN_UNLOCK;
 792                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 793         }
 794
 795         if (!(_connection_libnet_check_profile_validity(profile)) ||
 796             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4) ||
 797             dhcp_server == NULL) {
 798                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 799                 CONN_UNLOCK;
 800                 return CONNECTION_ERROR_INVALID_PARAMETER;
 801         }
 802
 803         net_profile_info_t *profile_info = profile;
 804         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 805         if (net_info == NULL) {
 806                 CONN_UNLOCK;
 807                 return CONNECTION_ERROR_OPERATION_FAILED;
 808         }
 809
 810         CONNECTION_LOG(CONNECTION_INFO, "IP Config %d, DHCP Server Address %s",
 811                         net_info->IpConfigType, (net_info->BServerAddr ? "TRUE" : "FALSE"));
 812
 813         *dhcp_server = __profile_convert_ip_to_string(&net_info->ServerAddr,
 814                         address_family);
 815
 816         if (*dhcp_server == NULL) {
 817                 CONN_UNLOCK;
 818                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 819         }
 820
 821         CONN_UNLOCK;
 822         return CONNECTION_ERROR_NONE;
 823 }
 824
 825 EXPORT_API int connection_profile_get_dhcp_lease_duration(
 826                 connection_profile_h profile,
 827                 connection_address_family_e address_family, int* dhcp_lease_duration)
 828 {
 829         CONN_LOCK;
 830
 831         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 832
 833         if (!(_connection_libnet_check_profile_validity(profile)) ||
 834             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 835                 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 836                 dhcp_lease_duration == NULL) {
 837                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 838                 CONN_UNLOCK;
 839                 return CONNECTION_ERROR_INVALID_PARAMETER;
 840         }
 841
 842         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 843                 CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
 844                 CONN_UNLOCK;
 845                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 846         }
 847
 848         net_profile_info_t *profile_info = profile;
 849         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 850         if (net_info == NULL) {
 851                 CONN_UNLOCK;
 852                 return CONNECTION_ERROR_OPERATION_FAILED;
 853         }
 854
 855         CONNECTION_LOG(CONNECTION_INFO, "Lease duration : %d",
 856                         net_info->DHCPLeaseDuration);
 857
 858         *dhcp_lease_duration = net_info->DHCPLeaseDuration;
 859
 860         CONN_UNLOCK;
 861         return CONNECTION_ERROR_NONE;
 862 }
 863
 864 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
 865                 connection_address_family_e address_family, char** dns_address)
 866 {
 867         CONN_LOCK;
 868
 869         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 870
 871         if (!(_connection_libnet_check_profile_validity(profile)) ||
 872             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 873              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 874             dns_address == NULL ||
 875             order <= 0 ||
 876             order > NET_DNS_ADDR_MAX) {
 877                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 878                 CONN_UNLOCK;
 879                 return CONNECTION_ERROR_INVALID_PARAMETER;
 880         }
 881
 882         net_profile_info_t *profile_info = profile;
 883         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 884         if (net_info == NULL) {
 885                 CONN_UNLOCK;
 886                 return CONNECTION_ERROR_OPERATION_FAILED;
 887         }
 888
 889         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 890                 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
 891                                 address_family);
 892         else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) //LCOV_EXCL_LINE
 893                 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1], //LCOV_EXCL_LINE
 894                                 address_family);
 895
 896         if (*dns_address == NULL) {
 897                 CONN_UNLOCK;
 898                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 899         }
 900
 901         CONN_UNLOCK;
 902         return CONNECTION_ERROR_NONE;
 903 }
 904
 905 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e *type)
 906 {
 907         CONN_LOCK;
 908
 909         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 910
 911         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 912                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 913                 CONN_UNLOCK;
 914                 return CONNECTION_ERROR_INVALID_PARAMETER;
 915         }
 916
 917         net_profile_info_t *profile_info = profile;
 918         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 919         if (net_info == NULL) {
 920                 CONN_UNLOCK;
 921                 return CONNECTION_ERROR_OPERATION_FAILED;
 922         }
 923
 924         //LCOV_EXCL_START
 925         if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
 926                 char *proxy = __profile_get_ethernet_proxy();
 927                 if (proxy == NULL) {
 928                         *type = CONNECTION_PROXY_TYPE_DIRECT;
 929                 } else {
 930                         *type = CONNECTION_PROXY_TYPE_MANUAL;
 931                         free(proxy);
 932                 }
 933
 934                 CONN_UNLOCK;
 935                 return CONNECTION_ERROR_NONE;
 936         }
 937         //LCOV_EXCL_STOP
 938
 939         switch (net_info->ProxyMethod) {
 940         //LCOV_EXCL_START
 941         case NET_PROXY_TYPE_DIRECT:
 942                 *type = CONNECTION_PROXY_TYPE_DIRECT;
 943                 break;
 944         case NET_PROXY_TYPE_AUTO:
 945                 *type = CONNECTION_PROXY_TYPE_AUTO;
 946                 break;
 947         case NET_PROXY_TYPE_MANUAL:
 948                 *type = CONNECTION_PROXY_TYPE_MANUAL;
 949                 break;
 950         case NET_PROXY_TYPE_UNKNOWN:
 951         default:
 952                 CONN_UNLOCK;
 953                 return CONNECTION_ERROR_OPERATION_FAILED;
 954         //LCOV_EXCL_STOP
 955         }
 956
 957         CONN_UNLOCK;
 958         return CONNECTION_ERROR_NONE;
 959 }
 960
 961 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
 962                 connection_address_family_e address_family, char** proxy_address)
 963 {
 964         CONN_LOCK;
 965
 966         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 967
 968         if (!(_connection_libnet_check_profile_validity(profile)) ||
 969             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 970              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 971              proxy_address == NULL) {
 972                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 973                 CONN_UNLOCK;
 974                 return CONNECTION_ERROR_INVALID_PARAMETER;
 975         }
 976
 977         net_profile_info_t *profile_info = profile;
 978         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 979         if (net_info == NULL) {
 980                 CONN_UNLOCK;
 981                 return CONNECTION_ERROR_OPERATION_FAILED;
 982         }
 983
 984         *proxy_address = g_strdup(net_info->ProxyAddr);
 985
 986         if (*proxy_address == NULL) {
 987                 CONN_UNLOCK;
 988                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 989         }
 990
 991         CONN_UNLOCK;
 992         return CONNECTION_ERROR_NONE;
 993 }
 994
 995 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
 996                 connection_address_family_e address_family, connection_ip_config_type_e type)
 997 {
 998         net_ip_config_type_t *profile_type = NULL;
 999
1000         CONN_LOCK;
1001
1002         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1003
1004         if (!(_connection_libnet_check_profile_validity(profile)) ||
1005             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1006              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1007                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1008                 CONN_UNLOCK;
1009                 return CONNECTION_ERROR_INVALID_PARAMETER;
1010         }
1011
1012         net_profile_info_t *profile_info = profile;
1013         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1014         if (net_info == NULL) {
1015                 CONN_UNLOCK;
1016                 return CONNECTION_ERROR_OPERATION_FAILED;
1017         }
1018
1019         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
1020                 profile_type = &net_info->IpConfigType ;
1021         else
1022                 profile_type = &net_info->IpConfigType6 ;
1023
1024         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1025                 switch (type) {
1026                 //LCOV_EXCL_START
1027                 case CONNECTION_IP_CONFIG_TYPE_STATIC:
1028                         *profile_type = NET_IP_CONFIG_TYPE_STATIC;
1029                         net_info->IpAddr.Data.Ipv4.s_addr = 0;
1030                         net_info->SubnetMask.Data.Ipv4.s_addr = 0;
1031                         net_info->GatewayAddr.Data.Ipv4.s_addr = 0 ;
1032                         break;
1033
1034                 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
1035                         *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
1036                         break;
1037
1038                 case CONNECTION_IP_CONFIG_TYPE_AUTO:
1039                         *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
1040                         break;
1041
1042                 case CONNECTION_IP_CONFIG_TYPE_FIXED:
1043                         net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
1044                         break;
1045
1046                 case CONNECTION_IP_CONFIG_TYPE_NONE:
1047                         *profile_type = NET_IP_CONFIG_TYPE_OFF;
1048                         break;
1049
1050                 default:
1051                         CONN_UNLOCK;
1052                         return CONNECTION_ERROR_INVALID_PARAMETER;
1053                 //LCOV_EXCL_STOP
1054                 }
1055         } else {
1056                 //LCOV_EXCL_START
1057                 switch (type) {
1058                 case CONNECTION_IP_CONFIG_TYPE_STATIC:
1059                         *profile_type = NET_IP_CONFIG_TYPE_STATIC;
1060                         inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
1061                         net_info->PrefixLen6 = 0 ;
1062                         inet_pton(AF_INET6, "::",
1063                                         &net_info->GatewayAddr6.Data.Ipv6);
1064                         break;
1065
1066                 case CONNECTION_IP_CONFIG_TYPE_AUTO:
1067                         *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
1068                         break;
1069
1070                 case CONNECTION_IP_CONFIG_TYPE_NONE:
1071                         *profile_type = NET_IP_CONFIG_TYPE_OFF;
1072                         break;
1073
1074                 default:
1075                         CONN_UNLOCK;
1076                         return CONNECTION_ERROR_INVALID_PARAMETER;
1077                 }
1078                 //LCOV_EXCL_STOP
1079         }
1080
1081         CONN_UNLOCK;
1082         return CONNECTION_ERROR_NONE;
1083 }
1084
1085 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
1086                 connection_address_family_e address_family, const char* ip_address)
1087 {
1088         CONN_LOCK;
1089
1090         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1091
1092         if (!(_connection_libnet_check_profile_validity(profile)) ||
1093             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1094              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1095                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1096                 CONN_UNLOCK;
1097                 return CONNECTION_ERROR_INVALID_PARAMETER;
1098         }
1099
1100         net_profile_info_t *profile_info = profile;
1101         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1102         if (net_info == NULL) {
1103                 CONN_UNLOCK;
1104                 return CONNECTION_ERROR_OPERATION_FAILED;
1105         }
1106
1107         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1108                 //LCOV_EXCL_START
1109                 if (ip_address == NULL)
1110                         inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
1111                 else if (inet_pton(AF_INET6, ip_address, &net_info->IpAddr6.Data.Ipv6) < 1) {
1112                         CONN_UNLOCK;
1113                         return CONNECTION_ERROR_INVALID_PARAMETER;
1114                 }
1115                 //LCOV_EXCL_STOP
1116         } else {
1117                 if (ip_address == NULL)
1118                         net_info->IpAddr.Data.Ipv4.s_addr = 0;
1119                 else if (inet_pton(AF_INET, ip_address, &net_info->IpAddr.Data.Ipv4) < 1) {
1120                         CONN_UNLOCK;
1121                         return CONNECTION_ERROR_INVALID_PARAMETER;
1122                 }
1123         }
1124
1125         CONN_UNLOCK;
1126         return CONNECTION_ERROR_NONE;
1127 }
1128
1129 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
1130                 connection_address_family_e address_family, const char* subnet_mask)
1131 {
1132         CONN_LOCK;
1133
1134         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1135
1136         if (!(_connection_libnet_check_profile_validity(profile)) ||
1137                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1138                          address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1139                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1140                 CONN_UNLOCK;
1141                 return CONNECTION_ERROR_INVALID_PARAMETER;
1142         }
1143
1144         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1145                 CONNECTION_LOG(CONNECTION_ERROR,
1146                                 "Please uses connection_profile_set_prefix_length()");
1147                 CONN_UNLOCK;
1148                 return CONNECTION_ERROR_NOT_SUPPORTED;
1149         }
1150
1151         net_profile_info_t *profile_info = profile;
1152         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1153         if (net_info == NULL) {
1154                 CONN_UNLOCK;
1155                 return CONNECTION_ERROR_OPERATION_FAILED;
1156         }
1157
1158         if (subnet_mask == NULL)
1159                 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
1160         else if (inet_pton(AF_INET, subnet_mask , &net_info->SubnetMask.Data.Ipv4) < 1) {
1161                 CONN_UNLOCK;
1162                 return CONNECTION_ERROR_INVALID_PARAMETER;
1163         }
1164
1165         net_info->PrefixLen = __profile_convert_netmask_to_prefix_len(subnet_mask);
1166         if (net_info->PrefixLen <= 0 || net_info->PrefixLen > 31) {
1167                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid Prefix length: %d", net_info->PrefixLen);
1168                 CONN_UNLOCK;
1169                 return CONNECTION_ERROR_INVALID_PARAMETER;
1170         }
1171
1172         CONN_UNLOCK;
1173         return CONNECTION_ERROR_NONE;
1174 }
1175
1176 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
1177                 connection_address_family_e address_family, const char* gateway_address)
1178 {
1179         CONN_LOCK;
1180
1181         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1182
1183         if (!(_connection_libnet_check_profile_validity(profile)) ||
1184             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1185              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1186                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1187                 CONN_UNLOCK;
1188                 return CONNECTION_ERROR_INVALID_PARAMETER;
1189         }
1190
1191         net_profile_info_t *profile_info = profile;
1192         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1193         if (net_info == NULL) {
1194                 CONN_UNLOCK;
1195                 return CONNECTION_ERROR_OPERATION_FAILED;
1196         }
1197
1198         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1199                 //LCOV_EXCL_START
1200                 if (gateway_address == NULL)
1201                         inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6);
1202                 else if (inet_pton(AF_INET6, gateway_address, &net_info->GatewayAddr6.Data.Ipv6) < 1) {
1203                         CONN_UNLOCK;
1204                         return CONNECTION_ERROR_INVALID_PARAMETER;
1205                 }
1206                 //LCOV_EXCL_STOP
1207         } else {
1208                 if (gateway_address == NULL)
1209                         net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
1210                 else if (inet_pton(AF_INET, gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) < 1) {
1211                         CONN_UNLOCK;
1212                         return CONNECTION_ERROR_INVALID_PARAMETER;
1213                 }
1214         }
1215
1216         CONN_UNLOCK;
1217         return CONNECTION_ERROR_NONE;
1218 }
1219
1220 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
1221                 connection_address_family_e address_family, const char* dns_address)
1222 {
1223         CONN_LOCK;
1224
1225         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1226
1227         if (!(_connection_libnet_check_profile_validity(profile)) ||
1228             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1229              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1230             order <= 0 ||
1231             order > NET_DNS_ADDR_MAX) {
1232                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1233                 CONN_UNLOCK;
1234                 return CONNECTION_ERROR_INVALID_PARAMETER;
1235         }
1236
1237         net_profile_info_t *profile_info = profile;
1238         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1239         if (net_info == NULL) {
1240                 CONN_UNLOCK;
1241                 return CONNECTION_ERROR_OPERATION_FAILED;
1242         }
1243
1244         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1245                 //LCOV_EXCL_START
1246                 net_info->DnsAddr6[order-1].Type = NET_ADDR_IPV6;
1247                 if (dns_address == NULL)
1248                         inet_pton(AF_INET6, "::", &net_info->DnsAddr6[order-1].Data.Ipv6);
1249                 else if (inet_pton(AF_INET6, dns_address, &net_info->DnsAddr6[order-1].Data.Ipv6) < 1) {
1250                         CONN_UNLOCK;
1251                         return CONNECTION_ERROR_INVALID_PARAMETER;
1252                 }
1253                 if (net_info->DnsCount6 < order)
1254                         net_info->DnsCount6 = order;
1255                 //LCOV_EXCL_STOP
1256         } else {
1257                 net_info->DnsAddr[order-1].Type = NET_ADDR_IPV4;
1258                 if (dns_address == NULL)
1259                         net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
1260                 else if (inet_pton(AF_INET, dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) < 1) {
1261                         CONN_UNLOCK;
1262                         return CONNECTION_ERROR_INVALID_PARAMETER;
1263                 }
1264                 if (net_info->DnsCount < order)
1265                         net_info->DnsCount = order;
1266         }
1267
1268         CONN_UNLOCK;
1269         return CONNECTION_ERROR_NONE;
1270 }
1271
1272 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
1273 {
1274         CONN_LOCK;
1275
1276         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1277
1278         if (!(_connection_libnet_check_profile_validity(profile))) {
1279                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1280                 CONN_UNLOCK;
1281                 return CONNECTION_ERROR_INVALID_PARAMETER;
1282         }
1283
1284         net_profile_info_t *profile_info = profile;
1285         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1286         if (net_info == NULL) {
1287                 CONN_UNLOCK;
1288                 return CONNECTION_ERROR_OPERATION_FAILED;
1289         }
1290
1291         switch (type) {
1292         //LCOV_EXCL_START
1293         case CONNECTION_PROXY_TYPE_DIRECT:
1294                 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
1295                 break;
1296         case CONNECTION_PROXY_TYPE_AUTO:
1297                 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
1298                 break;
1299         case CONNECTION_PROXY_TYPE_MANUAL:
1300                 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
1301                 break;
1302         default:
1303                 CONN_UNLOCK;
1304                 return CONNECTION_ERROR_INVALID_PARAMETER;
1305         //LCOV_EXCL_STOP
1306         }
1307
1308         CONN_UNLOCK;
1309         return CONNECTION_ERROR_NONE;
1310 }
1311
1312 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
1313                 connection_address_family_e address_family, const char* proxy_address)
1314 {
1315         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1316
1317         CONNECTION_LOG(CONNECTION_ERROR, "Address Family: %d", address_family);
1318         if (!(_connection_libnet_check_profile_validity(profile)) ||
1319             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1320              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1321                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1322                 CONN_UNLOCK;
1323                 return CONNECTION_ERROR_INVALID_PARAMETER;
1324         }
1325
1326         net_profile_info_t *profile_info = profile;
1327         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1328         if (net_info == NULL) {
1329                 CONN_UNLOCK;
1330                 return CONNECTION_ERROR_OPERATION_FAILED;
1331         }
1332
1333         if (proxy_address == NULL)
1334                 net_info->ProxyAddr[0] = '\0';
1335         else
1336                 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
1337
1338         CONN_UNLOCK;
1339         return CONNECTION_ERROR_NONE;
1340 }
1341
1342 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
1343                 connection_profile_state_changed_cb callback, void* user_data)
1344 {
1345         CONN_LOCK;
1346
1347         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1348
1349         if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
1350                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1351                 CONN_UNLOCK;
1352                 return CONNECTION_ERROR_INVALID_PARAMETER;
1353         }
1354
1355         if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data)) {
1356                 CONN_UNLOCK;
1357                 return CONNECTION_ERROR_NONE;
1358         }
1359
1360         CONN_UNLOCK;
1361         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1362 }
1363
1364 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
1365 {
1366         CONN_LOCK;
1367
1368         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1369
1370         if (!(_connection_libnet_check_profile_validity(profile))) {
1371                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1372                 CONN_UNLOCK;
1373                 return CONNECTION_ERROR_INVALID_PARAMETER;
1374         }
1375
1376         if (_connection_libnet_remove_from_profile_cb_list(profile) != true) {
1377                 CONN_UNLOCK;
1378                 return CONNECTION_ERROR_INVALID_PARAMETER;
1379         }
1380
1381         CONN_UNLOCK;
1382         return CONNECTION_ERROR_NONE;
1383 }
1384
1385
1386 /* Wi-Fi profile *************************************************************/
1387 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
1388 {
1389         CONN_LOCK;
1390
1391         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1392
1393         if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
1394                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1395                 CONN_UNLOCK;
1396                 return CONNECTION_ERROR_INVALID_PARAMETER;
1397         }
1398
1399         net_profile_info_t *profile_info = profile;
1400
1401         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1402                                 profile_info->profile_type != NET_DEVICE_MESH) {
1403                 CONN_UNLOCK;
1404                 return CONNECTION_ERROR_INVALID_PARAMETER;
1405         }
1406
1407         if (profile_info->profile_type == NET_DEVICE_WIFI)
1408                 *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
1409         else
1410                 *essid = g_strdup(profile_info->ProfileInfo.Mesh.essid);
1411
1412         if (*essid == NULL) {
1413                 CONN_UNLOCK;
1414                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1415         }
1416
1417         CONN_UNLOCK;
1418         return CONNECTION_ERROR_NONE;
1419 }
1420
1421 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
1422 {
1423         CONN_LOCK;
1424
1425         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1426
1427         if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
1428                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1429                 CONN_UNLOCK;
1430                 return CONNECTION_ERROR_INVALID_PARAMETER;
1431         }
1432
1433         net_profile_info_t *profile_info = profile;
1434
1435         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1436                                 profile_info->profile_type != NET_DEVICE_MESH) {
1437                 CONN_UNLOCK;
1438                 return CONNECTION_ERROR_INVALID_PARAMETER;
1439         }
1440
1441         if (profile_info->profile_type == NET_DEVICE_WIFI)
1442                 *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
1443         else
1444                 *bssid = g_strdup(profile_info->ProfileInfo.Mesh.bssid);
1445
1446         if (*bssid == NULL) {
1447                 CONN_UNLOCK;
1448                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1449         }
1450
1451         CONN_UNLOCK;
1452         return CONNECTION_ERROR_NONE;
1453 }
1454
1455 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
1456 {
1457         CONN_LOCK;
1458
1459         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1460
1461         if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
1462                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1463                 CONN_UNLOCK;
1464                 return CONNECTION_ERROR_INVALID_PARAMETER;
1465         }
1466
1467         net_profile_info_t *profile_info = profile;
1468
1469         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1470                                 profile_info->profile_type != NET_DEVICE_MESH) {
1471                 CONN_UNLOCK;
1472                 return CONNECTION_ERROR_INVALID_PARAMETER;
1473         }
1474
1475         if (profile_info->profile_type == NET_DEVICE_WIFI)
1476                 *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
1477         else
1478                 *rssi = (int)profile_info->ProfileInfo.Mesh.Strength;
1479
1480         CONN_UNLOCK;
1481         return CONNECTION_ERROR_NONE;
1482 }
1483
1484 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
1485 {
1486         CONN_LOCK;
1487
1488         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1489
1490         if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
1491                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1492                 CONN_UNLOCK;
1493                 return CONNECTION_ERROR_INVALID_PARAMETER;
1494         }
1495
1496         net_profile_info_t *profile_info = profile;
1497
1498         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1499                                 profile_info->profile_type != NET_DEVICE_MESH) {
1500                 CONN_UNLOCK;
1501                 return CONNECTION_ERROR_INVALID_PARAMETER;
1502         }
1503
1504         if (profile_info->profile_type == NET_DEVICE_WIFI)
1505                 *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
1506         else
1507                 *frequency = (int)profile_info->ProfileInfo.Mesh.frequency;
1508
1509         CONN_UNLOCK;
1510         return CONNECTION_ERROR_NONE;
1511 }
1512
1513 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
1514 {
1515         CONN_LOCK;
1516
1517         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1518
1519         if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
1520                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1521                 CONN_UNLOCK;
1522                 return CONNECTION_ERROR_INVALID_PARAMETER;
1523         }
1524
1525         net_profile_info_t *profile_info = profile;
1526
1527         if (profile_info->profile_type != NET_DEVICE_WIFI) {
1528                 CONN_UNLOCK;
1529                 return CONNECTION_ERROR_INVALID_PARAMETER;
1530         }
1531
1532         *max_speed = profile_info->ProfileInfo.Wlan.max_rate;
1533
1534         CONN_UNLOCK;
1535         return CONNECTION_ERROR_NONE;
1536 }
1537
1538 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e *type)
1539 {
1540         CONN_LOCK;
1541
1542         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1543
1544         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1545                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1546                 CONN_UNLOCK;
1547                 return CONNECTION_ERROR_INVALID_PARAMETER;
1548         }
1549
1550         net_profile_info_t *profile_info = profile;
1551
1552         wlan_security_mode_type_t sec_mode;
1553         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1554                                 profile_info->profile_type != NET_DEVICE_MESH) {
1555                 CONN_UNLOCK;
1556                 return CONNECTION_ERROR_INVALID_PARAMETER;
1557         }
1558
1559         if (profile_info->profile_type == NET_DEVICE_WIFI)
1560                 sec_mode = profile_info->ProfileInfo.Wlan.security_info.sec_mode;
1561         else
1562                 sec_mode = profile_info->ProfileInfo.Mesh.security_info.sec_mode;
1563
1564         switch (sec_mode) {
1565         //LCOV_EXCL_START
1566         case WLAN_SEC_MODE_NONE:
1567                 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
1568                 break;
1569         case WLAN_SEC_MODE_WEP:
1570                 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
1571                 break;
1572         case WLAN_SEC_MODE_IEEE8021X:
1573                 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
1574                 break;
1575         case WLAN_SEC_MODE_WPA_PSK:
1576                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
1577                 break;
1578         case WLAN_SEC_MODE_WPA2_PSK:
1579                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
1580                 break;
1581         case WLAN_SEC_MODE_SAE:
1582                 *type = CONNECTION_WIFI_SECURITY_TYPE_SAE;
1583                 break;
1584         default:
1585                 CONN_UNLOCK;
1586                 return CONNECTION_ERROR_OPERATION_FAILED;
1587         //LCOV_EXCL_STOP
1588         }
1589
1590         CONN_UNLOCK;
1591         return CONNECTION_ERROR_NONE;
1592 }
1593
1594 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e *type)
1595 {
1596         CONN_LOCK;
1597
1598         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1599
1600         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1601                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1602                 CONN_UNLOCK;
1603                 return CONNECTION_ERROR_INVALID_PARAMETER;
1604         }
1605
1606         net_profile_info_t *profile_info = profile;
1607
1608         if (profile_info->profile_type != NET_DEVICE_WIFI) {
1609                 CONN_UNLOCK;
1610                 return CONNECTION_ERROR_INVALID_PARAMETER;
1611         }
1612
1613         switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1614         //LCOV_EXCL_START
1615         case WLAN_ENC_MODE_NONE:
1616                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1617                 break;
1618         case WLAN_ENC_MODE_WEP:
1619                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1620                 break;
1621         case WLAN_ENC_MODE_TKIP:
1622                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1623                 break;
1624         case WLAN_ENC_MODE_AES:
1625                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1626                 break;
1627         case WLAN_ENC_MODE_TKIP_AES_MIXED:
1628                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1629                 break;
1630         default:
1631                 CONN_UNLOCK;
1632                 return CONNECTION_ERROR_OPERATION_FAILED;
1633         //LCOV_EXCL_STOP
1634         }
1635
1636         CONN_UNLOCK;
1637         return CONNECTION_ERROR_NONE;
1638 }
1639
1640 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1641 {
1642         CONN_LOCK;
1643
1644         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1645
1646         if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1647                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1648                 CONN_UNLOCK;
1649                 return CONNECTION_ERROR_INVALID_PARAMETER;
1650         }
1651
1652         net_profile_info_t *profile_info = profile;
1653
1654         wlan_security_mode_type_t sec_mode;
1655         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1656                                 profile_info->profile_type != NET_DEVICE_MESH) {
1657                 CONN_UNLOCK;
1658                 return CONNECTION_ERROR_INVALID_PARAMETER;
1659         }
1660
1661         if (profile_info->Favourite) {
1662                 *required = false;
1663                 CONN_UNLOCK;
1664                 return CONNECTION_ERROR_NONE;
1665         }
1666
1667         if (profile_info->profile_type == NET_DEVICE_WIFI)
1668                 sec_mode = profile_info->ProfileInfo.Wlan.security_info.sec_mode;
1669         else
1670                 sec_mode = profile_info->ProfileInfo.Mesh.security_info.sec_mode;
1671
1672         switch (sec_mode) {
1673         //LCOV_EXCL_START
1674         case WLAN_SEC_MODE_NONE:
1675                 *required = false;
1676                 break;
1677         case WLAN_SEC_MODE_WEP:
1678         case WLAN_SEC_MODE_IEEE8021X:
1679         case WLAN_SEC_MODE_WPA_PSK:
1680         case WLAN_SEC_MODE_WPA2_PSK:
1681         case WLAN_SEC_MODE_SAE:
1682                 *required = true;
1683                 break;
1684         default:
1685                 CONN_UNLOCK;
1686                 return CONNECTION_ERROR_OPERATION_FAILED;
1687         //LCOV_EXCL_STOP
1688         }
1689
1690         CONN_UNLOCK;
1691         return CONNECTION_ERROR_NONE;
1692 }
1693
1694 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1695 {
1696         CONN_LOCK;
1697
1698         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1699
1700         if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1701                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1702                 CONN_UNLOCK;
1703                 return CONNECTION_ERROR_INVALID_PARAMETER;
1704         }
1705
1706         net_profile_info_t *profile_info = profile;
1707
1708         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1709                                 profile_info->profile_type != NET_DEVICE_MESH) {
1710                 CONN_UNLOCK;
1711                 return CONNECTION_ERROR_INVALID_PARAMETER;
1712         }
1713
1714         if (profile_info->profile_type == NET_DEVICE_WIFI)
1715                 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1716                                   passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1717         else
1718                 g_strlcpy(profile_info->ProfileInfo.Mesh.security_info.authentication.sae.saeKey,
1719                                   passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1720
1721         CONN_UNLOCK;
1722         return CONNECTION_ERROR_NONE;
1723 }
1724
1725 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1726 {
1727         CONN_LOCK;
1728
1729         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1730
1731         if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1732                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1733                 CONN_UNLOCK;
1734                 return CONNECTION_ERROR_INVALID_PARAMETER;
1735         }
1736
1737         net_profile_info_t *profile_info = profile;
1738
1739         if (profile_info->profile_type != NET_DEVICE_WIFI) {
1740                 CONN_UNLOCK;
1741                 return CONNECTION_ERROR_INVALID_PARAMETER;
1742         }
1743
1744         if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1745                 *supported = true;
1746         else
1747                 *supported = false;
1748
1749         CONN_UNLOCK;
1750         return CONNECTION_ERROR_NONE;
1751 }
1752
1753
1754 /* Cellular profile **********************************************************/
1755 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1756                                                 connection_cellular_service_type_e* type)
1757 {
1758         CONN_LOCK;
1759
1760         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1761
1762         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1763                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1764                 CONN_UNLOCK;
1765                 return CONNECTION_ERROR_INVALID_PARAMETER;
1766         }
1767
1768         net_profile_info_t *profile_info = profile;
1769
1770         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1771                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1772                 CONN_UNLOCK;
1773                 return CONNECTION_ERROR_INVALID_PARAMETER;
1774         }
1775
1776         *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1777
1778         if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1779                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed"); //LCOV_EXCL_LINE
1780                 CONN_UNLOCK;
1781                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1782         }
1783
1784         CONN_UNLOCK;
1785         return CONNECTION_ERROR_NONE;
1786 }
1787
1788 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1789 {
1790         CONN_LOCK;
1791
1792         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1793
1794         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1795                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1796                 CONN_UNLOCK;
1797                 return CONNECTION_ERROR_INVALID_PARAMETER;
1798         }
1799
1800         net_profile_info_t *profile_info = profile;
1801
1802         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1803                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1804                 CONN_UNLOCK;
1805                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1806         }
1807
1808         *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1809         if (*apn == NULL) {
1810                 CONN_UNLOCK;
1811                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1812         }
1813
1814         CONN_UNLOCK;
1815         return CONNECTION_ERROR_NONE;
1816 }
1817
1818 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1819                 connection_cellular_auth_type_e *type, char** user_name, char** password)
1820 {
1821         CONN_LOCK;
1822
1823         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1824
1825         if (!(_connection_libnet_check_profile_validity(profile)) ||
1826             type == NULL || user_name == NULL || password == NULL) {
1827                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1828                 CONN_UNLOCK;
1829                 return CONNECTION_ERROR_INVALID_PARAMETER;
1830         }
1831
1832         net_profile_info_t *profile_info = profile;
1833
1834         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1835                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1836                 CONN_UNLOCK;
1837                 return CONNECTION_ERROR_INVALID_PARAMETER;
1838         }
1839
1840         switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1841         //LCOV_EXCL_START
1842         case NET_PDP_AUTH_NONE:
1843                 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1844                 break;
1845         case NET_PDP_AUTH_PAP:
1846                 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1847                 break;
1848         case NET_PDP_AUTH_CHAP:
1849                 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1850                 break;
1851         default:
1852                 CONN_UNLOCK;
1853                 return CONNECTION_ERROR_OPERATION_FAILED;
1854         //LCOV_EXCL_STOP
1855         }
1856
1857         *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1858         if (*user_name == NULL) {
1859                 CONN_UNLOCK;
1860                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1861         }
1862
1863         *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1864         if (*password == NULL) {
1865                 g_free(*user_name); //LCOV_EXCL_LINE
1866                 CONN_UNLOCK;
1867                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1868         }
1869
1870         CONN_UNLOCK;
1871         return CONNECTION_ERROR_NONE;
1872 }
1873
1874 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1875 {
1876         CONN_LOCK;
1877
1878         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1879
1880         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1881                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1882                 CONN_UNLOCK;
1883                 return CONNECTION_ERROR_INVALID_PARAMETER;
1884         }
1885
1886         net_profile_info_t *profile_info = profile;
1887
1888         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1889                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1890                 CONN_UNLOCK;
1891                 return CONNECTION_ERROR_INVALID_PARAMETER;
1892         }
1893
1894         *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1895         if (*home_url == NULL) {
1896                 CONN_UNLOCK;
1897                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1898         }
1899
1900         CONN_UNLOCK;
1901         return CONNECTION_ERROR_NONE;
1902 }
1903
1904 EXPORT_API int connection_profile_get_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1905 {
1906         CONN_LOCK;
1907
1908         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1909
1910         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1911                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1912                 CONN_UNLOCK;
1913                 return CONNECTION_ERROR_INVALID_PARAMETER;
1914         }
1915
1916         net_profile_info_t *profile_info = profile;
1917
1918         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1919                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1920                 CONN_UNLOCK;
1921                 return CONNECTION_ERROR_INVALID_PARAMETER;
1922         }
1923
1924         switch (profile_info->ProfileInfo.Pdp.PdnType) {
1925         //LCOV_EXCL_START
1926         case NET_PDN_TYPE_UNKNOWN:
1927                 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1928                 break;
1929         case NET_PDN_TYPE_IPV4:
1930                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1931                 break;
1932         case NET_PDN_TYPE_IPV6:
1933                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1934                 break;
1935         case NET_PDN_TYPE_IPV4_IPV6:
1936                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1937                 break;
1938         default:
1939                 CONN_UNLOCK;
1940                 return CONNECTION_ERROR_OPERATION_FAILED;
1941         //LCOV_EXCL_STOP
1942         }
1943
1944         CONN_UNLOCK;
1945         return CONNECTION_ERROR_NONE;
1946 }
1947
1948 EXPORT_API int connection_profile_get_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1949 {
1950         CONN_LOCK;
1951
1952         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1953
1954         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1955                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1956                 CONN_UNLOCK;
1957                 return CONNECTION_ERROR_INVALID_PARAMETER;
1958         }
1959
1960         net_profile_info_t *profile_info = profile;
1961
1962         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1963                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1964                 CONN_UNLOCK;
1965                 return CONNECTION_ERROR_INVALID_PARAMETER;
1966         }
1967
1968         switch (profile_info->ProfileInfo.Pdp.RoamPdnType) {
1969         //LCOV_EXCL_START
1970         case NET_PDN_TYPE_UNKNOWN:
1971                 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1972                 break;
1973         case NET_PDN_TYPE_IPV4:
1974                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1975                 break;
1976         case NET_PDN_TYPE_IPV6:
1977                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1978                 break;
1979         case NET_PDN_TYPE_IPV4_IPV6:
1980                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1981                 break;
1982         default:
1983                 CONN_UNLOCK;
1984                 return CONNECTION_ERROR_OPERATION_FAILED;
1985         //LCOV_EXCL_STOP
1986         }
1987
1988         CONN_UNLOCK;
1989         return CONNECTION_ERROR_NONE;
1990 }
1991
1992 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1993 {
1994         CONN_LOCK;
1995
1996         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1997
1998         if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1999                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2000                 CONN_UNLOCK;
2001                 return CONNECTION_ERROR_INVALID_PARAMETER;
2002         }
2003
2004         net_profile_info_t *profile_info = profile;
2005
2006         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2007                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2008                 CONN_UNLOCK;
2009                 return CONNECTION_ERROR_INVALID_PARAMETER;
2010         }
2011
2012         if (profile_info->ProfileInfo.Pdp.Roaming)
2013                 *is_roaming = true;
2014         else
2015                 *is_roaming = false;
2016
2017         CONN_UNLOCK;
2018         return CONNECTION_ERROR_NONE;
2019 }
2020
2021 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
2022 {
2023         CONN_LOCK;
2024
2025         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2026
2027         if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
2028                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2029                 CONN_UNLOCK;
2030                 return CONNECTION_ERROR_INVALID_PARAMETER;
2031         }
2032
2033         net_profile_info_t *profile_info = profile;
2034
2035         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2036                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2037                 CONN_UNLOCK;
2038                 return CONNECTION_ERROR_INVALID_PARAMETER;
2039         }
2040
2041         if (profile_info->ProfileInfo.Pdp.Hidden)
2042                 *is_hidden = true;
2043         else
2044                 *is_hidden = false;
2045
2046         CONN_UNLOCK;
2047         return CONNECTION_ERROR_NONE;
2048 }
2049
2050 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
2051 {
2052         CONN_LOCK;
2053
2054         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2055
2056         if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
2057                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2058                 CONN_UNLOCK;
2059                 return CONNECTION_ERROR_INVALID_PARAMETER;
2060         }
2061
2062         net_profile_info_t *profile_info = profile;
2063
2064         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2065                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2066                 CONN_UNLOCK;
2067                 return CONNECTION_ERROR_INVALID_PARAMETER;
2068         }
2069
2070         if (profile_info->ProfileInfo.Pdp.Editable)
2071                 *is_editable = true;
2072         else
2073                 *is_editable = false;
2074
2075         CONN_UNLOCK;
2076         return CONNECTION_ERROR_NONE;
2077 }
2078
2079 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
2080 {
2081         CONN_LOCK;
2082
2083         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2084
2085         if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
2086                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2087                 CONN_UNLOCK;
2088                 return CONNECTION_ERROR_INVALID_PARAMETER;
2089         }
2090
2091         net_profile_info_t *profile_info = profile;
2092
2093         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2094                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2095                 CONN_UNLOCK;
2096                 return CONNECTION_ERROR_INVALID_PARAMETER;
2097         }
2098
2099         if (profile_info->ProfileInfo.Pdp.DefaultConn)
2100                 *is_default = true;
2101         else
2102                 *is_default = false;
2103
2104         CONN_UNLOCK;
2105         return CONNECTION_ERROR_NONE;
2106 }
2107
2108 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
2109                 connection_cellular_service_type_e service_type)
2110 {
2111         CONN_LOCK;
2112
2113         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2114
2115         if (!(_connection_libnet_check_profile_validity(profile))) {
2116                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2117                 CONN_UNLOCK;
2118                 return CONNECTION_ERROR_INVALID_PARAMETER;
2119         }
2120
2121         net_profile_info_t *profile_info = profile;
2122
2123         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2124                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2125                 CONN_UNLOCK;
2126                 return CONNECTION_ERROR_INVALID_PARAMETER;
2127         }
2128
2129         switch (service_type) {
2130         //LCOV_EXCL_START
2131         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
2132                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
2133                 break;
2134         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
2135                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
2136                 break;
2137         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
2138                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
2139                 break;
2140         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
2141                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
2142                 break;
2143         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
2144                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
2145                 break;
2146         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
2147                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
2148                 break;
2149         case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
2150         default:
2151                 CONN_UNLOCK;
2152                 return CONNECTION_ERROR_INVALID_PARAMETER;
2153         //LCOV_EXCL_STOP
2154         }
2155
2156         CONN_UNLOCK;
2157         return CONNECTION_ERROR_NONE;
2158 }
2159
2160 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
2161 {
2162         CONN_LOCK;
2163
2164         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2165
2166         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
2167                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2168                 CONN_UNLOCK;
2169                 return CONNECTION_ERROR_INVALID_PARAMETER;
2170         }
2171
2172         net_profile_info_t *profile_info = profile;
2173
2174         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2175                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2176                 CONN_UNLOCK;
2177                 return CONNECTION_ERROR_INVALID_PARAMETER;
2178         }
2179
2180         g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
2181
2182         CONN_UNLOCK;
2183         return CONNECTION_ERROR_NONE;
2184 }
2185
2186 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
2187                 connection_cellular_auth_type_e type, const char* user_name, const char* password)
2188 {
2189         CONN_LOCK;
2190
2191         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2192
2193         if (!(_connection_libnet_check_profile_validity(profile)) ||
2194             user_name == NULL || password == NULL) {
2195                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2196                 CONN_UNLOCK;
2197                 return CONNECTION_ERROR_INVALID_PARAMETER;
2198         }
2199
2200         net_profile_info_t *profile_info = profile;
2201
2202         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2203                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2204                 CONN_UNLOCK;
2205                 return CONNECTION_ERROR_INVALID_PARAMETER;
2206         }
2207
2208         switch (type) {
2209         //LCOV_EXCL_START
2210         case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
2211                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
2212                 break;
2213         case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
2214                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
2215                 break;
2216         case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
2217                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
2218                 break;
2219         default:
2220                 CONN_UNLOCK;
2221                 return CONNECTION_ERROR_INVALID_PARAMETER;
2222         //LCOV_EXCL_STOP
2223         }
2224
2225         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
2226         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
2227
2228         CONN_UNLOCK;
2229         return CONNECTION_ERROR_NONE;
2230 }
2231
2232 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
2233 {
2234         CONN_LOCK;
2235
2236         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2237
2238         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
2239                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2240                 CONN_UNLOCK;
2241                 return CONNECTION_ERROR_INVALID_PARAMETER;
2242         }
2243
2244         net_profile_info_t *profile_info = profile;
2245
2246         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2247                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2248                 CONN_UNLOCK;
2249                 return CONNECTION_ERROR_INVALID_PARAMETER;
2250         }
2251
2252         g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
2253
2254         CONN_UNLOCK;
2255         return CONNECTION_ERROR_NONE;
2256 }
2257
2258 EXPORT_API int connection_profile_set_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
2259 {
2260         CONN_LOCK;
2261
2262         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2263
2264         if (!(_connection_libnet_check_profile_validity(profile))) {
2265                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2266                 CONN_UNLOCK;
2267                 return CONNECTION_ERROR_INVALID_PARAMETER;
2268         }
2269
2270         net_profile_info_t *profile_info = profile;
2271
2272         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2273                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2274                 CONN_UNLOCK;
2275                 return CONNECTION_ERROR_INVALID_PARAMETER;
2276         }
2277
2278         switch (type) {
2279         //LCOV_EXCL_START
2280         case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
2281                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4;
2282                 break;
2283         case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
2284                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV6;
2285                 break;
2286         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
2287                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
2288                 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
2289                                                 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
2290                 break;
2291         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
2292                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
2293                 break;
2294         default:
2295                 CONN_UNLOCK;
2296                 return CONNECTION_ERROR_INVALID_PARAMETER;
2297         //LCOV_EXCL_STOP
2298         }
2299
2300         CONN_UNLOCK;
2301         return CONNECTION_ERROR_NONE;
2302 }
2303
2304 EXPORT_API int connection_profile_set_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
2305 {
2306         CONN_LOCK;
2307
2308         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2309
2310         if (!(_connection_libnet_check_profile_validity(profile))) {
2311                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2312                 CONN_UNLOCK;
2313                 return CONNECTION_ERROR_INVALID_PARAMETER;
2314         }
2315
2316         net_profile_info_t *profile_info = profile;
2317
2318         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2319                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2320                 CONN_UNLOCK;
2321                 return CONNECTION_ERROR_INVALID_PARAMETER;
2322         }
2323
2324         switch (type) {
2325         //LCOV_EXCL_START
2326         case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
2327                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4;
2328                 break;
2329         case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
2330                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV6;
2331                 break;
2332         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
2333                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
2334                 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
2335                                                 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
2336                 break;
2337         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
2338                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
2339                 break;
2340         default:
2341                 CONN_UNLOCK;
2342                 return CONNECTION_ERROR_INVALID_PARAMETER;
2343         //LCOV_EXCL_STOP
2344         }
2345
2346         CONN_UNLOCK;
2347         return CONNECTION_ERROR_NONE;
2348 }
2349
2350 EXPORT_API int connection_profile_get_ipv6_state(connection_profile_h profile, connection_profile_state_e *state)
2351 {
2352         CONN_LOCK;
2353
2354         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2355                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2356
2357         if (!(_connection_libnet_check_profile_validity(profile)) ||
2358                         state == NULL) {
2359                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2360                 CONN_UNLOCK;
2361                 return CONNECTION_ERROR_INVALID_PARAMETER;
2362         }
2363
2364         net_profile_info_t *profile_info = profile;
2365         *state = _profile_convert_to_cp_state(profile_info->ProfileState6);
2366         if (*state < 0) {
2367                 CONN_UNLOCK;
2368                 return CONNECTION_ERROR_OPERATION_FAILED;
2369         }
2370
2371         CONN_UNLOCK;
2372         return CONNECTION_ERROR_NONE;
2373 }
2374
2375 EXPORT_API int connection_profile_set_dns_config_type(connection_profile_h profile,
2376                 connection_address_family_e address_family, connection_dns_config_type_e type)
2377 {
2378         CONN_LOCK;
2379
2380         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2381                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2382
2383         if (!(_connection_libnet_check_profile_validity(profile))) {
2384                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2385                 CONN_UNLOCK;
2386                 return CONNECTION_ERROR_INVALID_PARAMETER;
2387         }
2388
2389         if ((address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2390                                 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2391                         (type != CONNECTION_DNS_CONFIG_TYPE_STATIC &&
2392                          type != CONNECTION_DNS_CONFIG_TYPE_DYNAMIC)) {
2393                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2394                 CONN_UNLOCK;
2395                 return CONNECTION_ERROR_INVALID_PARAMETER;
2396         }
2397
2398         net_dns_config_type_t *profileType = NULL;
2399         net_dns_config_type_t *profileType6 = NULL;
2400         net_profile_info_t *profile_info = profile;
2401
2402         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2403         if (net_info == NULL) {
2404                 CONN_UNLOCK;
2405                 return CONNECTION_ERROR_OPERATION_FAILED;
2406         }
2407
2408         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
2409                 profileType = &net_info->DnsConfigType;
2410                 net_info->DnsAddr[0].Data.Ipv4.s_addr = 0;
2411                 net_info->DnsAddr[1].Data.Ipv4.s_addr = 0;
2412                 *profileType = type;
2413         } else {
2414                 profileType6 = &net_info->DnsConfigType6;
2415                 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[0].Data.Ipv6);
2416                 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[1].Data.Ipv6);
2417                 *profileType6 = type;
2418         }
2419
2420         CONN_UNLOCK;
2421         return CONNECTION_ERROR_NONE;
2422 }
2423
2424 EXPORT_API int connection_profile_get_dns_config_type(connection_profile_h profile,
2425                 connection_address_family_e address_family, connection_dns_config_type_e *type)
2426 {
2427         CONN_LOCK;
2428
2429         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2430                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2431
2432         if (!(_connection_libnet_check_profile_validity(profile)) ||
2433                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2434                          address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2435                         type == NULL) {
2436                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2437                 CONN_UNLOCK;
2438                 return CONNECTION_ERROR_INVALID_PARAMETER;
2439         }
2440
2441         net_dns_config_type_t profileType;
2442         net_profile_info_t *profile_info = profile;
2443         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2444         if (net_info == NULL) {
2445                 CONN_UNLOCK;
2446                 return CONNECTION_ERROR_OPERATION_FAILED;
2447         }
2448
2449         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
2450                 profileType = net_info->DnsConfigType;
2451         else
2452                 profileType = net_info->DnsConfigType6;
2453
2454         switch (profileType) {
2455         case NET_DNS_CONFIG_TYPE_STATIC:
2456                 *type = CONNECTION_DNS_CONFIG_TYPE_STATIC;
2457                 break;
2458         case NET_DNS_CONFIG_TYPE_DYNAMIC:
2459                 *type = CONNECTION_DNS_CONFIG_TYPE_DYNAMIC;
2460                 break;
2461         default:
2462                 *type = CONNECTION_DNS_CONFIG_TYPE_NONE;
2463                 break;
2464         }
2465
2466         CONN_UNLOCK;
2467         return CONNECTION_ERROR_NONE;
2468 }
2469
2470 EXPORT_API int connection_profile_set_prefix_length(connection_profile_h profile,
2471                 connection_address_family_e address_family, int prefix_len)
2472 {
2473         CONN_LOCK;
2474
2475         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2476                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2477
2478         if (!(_connection_libnet_check_profile_validity(profile)) ||
2479                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2480                         address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
2481                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2482                 CONN_UNLOCK;
2483                 return CONNECTION_ERROR_INVALID_PARAMETER;
2484         }
2485
2486         net_profile_info_t *profile_info = profile;
2487         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2488         if (net_info == NULL) {
2489                 CONN_UNLOCK;
2490                 return CONNECTION_ERROR_OPERATION_FAILED;
2491         }
2492
2493         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
2494                 net_info->PrefixLen = prefix_len;
2495                 net_info->SubnetMask.Data.Ipv4.s_addr = __profile_convert_prefix_len_to_netmask(prefix_len);
2496         } else
2497                 net_info->PrefixLen6 = prefix_len;
2498
2499         CONN_UNLOCK;
2500         return CONNECTION_ERROR_NONE;
2501 }
2502
2503 EXPORT_API int connection_profile_get_prefix_length(connection_profile_h profile,
2504                 connection_address_family_e address_family, int *prefix_len)
2505 {
2506         CONN_LOCK;
2507
2508         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2509                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2510
2511         if (!(_connection_libnet_check_profile_validity(profile)) ||
2512                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2513                         address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2514                         prefix_len == NULL) {
2515                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2516                 CONN_UNLOCK;
2517                 return CONNECTION_ERROR_INVALID_PARAMETER;
2518         }
2519
2520         net_profile_info_t *profile_info = profile;
2521         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2522         if (net_info == NULL) {
2523                 CONN_UNLOCK;
2524                 return CONNECTION_ERROR_OPERATION_FAILED;
2525         }
2526
2527         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
2528                 *prefix_len =  net_info->PrefixLen;
2529         else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
2530                 *prefix_len =  net_info->PrefixLen6;
2531
2532         CONN_UNLOCK;
2533         return CONNECTION_ERROR_NONE;
2534 }