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 bool __profile_ethernet_validate_eap_auth_type(net_dev_info_t *net_info)
  53 {
  54         connection_ethernet_eap_type_e eap_type = net_info->eap.eap_type;
  55
  56         if (net_info->use_eapol == false)
  57                 return false;
  58
  59         if (eap_type != CONNECTION_ETHERNET_EAP_TYPE_PEAP &&
  60                         eap_type != CONNECTION_ETHERNET_EAP_TYPE_TTLS &&
  61                         eap_type != CONNECTION_ETHERNET_EAP_TYPE_FAST)
  62                 return false;
  63
  64         return true;
  65 }
  66
  67 static bool __profile_ethernet_validate_eap_identity(net_dev_info_t *net_info)
  68 {
  69         connection_ethernet_eap_type_e eap_type = net_info->eap.eap_type;
  70
  71         if (net_info->use_eapol == false)
  72                 return false;
  73
  74         if (eap_type != CONNECTION_ETHERNET_EAP_TYPE_MD5 &&
  75                         eap_type != CONNECTION_ETHERNET_EAP_TYPE_PEAP &&
  76                         eap_type != CONNECTION_ETHERNET_EAP_TYPE_TLS &&
  77                         eap_type != CONNECTION_ETHERNET_EAP_TYPE_TTLS &&
  78                         eap_type != CONNECTION_ETHERNET_EAP_TYPE_FAST)
  79                 return false;
  80
  81         return true;
  82 }
  83
  84 static bool __profile_ethernet_validate_eap_anonymous_identity(net_dev_info_t *net_info)
  85 {
  86         connection_ethernet_eap_type_e eap_type = net_info->eap.eap_type;
  87
  88         if (net_info->use_eapol == false)
  89                 return false;
  90
  91         if (eap_type != CONNECTION_ETHERNET_EAP_TYPE_PEAP &&
  92                         eap_type != CONNECTION_ETHERNET_EAP_TYPE_TTLS &&
  93                         eap_type != CONNECTION_ETHERNET_EAP_TYPE_FAST)
  94                 return false;
  95
  96         return true;
  97 }
  98
  99 static bool __profile_ethernet_validate_eap_pac_file(net_dev_info_t *net_info)
 100 {
 101         connection_ethernet_eap_type_e eap_type = net_info->eap.eap_type;
 102
 103         if (net_info->use_eapol == false)
 104                 return false;
 105
 106         if (eap_type != CONNECTION_ETHERNET_EAP_TYPE_FAST)
 107                 return false;
 108
 109         return true;
 110 }
 111
 112 static bool __profile_ethernet_validate_eap_peap_version(net_dev_info_t *net_info)
 113 {
 114         connection_ethernet_eap_type_e eap_type = net_info->eap.eap_type;
 115
 116         if (net_info->use_eapol == false)
 117                 return false;
 118
 119         if (eap_type != CONNECTION_ETHERNET_EAP_TYPE_PEAP)
 120                 return false;
 121
 122         return true;
 123 }
 124
 125 static bool __profile_ethernet_validate_eap_private_key_file(net_dev_info_t *net_info)
 126 {
 127         connection_ethernet_eap_type_e eap_type = net_info->eap.eap_type;
 128
 129         if (net_info->use_eapol == false)
 130                 return false;
 131
 132         if (eap_type != CONNECTION_ETHERNET_EAP_TYPE_TLS)
 133                 return false;
 134
 135         return true;
 136 }
 137
 138 static bool __profile_ethernet_validate_eap_client_cert_file(net_dev_info_t *net_info)
 139 {
 140         connection_ethernet_eap_type_e eap_type = net_info->eap.eap_type;
 141
 142         if (net_info->use_eapol == false)
 143                 return false;
 144
 145         if (eap_type != CONNECTION_ETHERNET_EAP_TYPE_TLS)
 146                 return false;
 147
 148         return true;
 149 }
 150
 151 static bool __profile_ethernet_validate_eap_ca_cert_file(net_dev_info_t *net_info)
 152 {
 153         connection_ethernet_eap_type_e eap_type = net_info->eap.eap_type;
 154
 155         if (net_info->use_eapol == false)
 156                 return false;
 157
 158         if (eap_type != CONNECTION_ETHERNET_EAP_TYPE_PEAP &&
 159                         eap_type != CONNECTION_ETHERNET_EAP_TYPE_TLS &&
 160                         eap_type != CONNECTION_ETHERNET_EAP_TYPE_TTLS)
 161                 return false;
 162
 163         return true;
 164 }
 165
 166 static bool __profile_ethernet_validate_eap_passphrase(net_dev_info_t *net_info)
 167 {
 168         connection_ethernet_eap_type_e eap_type = net_info->eap.eap_type;
 169
 170         if (net_info->use_eapol == false)
 171                 return false;
 172
 173         if (eap_type != CONNECTION_ETHERNET_EAP_TYPE_MD5 &&
 174                         eap_type != CONNECTION_ETHERNET_EAP_TYPE_PEAP &&
 175                         eap_type != CONNECTION_ETHERNET_EAP_TYPE_TTLS &&
 176                         eap_type != CONNECTION_ETHERNET_EAP_TYPE_FAST)
 177                 return false;
 178
 179         return true;
 180 }
 181
 182 static char *__profile_convert_ip_to_string(net_addr_t *ip_addr, connection_address_family_e address_family)
 183 {
 184         unsigned char *ipaddr = NULL;
 185         char *ipstr = NULL;
 186
 187         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
 188                 ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr;
 189                 ipstr = g_try_malloc0(INET_ADDRSTRLEN);
 190                 if (ipstr == NULL)
 191                         return NULL;
 192
 193                 inet_ntop(AF_INET, ipaddr, ipstr, INET_ADDRSTRLEN);
 194         } else {
 195                 //LCOV_EXCL_START
 196                 ipaddr = (unsigned char *)&ip_addr->Data.Ipv6.s6_addr;
 197                 ipstr = g_try_malloc0(INET6_ADDRSTRLEN);
 198                 if (ipstr == NULL)
 199                                 return NULL;
 200
 201                 inet_ntop(AF_INET6, ipaddr, ipstr, INET6_ADDRSTRLEN);
 202                 //LCOV_EXCL_STOP
 203         }
 204
 205         return ipstr;
 206 }
 207
 208 static void __profile_init_cellular_profile(net_profile_info_t *profile_info, const char *keyword)
 209 {
 210         int default_subscriber_id = 0;
 211         connection_profile_h profile = NULL;
 212
 213         profile_info->profile_type = NET_DEVICE_CELLULAR;
 214         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
 215         profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_UNKNOWN;
 216         profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_UNKNOWN;
 217         profile_info->ProfileInfo.Pdp.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
 218         profile_info->ProfileInfo.Pdp.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
 219         g_strlcpy(profile_info->ProfileInfo.Pdp.Keyword, keyword, NET_PDP_APN_LEN_MAX);
 220
 221         if (vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE,
 222                                         &default_subscriber_id) != 0)
 223                 CONNECTION_LOG(CONNECTION_ERROR, //LCOV_EXCL_LINE
 224                                                 "Failed to get VCONF_TELEPHONY_DEFAULT_DATA_SERVICE");
 225
 226         profile = (connection_profile_h)profile_info;
 227         _connection_libnet_set_cellular_subscriber_id(profile, default_subscriber_id);
 228 }
 229
 230 static void __profile_init_wifi_profile(net_profile_info_t *profile_info)
 231 {
 232         profile_info->profile_type = NET_DEVICE_WIFI;
 233         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
 234         profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
 235         profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
 236         profile_info->ProfileInfo.Wlan.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
 237         profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
 238         profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
 239 }
 240
 241 //LCOV_EXCL_START
 242 static char* __profile_get_ethernet_proxy(void)
 243 {
 244         char *proxy;
 245
 246         proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
 247
 248         if (proxy == NULL) {
 249                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get system proxy");
 250                 return NULL;
 251         }
 252
 253         return proxy;
 254 }
 255 //LCOV_EXCL_STOP
 256
 257 static unsigned char __profile_convert_netmask_to_prefix_len(const char *netmask)
 258 {
 259         if (netmask == NULL)
 260                 return 0;
 261
 262         in_addr_t mask = inet_network(netmask);
 263         in_addr_t host = ~mask;
 264         unsigned char prefix_len = 0;
 265
 266         /* a valid netmask must be 2^n - 1 */
 267         if ((host & (host + 1)) != 0)
 268                 return -1;
 269
 270         for (; mask; mask <<= 1)
 271                 ++prefix_len;
 272
 273         return prefix_len;
 274 }
 275
 276 static in_addr_t __profile_convert_prefix_len_to_netmask(int prefix_len)
 277 {
 278         return (prefix_len ? (in_addr_t) 0xFFFFFFFFu >> (32 - prefix_len) : 0);
 279 }
 280
 281 //LCOV_EXCL_START
 282 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
 283 {
 284         switch (svc_type) {
 285         case NET_SERVICE_INTERNET:
 286                 return CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
 287         case NET_SERVICE_MMS:
 288                 return CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
 289         case NET_SERVICE_PREPAID_INTERNET:
 290                 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
 291         case NET_SERVICE_PREPAID_MMS:
 292                 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
 293         case NET_SERVICE_TETHERING:
 294                 return CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
 295         case NET_SERVICE_APPLICATION:
 296                 return CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
 297         default:
 298                 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
 299         }
 300 }
 301
 302 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
 303 {
 304         connection_profile_state_e cp_state;
 305
 306         switch (state) {
 307         case NET_STATE_TYPE_ONLINE:
 308         case NET_STATE_TYPE_READY:
 309                 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
 310                 break;
 311         case NET_STATE_TYPE_IDLE:
 312         case NET_STATE_TYPE_FAILURE:
 313         case NET_STATE_TYPE_DISCONNECT:
 314                 cp_state = CONNECTION_PROFILE_STATE_DISCONNECTED;
 315                 break;
 316         case NET_STATE_TYPE_ASSOCIATION:
 317                 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
 318                 break;
 319         case NET_STATE_TYPE_CONFIGURATION:
 320                 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
 321                 break;
 322         default:
 323                 cp_state = -1;
 324         }
 325
 326         return cp_state;
 327 }
 328
 329 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
 330 {
 331         switch (svc_type) {
 332         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
 333                 return NET_SERVICE_INTERNET;
 334         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
 335                 return NET_SERVICE_MMS;
 336         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
 337                 return NET_SERVICE_PREPAID_INTERNET;
 338         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
 339                 return NET_SERVICE_PREPAID_MMS;
 340         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
 341                 return NET_SERVICE_TETHERING;
 342         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
 343                 return NET_SERVICE_APPLICATION;
 344         default:
 345                 return NET_SERVICE_UNKNOWN;
 346         }
 347 }
 348
 349 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
 350 {
 351         net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
 352
 353         switch (state) {
 354         case CONNECTION_PROFILE_STATE_CONNECTED:
 355                 libnet_state = NET_STATE_TYPE_ONLINE;
 356                 break;
 357         case CONNECTION_PROFILE_STATE_DISCONNECTED:
 358                 libnet_state = NET_STATE_TYPE_IDLE;
 359                 break;
 360         case CONNECTION_PROFILE_STATE_ASSOCIATION:
 361                 libnet_state = NET_STATE_TYPE_ASSOCIATION;
 362                 break;
 363         case CONNECTION_PROFILE_STATE_CONFIGURATION:
 364                 libnet_state = NET_STATE_TYPE_CONFIGURATION;
 365                 break;
 366         }
 367
 368         return libnet_state;
 369 }
 370 //LCOV_EXCL_STOP
 371
 372 /* Connection profile ********************************************************/
 373 EXPORT_API int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
 374 {
 375         CONN_LOCK;
 376
 377         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
 378
 379         if (type == CONNECTION_PROFILE_TYPE_CELLULAR)
 380                 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 381         else if (type == CONNECTION_PROFILE_TYPE_WIFI)
 382                 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 383
 384         if (type != CONNECTION_PROFILE_TYPE_CELLULAR &&
 385              type != CONNECTION_PROFILE_TYPE_WIFI) {
 386                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 387                 CONN_UNLOCK;
 388                 return CONNECTION_ERROR_INVALID_PARAMETER;
 389         }
 390
 391         if (profile == NULL) {
 392                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 393                 CONN_UNLOCK;
 394                 return CONNECTION_ERROR_INVALID_PARAMETER;
 395         }
 396
 397         int rv  = _connection_libnet_check_profile_privilege();
 398         if (rv == CONNECTION_ERROR_PERMISSION_DENIED) {
 399                 CONN_UNLOCK; //LCOV_EXCL_LINE
 400                 return rv; //LCOV_EXCL_LINE
 401         } else if (rv != CONNECTION_ERROR_NONE) {
 402                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create profile"); //LCOV_EXCL_LINE
 403                 CONN_UNLOCK; //LCOV_EXCL_LINE
 404                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 405         }
 406
 407         net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
 408         if (profile_info == NULL) {
 409                 CONN_UNLOCK; //LCOV_EXCL_LINE
 410                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 411         }
 412
 413         if (type == CONNECTION_PROFILE_TYPE_CELLULAR) {
 414                 if (keyword == NULL) {
 415                         CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 416                         g_free(profile_info);
 417                         CONN_UNLOCK;
 418                         return CONNECTION_ERROR_INVALID_PARAMETER;
 419                 }
 420                 __profile_init_cellular_profile(profile_info, keyword);
 421         } else if (type ==  CONNECTION_PROFILE_TYPE_WIFI) {
 422                 __profile_init_wifi_profile(profile_info);
 423         }
 424
 425         *profile = (connection_profile_h)profile_info;
 426         _connection_libnet_add_to_profile_list(*profile);
 427
 428         CONN_UNLOCK;
 429         return CONNECTION_ERROR_NONE;
 430 }
 431
 432 EXPORT_API int connection_profile_destroy(connection_profile_h profile)
 433 {
 434         CONN_LOCK;
 435
 436         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 437
 438         if (!(_connection_libnet_check_profile_validity(profile))) {
 439                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 440                 CONN_UNLOCK;
 441                 return CONNECTION_ERROR_INVALID_PARAMETER;
 442         }
 443
 444         _connection_libnet_remove_from_profile_list(profile);
 445
 446         CONN_UNLOCK;
 447         return CONNECTION_ERROR_NONE;
 448 }
 449
 450 EXPORT_API int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
 451 {
 452         CONN_LOCK;
 453
 454         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 455
 456         if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
 457                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 458                 CONN_UNLOCK;
 459                 return CONNECTION_ERROR_INVALID_PARAMETER;
 460         }
 461
 462         *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
 463         if (*cloned_profile == NULL) {
 464                 CONN_UNLOCK; //LCOV_EXCL_LINE
 465                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 466         }
 467
 468         memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
 469         _connection_libnet_add_to_profile_list(*cloned_profile);
 470
 471         CONN_UNLOCK;
 472         return CONNECTION_ERROR_NONE;
 473 }
 474
 475 EXPORT_API int connection_profile_get_id(connection_profile_h profile, char** profile_id)
 476 {
 477         CONN_LOCK;
 478
 479         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 480
 481         if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
 482                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 483                 CONN_UNLOCK;
 484                 return CONNECTION_ERROR_INVALID_PARAMETER;
 485         }
 486
 487         net_profile_info_t *profile_info = profile;
 488
 489         char *prof_id = strrchr(profile_info->ProfileName, '/');
 490         if (prof_id == NULL) {
 491                 CONN_UNLOCK; //LCOV_EXCL_LINE
 492                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 493         }
 494
 495         prof_id++;
 496         *profile_id = g_strdup(prof_id);
 497
 498         if (*profile_id == NULL) {
 499                 CONN_UNLOCK; //LCOV_EXCL_LINE
 500                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 501         }
 502
 503         CONN_UNLOCK;
 504         return CONNECTION_ERROR_NONE;
 505 }
 506
 507 EXPORT_API int connection_profile_get_name(connection_profile_h profile, char** profile_name)
 508 {
 509         CONN_LOCK;
 510
 511         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 512
 513         if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
 514                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 515                 CONN_UNLOCK;
 516                 return CONNECTION_ERROR_INVALID_PARAMETER;
 517         }
 518
 519         net_profile_info_t *profile_info = profile;
 520
 521         switch (profile_info->profile_type) {
 522         case NET_DEVICE_CELLULAR:
 523                 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
 524                 break;
 525         case NET_DEVICE_WIFI:
 526                 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
 527                 break;
 528         case NET_DEVICE_ETHERNET:
 529                 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName); //LCOV_EXCL_LINE
 530                 break; //LCOV_EXCL_LINE
 531         case NET_DEVICE_BLUETOOTH: {
 532                 char *bt_name = strrchr(profile_info->ProfileName, '/');
 533                 if (bt_name == NULL) {
 534                         CONN_UNLOCK; //LCOV_EXCL_LINE
 535                         return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 536                 }
 537
 538                 bt_name++;
 539                 *profile_name = g_strdup(bt_name);
 540         } break;
 541         case NET_DEVICE_MESH:
 542                 *profile_name = g_strdup(profile_info->ProfileInfo.Mesh.essid);
 543                 break;
 544         default:
 545                 CONN_UNLOCK; //LCOV_EXCL_LINE
 546                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 547         }
 548
 549         if (*profile_name == NULL) {
 550                 CONN_UNLOCK; //LCOV_EXCL_LINE
 551                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 552         }
 553
 554         CONN_UNLOCK;
 555         return CONNECTION_ERROR_NONE;
 556 }
 557
 558 EXPORT_API int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e *type)
 559 {
 560         CONN_LOCK;
 561
 562         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 563
 564         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 565                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 566                 CONN_UNLOCK;
 567                 return CONNECTION_ERROR_INVALID_PARAMETER;
 568         }
 569
 570         net_profile_info_t *profile_info = profile;
 571
 572         switch (profile_info->profile_type) {
 573         case NET_DEVICE_CELLULAR:
 574                 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
 575                 break;
 576         case NET_DEVICE_WIFI:
 577                 *type = CONNECTION_PROFILE_TYPE_WIFI;
 578                 break;
 579         case NET_DEVICE_ETHERNET:
 580                 *type = CONNECTION_PROFILE_TYPE_ETHERNET; //LCOV_EXCL_LINE
 581                 break; //LCOV_EXCL_LINE
 582         case NET_DEVICE_BLUETOOTH:
 583                 *type = CONNECTION_PROFILE_TYPE_BT;
 584                 break;
 585         case NET_DEVICE_MESH:
 586                 *type = CONNECTION_PROFILE_TYPE_MESH;
 587                 break;
 588         default:
 589                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type"); //LCOV_EXCL_LINE
 590                 CONN_UNLOCK; //LCOV_EXCL_LINE
 591                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 592         }
 593
 594         CONN_UNLOCK;
 595         return CONNECTION_ERROR_NONE;
 596 }
 597
 598 EXPORT_API int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
 599 {
 600         CONN_LOCK;
 601
 602         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 603
 604         if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
 605                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 606                 CONN_UNLOCK;
 607                 return CONNECTION_ERROR_INVALID_PARAMETER;
 608         }
 609
 610         net_profile_info_t *profile_info = profile;
 611         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 612         if (net_info == NULL) {
 613                 CONN_UNLOCK; //LCOV_EXCL_LINE
 614                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 615         }
 616
 617         *interface_name = g_strdup(net_info->DevName);
 618         if (*interface_name == NULL) {
 619                 CONN_UNLOCK; //LCOV_EXCL_LINE
 620                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 621         }
 622
 623         CONN_UNLOCK;
 624         return CONNECTION_ERROR_NONE;
 625 }
 626
 627 EXPORT_API int connection_profile_refresh(connection_profile_h profile)
 628 {
 629         int rv;
 630
 631         CONN_LOCK;
 632
 633         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 634
 635         if (!(_connection_libnet_check_profile_validity(profile))) {
 636                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 637                 CONN_UNLOCK;
 638                 return CONNECTION_ERROR_INVALID_PARAMETER;
 639         }
 640
 641         net_profile_info_t profile_info_local;
 642         net_profile_info_t *profile_info = profile;
 643
 644         rv = net_get_profile_info(NULL, profile_info->ProfileName, &profile_info_local);
 645         if (rv == NET_ERR_ACCESS_DENIED) {
 646                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 647                 CONN_UNLOCK; //LCOV_EXCL_LINE
 648                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 649         } else if (rv != NET_ERR_NONE) {
 650                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get profile information"); //LCOV_EXCL_LINE
 651                 CONN_UNLOCK; //LCOV_EXCL_LINE
 652                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 653         }
 654
 655         memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
 656
 657         CONN_UNLOCK;
 658         return CONNECTION_ERROR_NONE;
 659 }
 660
 661 EXPORT_API int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
 662 {
 663         CONN_LOCK;
 664
 665         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 666
 667         if (!(_connection_libnet_check_profile_validity(profile)) || state == 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         *state = _profile_convert_to_cp_state(profile_info->ProfileState);
 675
 676         CONN_UNLOCK;
 677         return CONNECTION_ERROR_NONE;
 678 }
 679
 680 EXPORT_API int connection_profile_get_internet_state(connection_profile_h profile,
 681                 connection_internet_state_e *state)
 682 {
 683         CONN_LOCK;
 684
 685         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 686
 687         if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
 688                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 689                 CONN_UNLOCK;
 690                 return CONNECTION_ERROR_INVALID_PARAMETER;
 691         }
 692
 693         net_profile_info_t *profile_info = profile;
 694         if (profile_info->ProfileState == NET_STATE_TYPE_ONLINE)
 695                 *state = CONNECTION_INTERNET_STATE_ONLINE;
 696         else
 697                 *state = CONNECTION_INTERNET_STATE_OFFLINE;
 698
 699         CONN_UNLOCK;
 700         return CONNECTION_ERROR_NONE;
 701 }
 702
 703 EXPORT_API int connection_profile_get_ip_config_type(connection_profile_h profile,
 704                 connection_address_family_e address_family, connection_ip_config_type_e *type)
 705 {
 706         net_ip_config_type_t profile_type;
 707
 708         CONN_LOCK;
 709
 710         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 711
 712         if (!(_connection_libnet_check_profile_validity(profile)) ||
 713             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 714              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 715             type == NULL) {
 716                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 717                 CONN_UNLOCK;
 718                 return CONNECTION_ERROR_INVALID_PARAMETER;
 719         }
 720
 721         net_profile_info_t *profile_info = profile;
 722         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 723         if (net_info == NULL) {
 724                 CONN_UNLOCK; //LCOV_EXCL_LINE
 725                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 726         }
 727
 728         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 729                 profile_type = net_info->IpConfigType;
 730         else
 731                 profile_type = net_info->IpConfigType6;
 732
 733         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
 734                 switch (profile_type) {
 735                 //LCOV_EXCL_START
 736                 case NET_IP_CONFIG_TYPE_STATIC:
 737                         *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
 738                         break;
 739
 740                 case NET_IP_CONFIG_TYPE_DYNAMIC:
 741                         *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
 742                         break;
 743
 744                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 745                         *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 746                         break;
 747
 748                 case NET_IP_CONFIG_TYPE_FIXED:
 749                         *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
 750                         break;
 751
 752                 case NET_IP_CONFIG_TYPE_OFF:
 753                         *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 754                         break;
 755                 default:
 756                         CONN_UNLOCK;
 757                         return CONNECTION_ERROR_OPERATION_FAILED;
 758                 //LCOV_EXCL_STOP
 759                 }
 760         } else {
 761                 //LCOV_EXCL_START
 762                 switch (profile_type) {
 763                 case NET_IP_CONFIG_TYPE_STATIC:
 764                         *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
 765                         break;
 766
 767                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 768                         *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 769                         break;
 770
 771                 case NET_IP_CONFIG_TYPE_OFF:
 772                         *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 773                         break;
 774
 775                 default:
 776                         CONN_UNLOCK;
 777                         return  CONNECTION_ERROR_OPERATION_FAILED;
 778
 779                 }
 780                 //LCOV_EXCL_STOP
 781         }
 782
 783         CONN_UNLOCK;
 784         return CONNECTION_ERROR_NONE;
 785 }
 786
 787 EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
 788                 connection_address_family_e address_family, char** ip_address)
 789 {
 790         CONN_LOCK;
 791
 792         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 793
 794         if (!(_connection_libnet_check_profile_validity(profile)) ||
 795             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 796              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 797             ip_address == 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; //LCOV_EXCL_LINE
 807                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 808         }
 809
 810         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
 811                 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
 812                                 address_family);
 813         } else {
 814                 if (net_get_preferred_ipv6_address(net_info->ProfileName, ip_address) != NET_ERR_NONE) {
 815                         CONNECTION_LOG(CONNECTION_ERROR, "Failed to get preferred ipv6 address"); //LCOV_EXCL_LINE
 816                         *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr6, //LCOV_EXCL_LINE
 817                                         address_family);
 818                 }
 819         }
 820
 821         if (*ip_address == NULL) {
 822                 CONN_UNLOCK; //LCOV_EXCL_LINE
 823                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 824         }
 825
 826         CONN_UNLOCK;
 827         return CONNECTION_ERROR_NONE;
 828 }
 829
 830 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
 831                 connection_address_family_e address_family, char** subnet_mask)
 832 {
 833         CONN_LOCK;
 834
 835         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 836
 837         if (!(_connection_libnet_check_profile_validity(profile)) ||
 838             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 839              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 840             subnet_mask == NULL) {
 841                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 842                 CONN_UNLOCK;
 843                 return CONNECTION_ERROR_INVALID_PARAMETER;
 844         }
 845
 846         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 847                 CONNECTION_LOG(CONNECTION_ERROR, //LCOV_EXCL_LINE
 848                                 "Please uses connection_profile_get_prefix_length()");
 849                 CONN_UNLOCK; //LCOV_EXCL_LINE
 850                 return CONNECTION_ERROR_NOT_SUPPORTED; //LCOV_EXCL_LINE
 851         }
 852
 853         net_profile_info_t *profile_info = profile;
 854         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 855         if (net_info == NULL) {
 856                 CONN_UNLOCK; //LCOV_EXCL_LINE
 857                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 858         }
 859
 860         *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask,
 861                                 address_family);
 862
 863         if (*subnet_mask == NULL) {
 864                 CONN_UNLOCK; //LCOV_EXCL_LINE
 865                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 866         }
 867
 868         CONN_UNLOCK;
 869         return CONNECTION_ERROR_NONE;
 870 }
 871
 872 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
 873                 connection_address_family_e address_family, char** gateway_address)
 874 {
 875         CONN_LOCK;
 876
 877         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 878
 879         if (!(_connection_libnet_check_profile_validity(profile)) ||
 880             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 881              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 882             gateway_address == NULL) {
 883                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 884                 CONN_UNLOCK;
 885                 return CONNECTION_ERROR_INVALID_PARAMETER;
 886         }
 887
 888         net_profile_info_t *profile_info = profile;
 889         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 890         if (net_info == NULL) {
 891                 CONN_UNLOCK; //LCOV_EXCL_LINE
 892                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 893         }
 894
 895         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 896                 *gateway_address = __profile_convert_ip_to_string(
 897                                         &net_info->GatewayAddr6, address_family);
 898         else
 899                 *gateway_address = __profile_convert_ip_to_string(
 900                                         &net_info->GatewayAddr, address_family);
 901
 902         if (*gateway_address == NULL) {
 903                 CONN_UNLOCK; //LCOV_EXCL_LINE
 904                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 905         }
 906
 907         CONN_UNLOCK;
 908         return CONNECTION_ERROR_NONE;
 909 }
 910
 911 EXPORT_API int connection_profile_get_dhcp_server_address(
 912                 connection_profile_h profile,
 913                 connection_address_family_e address_family, char** dhcp_server)
 914 {
 915         CONN_LOCK;
 916
 917         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 918
 919         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 920                 CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
 921                 CONN_UNLOCK;
 922                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 923         }
 924
 925         if (!(_connection_libnet_check_profile_validity(profile)) ||
 926             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4) ||
 927             dhcp_server == NULL) {
 928                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 929                 CONN_UNLOCK;
 930                 return CONNECTION_ERROR_INVALID_PARAMETER;
 931         }
 932
 933         net_profile_info_t *profile_info = profile;
 934         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 935         if (net_info == NULL) {
 936                 CONN_UNLOCK; //LCOV_EXCL_LINE
 937                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 938         }
 939
 940         CONNECTION_LOG(CONNECTION_INFO, "IP Config %d, DHCP Server Address %s",
 941                         net_info->IpConfigType, (net_info->BServerAddr ? "TRUE" : "FALSE"));
 942
 943         *dhcp_server = __profile_convert_ip_to_string(&net_info->ServerAddr,
 944                         address_family);
 945
 946         if (*dhcp_server == NULL) {
 947                 CONN_UNLOCK; //LCOV_EXCL_LINE
 948                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 949         }
 950
 951         CONN_UNLOCK;
 952         return CONNECTION_ERROR_NONE;
 953 }
 954
 955 EXPORT_API int connection_profile_get_dhcp_lease_duration(
 956                 connection_profile_h profile,
 957                 connection_address_family_e address_family, int* dhcp_lease_duration)
 958 {
 959         CONN_LOCK;
 960
 961         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 962
 963         if (!(_connection_libnet_check_profile_validity(profile)) ||
 964             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 965                 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 966                 dhcp_lease_duration == NULL) {
 967                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 968                 CONN_UNLOCK;
 969                 return CONNECTION_ERROR_INVALID_PARAMETER;
 970         }
 971
 972         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 973                 CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
 974                 CONN_UNLOCK;
 975                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 976         }
 977
 978         net_profile_info_t *profile_info = profile;
 979         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 980         if (net_info == NULL) {
 981                 CONN_UNLOCK; //LCOV_EXCL_LINE
 982                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 983         }
 984
 985         CONNECTION_LOG(CONNECTION_INFO, "Lease duration : %d",
 986                         net_info->DHCPLeaseDuration);
 987
 988         *dhcp_lease_duration = net_info->DHCPLeaseDuration;
 989
 990         CONN_UNLOCK;
 991         return CONNECTION_ERROR_NONE;
 992 }
 993
 994 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
 995                 connection_address_family_e address_family, char** dns_address)
 996 {
 997         CONN_LOCK;
 998
 999         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1000
1001         if (!(_connection_libnet_check_profile_validity(profile)) ||
1002             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1003              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1004             dns_address == NULL ||
1005             order <= 0 ||
1006             order > NET_DNS_ADDR_MAX) {
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; //LCOV_EXCL_LINE
1016                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1017         }
1018
1019         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
1020                 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
1021                                 address_family);
1022         else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) //LCOV_EXCL_LINE
1023                 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1], //LCOV_EXCL_LINE
1024                                 address_family);
1025
1026         if (*dns_address == NULL) {
1027                 CONN_UNLOCK; //LCOV_EXCL_LINE
1028                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1029         }
1030
1031         CONN_UNLOCK;
1032         return CONNECTION_ERROR_NONE;
1033 }
1034
1035 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e *type)
1036 {
1037         CONN_LOCK;
1038
1039         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1040
1041         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1042                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1043                 CONN_UNLOCK;
1044                 return CONNECTION_ERROR_INVALID_PARAMETER;
1045         }
1046
1047         net_profile_info_t *profile_info = profile;
1048         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1049         if (net_info == NULL) {
1050                 CONN_UNLOCK; //LCOV_EXCL_LINE
1051                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1052         }
1053
1054         //LCOV_EXCL_START
1055         if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
1056                 char *proxy = __profile_get_ethernet_proxy();
1057                 if (proxy == NULL) {
1058                         *type = CONNECTION_PROXY_TYPE_DIRECT;
1059                 } else {
1060                         *type = CONNECTION_PROXY_TYPE_MANUAL;
1061                         free(proxy);
1062                 }
1063
1064                 CONN_UNLOCK;
1065                 return CONNECTION_ERROR_NONE;
1066         }
1067         //LCOV_EXCL_STOP
1068
1069         switch (net_info->ProxyMethod) {
1070         //LCOV_EXCL_START
1071         case NET_PROXY_TYPE_DIRECT:
1072                 *type = CONNECTION_PROXY_TYPE_DIRECT;
1073                 break;
1074         case NET_PROXY_TYPE_AUTO:
1075                 *type = CONNECTION_PROXY_TYPE_AUTO;
1076                 break;
1077         case NET_PROXY_TYPE_MANUAL:
1078                 *type = CONNECTION_PROXY_TYPE_MANUAL;
1079                 break;
1080         case NET_PROXY_TYPE_UNKNOWN:
1081         default:
1082                 CONN_UNLOCK;
1083                 return CONNECTION_ERROR_OPERATION_FAILED;
1084         //LCOV_EXCL_STOP
1085         }
1086
1087         CONN_UNLOCK;
1088         return CONNECTION_ERROR_NONE;
1089 }
1090
1091 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
1092                 connection_address_family_e address_family, char** proxy_address)
1093 {
1094         CONN_LOCK;
1095
1096         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1097
1098         if (!(_connection_libnet_check_profile_validity(profile)) ||
1099             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1100              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1101              proxy_address == NULL) {
1102                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1103                 CONN_UNLOCK;
1104                 return CONNECTION_ERROR_INVALID_PARAMETER;
1105         }
1106
1107         net_profile_info_t *profile_info = profile;
1108         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1109         if (net_info == NULL) {
1110                 CONN_UNLOCK; //LCOV_EXCL_LINE
1111                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1112         }
1113
1114         *proxy_address = g_strdup(net_info->ProxyAddr);
1115
1116         if (*proxy_address == NULL) {
1117                 CONN_UNLOCK; //LCOV_EXCL_LINE
1118                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1119         }
1120
1121         CONN_UNLOCK;
1122         return CONNECTION_ERROR_NONE;
1123 }
1124
1125 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
1126                 connection_address_family_e address_family, connection_ip_config_type_e type)
1127 {
1128         net_ip_config_type_t *profile_type = NULL;
1129
1130         CONN_LOCK;
1131
1132         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1133
1134         if (!(_connection_libnet_check_profile_validity(profile)) ||
1135             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1136              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1137                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1138                 CONN_UNLOCK;
1139                 return CONNECTION_ERROR_INVALID_PARAMETER;
1140         }
1141
1142         net_profile_info_t *profile_info = profile;
1143         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1144         if (net_info == NULL) {
1145                 CONN_UNLOCK; //LCOV_EXCL_LINE
1146                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1147         }
1148
1149         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
1150                 profile_type = &net_info->IpConfigType ;
1151         else
1152                 profile_type = &net_info->IpConfigType6 ;
1153
1154         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1155                 switch (type) {
1156                 //LCOV_EXCL_START
1157                 case CONNECTION_IP_CONFIG_TYPE_STATIC:
1158                         *profile_type = NET_IP_CONFIG_TYPE_STATIC;
1159                         net_info->IpAddr.Data.Ipv4.s_addr = 0;
1160                         net_info->SubnetMask.Data.Ipv4.s_addr = 0;
1161                         net_info->GatewayAddr.Data.Ipv4.s_addr = 0 ;
1162                         break;
1163
1164                 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
1165                         *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
1166                         break;
1167
1168                 case CONNECTION_IP_CONFIG_TYPE_AUTO:
1169                         *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
1170                         break;
1171
1172                 case CONNECTION_IP_CONFIG_TYPE_FIXED:
1173                         net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
1174                         break;
1175
1176                 case CONNECTION_IP_CONFIG_TYPE_NONE:
1177                         *profile_type = NET_IP_CONFIG_TYPE_OFF;
1178                         break;
1179
1180                 default:
1181                         CONN_UNLOCK;
1182                         return CONNECTION_ERROR_INVALID_PARAMETER;
1183                 //LCOV_EXCL_STOP
1184                 }
1185         } else {
1186                 //LCOV_EXCL_START
1187                 switch (type) {
1188                 case CONNECTION_IP_CONFIG_TYPE_STATIC:
1189                         *profile_type = NET_IP_CONFIG_TYPE_STATIC;
1190                         inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
1191                         net_info->PrefixLen6 = 0 ;
1192                         inet_pton(AF_INET6, "::",
1193                                         &net_info->GatewayAddr6.Data.Ipv6);
1194                         break;
1195
1196                 case CONNECTION_IP_CONFIG_TYPE_AUTO:
1197                         *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
1198                         break;
1199
1200                 case CONNECTION_IP_CONFIG_TYPE_NONE:
1201                         *profile_type = NET_IP_CONFIG_TYPE_OFF;
1202                         break;
1203
1204                 default:
1205                         CONN_UNLOCK;
1206                         return CONNECTION_ERROR_INVALID_PARAMETER;
1207                 }
1208                 //LCOV_EXCL_STOP
1209         }
1210
1211         CONN_UNLOCK;
1212         return CONNECTION_ERROR_NONE;
1213 }
1214
1215 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
1216                 connection_address_family_e address_family, const char* ip_address)
1217 {
1218         CONN_LOCK;
1219
1220         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1221
1222         if (!(_connection_libnet_check_profile_validity(profile)) ||
1223             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1224              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1225                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1226                 CONN_UNLOCK;
1227                 return CONNECTION_ERROR_INVALID_PARAMETER;
1228         }
1229
1230         net_profile_info_t *profile_info = profile;
1231         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1232         if (net_info == NULL) {
1233                 CONN_UNLOCK; //LCOV_EXCL_LINE
1234                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1235         }
1236
1237         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1238                 //LCOV_EXCL_START
1239                 if (ip_address == NULL)
1240                         inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
1241                 else if (inet_pton(AF_INET6, ip_address, &net_info->IpAddr6.Data.Ipv6) < 1) {
1242                         CONN_UNLOCK;
1243                         return CONNECTION_ERROR_INVALID_PARAMETER;
1244                 }
1245                 //LCOV_EXCL_STOP
1246         } else {
1247                 if (ip_address == NULL)
1248                         net_info->IpAddr.Data.Ipv4.s_addr = 0;
1249                 else if (inet_pton(AF_INET, ip_address, &net_info->IpAddr.Data.Ipv4) < 1) {
1250                         CONN_UNLOCK; //LCOV_EXCL_LINE
1251                         return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1252                 }
1253         }
1254
1255         CONN_UNLOCK;
1256         return CONNECTION_ERROR_NONE;
1257 }
1258
1259 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
1260                 connection_address_family_e address_family, const char* subnet_mask)
1261 {
1262         CONN_LOCK;
1263
1264         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1265
1266         if (!(_connection_libnet_check_profile_validity(profile)) ||
1267                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1268                          address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1269                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1270                 CONN_UNLOCK;
1271                 return CONNECTION_ERROR_INVALID_PARAMETER;
1272         }
1273
1274         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1275                 CONNECTION_LOG(CONNECTION_ERROR, //LCOV_EXCL_LINE
1276                                 "Please uses connection_profile_set_prefix_length()");
1277                 CONN_UNLOCK; //LCOV_EXCL_LINE
1278                 return CONNECTION_ERROR_NOT_SUPPORTED; //LCOV_EXCL_LINE
1279         }
1280
1281         net_profile_info_t *profile_info = profile;
1282         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1283         if (net_info == NULL) {
1284                 CONN_UNLOCK; //LCOV_EXCL_LINE
1285                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1286         }
1287
1288         if (subnet_mask == NULL)
1289                 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
1290         else if (inet_pton(AF_INET, subnet_mask , &net_info->SubnetMask.Data.Ipv4) < 1) {
1291                 CONN_UNLOCK; //LCOV_EXCL_LINE
1292                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1293         }
1294
1295         net_info->PrefixLen = __profile_convert_netmask_to_prefix_len(subnet_mask);
1296         if (net_info->PrefixLen <= 0 || net_info->PrefixLen > 31) {
1297                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid Prefix length: %d", net_info->PrefixLen); //LCOV_EXCL_LINE
1298                 CONN_UNLOCK; //LCOV_EXCL_LINE
1299                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1300         }
1301
1302         CONN_UNLOCK;
1303         return CONNECTION_ERROR_NONE;
1304 }
1305
1306 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
1307                 connection_address_family_e address_family, const char* gateway_address)
1308 {
1309         CONN_LOCK;
1310
1311         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1312
1313         if (!(_connection_libnet_check_profile_validity(profile)) ||
1314             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1315              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1316                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1317                 CONN_UNLOCK;
1318                 return CONNECTION_ERROR_INVALID_PARAMETER;
1319         }
1320
1321         net_profile_info_t *profile_info = profile;
1322         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1323         if (net_info == NULL) {
1324                 CONN_UNLOCK; //LCOV_EXCL_LINE
1325                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1326         }
1327
1328         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1329                 //LCOV_EXCL_START
1330                 if (gateway_address == NULL)
1331                         inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6);
1332                 else if (inet_pton(AF_INET6, gateway_address, &net_info->GatewayAddr6.Data.Ipv6) < 1) {
1333                         CONN_UNLOCK;
1334                         return CONNECTION_ERROR_INVALID_PARAMETER;
1335                 }
1336                 //LCOV_EXCL_STOP
1337         } else {
1338                 if (gateway_address == NULL)
1339                         net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
1340                 else if (inet_pton(AF_INET, gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) < 1) {
1341                         CONN_UNLOCK; //LCOV_EXCL_LINE
1342                         return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1343                 }
1344         }
1345
1346         CONN_UNLOCK;
1347         return CONNECTION_ERROR_NONE;
1348 }
1349
1350 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
1351                 connection_address_family_e address_family, const char* dns_address)
1352 {
1353         CONN_LOCK;
1354
1355         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1356
1357         if (!(_connection_libnet_check_profile_validity(profile)) ||
1358             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1359              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1360             order <= 0 ||
1361             order > NET_DNS_ADDR_MAX) {
1362                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1363                 CONN_UNLOCK;
1364                 return CONNECTION_ERROR_INVALID_PARAMETER;
1365         }
1366
1367         net_profile_info_t *profile_info = profile;
1368         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1369         if (net_info == NULL) {
1370                 CONN_UNLOCK; //LCOV_EXCL_LINE
1371                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1372         }
1373
1374         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1375                 //LCOV_EXCL_START
1376                 net_info->DnsAddr6[order-1].Type = NET_ADDR_IPV6;
1377                 if (dns_address == NULL)
1378                         inet_pton(AF_INET6, "::", &net_info->DnsAddr6[order-1].Data.Ipv6);
1379                 else if (inet_pton(AF_INET6, dns_address, &net_info->DnsAddr6[order-1].Data.Ipv6) < 1) {
1380                         CONN_UNLOCK;
1381                         return CONNECTION_ERROR_INVALID_PARAMETER;
1382                 }
1383                 if (net_info->DnsCount6 < order)
1384                         net_info->DnsCount6 = order;
1385                 //LCOV_EXCL_STOP
1386         } else {
1387                 net_info->DnsAddr[order-1].Type = NET_ADDR_IPV4;
1388                 if (dns_address == NULL)
1389                         net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
1390                 else if (inet_pton(AF_INET, dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) < 1) {
1391                         CONN_UNLOCK; //LCOV_EXCL_LINE
1392                         return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1393                 }
1394                 if (net_info->DnsCount < order)
1395                         net_info->DnsCount = order;
1396         }
1397
1398         CONN_UNLOCK;
1399         return CONNECTION_ERROR_NONE;
1400 }
1401
1402 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
1403 {
1404         CONN_LOCK;
1405
1406         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1407
1408         if (!(_connection_libnet_check_profile_validity(profile))) {
1409                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1410                 CONN_UNLOCK;
1411                 return CONNECTION_ERROR_INVALID_PARAMETER;
1412         }
1413
1414         net_profile_info_t *profile_info = profile;
1415         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1416         if (net_info == NULL) {
1417                 CONN_UNLOCK; //LCOV_EXCL_LINE
1418                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1419         }
1420
1421         switch (type) {
1422         //LCOV_EXCL_START
1423         case CONNECTION_PROXY_TYPE_DIRECT:
1424                 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
1425                 break;
1426         case CONNECTION_PROXY_TYPE_AUTO:
1427                 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
1428                 break;
1429         case CONNECTION_PROXY_TYPE_MANUAL:
1430                 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
1431                 break;
1432         default:
1433                 CONN_UNLOCK;
1434                 return CONNECTION_ERROR_INVALID_PARAMETER;
1435         //LCOV_EXCL_STOP
1436         }
1437
1438         CONN_UNLOCK;
1439         return CONNECTION_ERROR_NONE;
1440 }
1441
1442 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
1443                 connection_address_family_e address_family, const char* proxy_address)
1444 {
1445         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1446
1447         CONNECTION_LOG(CONNECTION_ERROR, "Address Family: %d", address_family);
1448         if (!(_connection_libnet_check_profile_validity(profile)) ||
1449             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1450              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1451                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1452                 CONN_UNLOCK;
1453                 return CONNECTION_ERROR_INVALID_PARAMETER;
1454         }
1455
1456         net_profile_info_t *profile_info = profile;
1457         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1458         if (net_info == NULL) {
1459                 CONN_UNLOCK; //LCOV_EXCL_LINE
1460                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1461         }
1462
1463         if (proxy_address == NULL)
1464                 net_info->ProxyAddr[0] = '\0';
1465         else
1466                 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
1467
1468         CONN_UNLOCK;
1469         return CONNECTION_ERROR_NONE;
1470 }
1471
1472 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
1473                 connection_profile_state_changed_cb callback, void* user_data)
1474 {
1475         CONN_LOCK;
1476
1477         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1478
1479         if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
1480                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1481                 CONN_UNLOCK;
1482                 return CONNECTION_ERROR_INVALID_PARAMETER;
1483         }
1484
1485         if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data)) {
1486                 CONN_UNLOCK;
1487                 return CONNECTION_ERROR_NONE;
1488         }
1489
1490         CONN_UNLOCK; //LCOV_EXCL_LINE
1491         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1492 }
1493
1494 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
1495 {
1496         CONN_LOCK;
1497
1498         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1499
1500         if (!(_connection_libnet_check_profile_validity(profile))) {
1501                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1502                 CONN_UNLOCK;
1503                 return CONNECTION_ERROR_INVALID_PARAMETER;
1504         }
1505
1506         if (_connection_libnet_remove_from_profile_cb_list(profile) != true) {
1507                 CONN_UNLOCK; //LCOV_EXCL_LINE
1508                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1509         }
1510
1511         CONN_UNLOCK;
1512         return CONNECTION_ERROR_NONE;
1513 }
1514
1515
1516 /* Wi-Fi profile *************************************************************/
1517 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
1518 {
1519         CONN_LOCK;
1520
1521         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1522
1523         if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
1524                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1525                 CONN_UNLOCK;
1526                 return CONNECTION_ERROR_INVALID_PARAMETER;
1527         }
1528
1529         net_profile_info_t *profile_info = profile;
1530
1531         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1532                                 profile_info->profile_type != NET_DEVICE_MESH) {
1533                 CONN_UNLOCK;
1534                 return CONNECTION_ERROR_INVALID_PARAMETER;
1535         }
1536
1537         if (profile_info->profile_type == NET_DEVICE_WIFI)
1538                 *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
1539         else
1540                 *essid = g_strdup(profile_info->ProfileInfo.Mesh.essid);
1541
1542         if (*essid == NULL) {
1543                 CONN_UNLOCK; //LCOV_EXCL_LINE
1544                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1545         }
1546
1547         CONN_UNLOCK;
1548         return CONNECTION_ERROR_NONE;
1549 }
1550
1551 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
1552 {
1553         CONN_LOCK;
1554
1555         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1556
1557         if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
1558                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1559                 CONN_UNLOCK;
1560                 return CONNECTION_ERROR_INVALID_PARAMETER;
1561         }
1562
1563         net_profile_info_t *profile_info = profile;
1564
1565         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1566                                 profile_info->profile_type != NET_DEVICE_MESH) {
1567                 CONN_UNLOCK;
1568                 return CONNECTION_ERROR_INVALID_PARAMETER;
1569         }
1570
1571         if (profile_info->profile_type == NET_DEVICE_WIFI)
1572                 *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
1573         else
1574                 *bssid = g_strdup(profile_info->ProfileInfo.Mesh.bssid);
1575
1576         if (*bssid == NULL) {
1577                 CONN_UNLOCK; //LCOV_EXCL_LINE
1578                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1579         }
1580
1581         CONN_UNLOCK;
1582         return CONNECTION_ERROR_NONE;
1583 }
1584
1585 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
1586 {
1587         CONN_LOCK;
1588
1589         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1590
1591         if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
1592                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1593                 CONN_UNLOCK;
1594                 return CONNECTION_ERROR_INVALID_PARAMETER;
1595         }
1596
1597         net_profile_info_t *profile_info = profile;
1598
1599         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1600                                 profile_info->profile_type != NET_DEVICE_MESH) {
1601                 CONN_UNLOCK;
1602                 return CONNECTION_ERROR_INVALID_PARAMETER;
1603         }
1604
1605         if (profile_info->profile_type == NET_DEVICE_WIFI)
1606                 *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
1607         else
1608                 *rssi = (int)profile_info->ProfileInfo.Mesh.Strength;
1609
1610         CONN_UNLOCK;
1611         return CONNECTION_ERROR_NONE;
1612 }
1613
1614 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
1615 {
1616         CONN_LOCK;
1617
1618         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1619
1620         if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
1621                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1622                 CONN_UNLOCK;
1623                 return CONNECTION_ERROR_INVALID_PARAMETER;
1624         }
1625
1626         net_profile_info_t *profile_info = profile;
1627
1628         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1629                                 profile_info->profile_type != NET_DEVICE_MESH) {
1630                 CONN_UNLOCK;
1631                 return CONNECTION_ERROR_INVALID_PARAMETER;
1632         }
1633
1634         if (profile_info->profile_type == NET_DEVICE_WIFI)
1635                 *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
1636         else
1637                 *frequency = (int)profile_info->ProfileInfo.Mesh.frequency;
1638
1639         CONN_UNLOCK;
1640         return CONNECTION_ERROR_NONE;
1641 }
1642
1643 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
1644 {
1645         CONN_LOCK;
1646
1647         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1648
1649         if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
1650                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1651                 CONN_UNLOCK;
1652                 return CONNECTION_ERROR_INVALID_PARAMETER;
1653         }
1654
1655         net_profile_info_t *profile_info = profile;
1656
1657         if (profile_info->profile_type != NET_DEVICE_WIFI) {
1658                 CONN_UNLOCK;
1659                 return CONNECTION_ERROR_INVALID_PARAMETER;
1660         }
1661
1662         *max_speed = profile_info->ProfileInfo.Wlan.max_rate;
1663
1664         CONN_UNLOCK;
1665         return CONNECTION_ERROR_NONE;
1666 }
1667
1668 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e *type)
1669 {
1670         CONN_LOCK;
1671
1672         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1673
1674         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1675                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1676                 CONN_UNLOCK;
1677                 return CONNECTION_ERROR_INVALID_PARAMETER;
1678         }
1679
1680         net_profile_info_t *profile_info = profile;
1681
1682         wlan_security_mode_type_t sec_mode;
1683         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1684                                 profile_info->profile_type != NET_DEVICE_MESH) {
1685                 CONN_UNLOCK;
1686                 return CONNECTION_ERROR_INVALID_PARAMETER;
1687         }
1688
1689         if (profile_info->profile_type == NET_DEVICE_WIFI)
1690                 sec_mode = profile_info->ProfileInfo.Wlan.security_info.sec_mode;
1691         else
1692                 sec_mode = profile_info->ProfileInfo.Mesh.security_info.sec_mode;
1693
1694         switch (sec_mode) {
1695         //LCOV_EXCL_START
1696         case WLAN_SEC_MODE_NONE:
1697                 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
1698                 break;
1699         case WLAN_SEC_MODE_WEP:
1700                 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
1701                 break;
1702         case WLAN_SEC_MODE_IEEE8021X:
1703                 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
1704                 break;
1705         case WLAN_SEC_MODE_WPA_PSK:
1706                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
1707                 break;
1708         case WLAN_SEC_MODE_WPA2_PSK:
1709                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
1710                 break;
1711         case WLAN_SEC_MODE_SAE:
1712                 *type = CONNECTION_WIFI_SECURITY_TYPE_SAE;
1713                 break;
1714         default:
1715                 CONN_UNLOCK;
1716                 return CONNECTION_ERROR_OPERATION_FAILED;
1717         //LCOV_EXCL_STOP
1718         }
1719
1720         CONN_UNLOCK;
1721         return CONNECTION_ERROR_NONE;
1722 }
1723
1724 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e *type)
1725 {
1726         CONN_LOCK;
1727
1728         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1729
1730         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1731                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1732                 CONN_UNLOCK;
1733                 return CONNECTION_ERROR_INVALID_PARAMETER;
1734         }
1735
1736         net_profile_info_t *profile_info = profile;
1737
1738         if (profile_info->profile_type != NET_DEVICE_WIFI) {
1739                 CONN_UNLOCK;
1740                 return CONNECTION_ERROR_INVALID_PARAMETER;
1741         }
1742
1743         switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1744         //LCOV_EXCL_START
1745         case WLAN_ENC_MODE_NONE:
1746                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1747                 break;
1748         case WLAN_ENC_MODE_WEP:
1749                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1750                 break;
1751         case WLAN_ENC_MODE_TKIP:
1752                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1753                 break;
1754         case WLAN_ENC_MODE_AES:
1755                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1756                 break;
1757         case WLAN_ENC_MODE_TKIP_AES_MIXED:
1758                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1759                 break;
1760         default:
1761                 CONN_UNLOCK;
1762                 return CONNECTION_ERROR_OPERATION_FAILED;
1763         //LCOV_EXCL_STOP
1764         }
1765
1766         CONN_UNLOCK;
1767         return CONNECTION_ERROR_NONE;
1768 }
1769
1770 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1771 {
1772         CONN_LOCK;
1773
1774         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1775
1776         if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1777                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1778                 CONN_UNLOCK;
1779                 return CONNECTION_ERROR_INVALID_PARAMETER;
1780         }
1781
1782         net_profile_info_t *profile_info = profile;
1783
1784         wlan_security_mode_type_t sec_mode;
1785         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1786                                 profile_info->profile_type != NET_DEVICE_MESH) {
1787                 CONN_UNLOCK;
1788                 return CONNECTION_ERROR_INVALID_PARAMETER;
1789         }
1790
1791         if (profile_info->Favourite) {
1792                 *required = false; //LCOV_EXCL_LINE
1793                 CONN_UNLOCK; //LCOV_EXCL_LINE
1794                 return CONNECTION_ERROR_NONE; //LCOV_EXCL_LINE
1795         }
1796
1797         if (profile_info->profile_type == NET_DEVICE_WIFI)
1798                 sec_mode = profile_info->ProfileInfo.Wlan.security_info.sec_mode;
1799         else
1800                 sec_mode = profile_info->ProfileInfo.Mesh.security_info.sec_mode;
1801
1802         switch (sec_mode) {
1803         //LCOV_EXCL_START
1804         case WLAN_SEC_MODE_NONE:
1805                 *required = false;
1806                 break;
1807         case WLAN_SEC_MODE_WEP:
1808         case WLAN_SEC_MODE_IEEE8021X:
1809         case WLAN_SEC_MODE_WPA_PSK:
1810         case WLAN_SEC_MODE_WPA2_PSK:
1811         case WLAN_SEC_MODE_SAE:
1812                 *required = true;
1813                 break;
1814         default:
1815                 CONN_UNLOCK;
1816                 return CONNECTION_ERROR_OPERATION_FAILED;
1817         //LCOV_EXCL_STOP
1818         }
1819
1820         CONN_UNLOCK;
1821         return CONNECTION_ERROR_NONE;
1822 }
1823
1824 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1825 {
1826         CONN_LOCK;
1827
1828         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1829
1830         if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1831                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1832                 CONN_UNLOCK;
1833                 return CONNECTION_ERROR_INVALID_PARAMETER;
1834         }
1835
1836         net_profile_info_t *profile_info = profile;
1837
1838         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1839                                 profile_info->profile_type != NET_DEVICE_MESH) {
1840                 CONN_UNLOCK;
1841                 return CONNECTION_ERROR_INVALID_PARAMETER;
1842         }
1843
1844         if (profile_info->profile_type == NET_DEVICE_WIFI)
1845                 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1846                                   passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1847         else
1848                 g_strlcpy(profile_info->ProfileInfo.Mesh.security_info.authentication.sae.saeKey,
1849                                   passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1850
1851         CONN_UNLOCK;
1852         return CONNECTION_ERROR_NONE;
1853 }
1854
1855 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1856 {
1857         CONN_LOCK;
1858
1859         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1860
1861         if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1862                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1863                 CONN_UNLOCK;
1864                 return CONNECTION_ERROR_INVALID_PARAMETER;
1865         }
1866
1867         net_profile_info_t *profile_info = profile;
1868
1869         if (profile_info->profile_type != NET_DEVICE_WIFI) {
1870                 CONN_UNLOCK;
1871                 return CONNECTION_ERROR_INVALID_PARAMETER;
1872         }
1873
1874         if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1875                 *supported = true;
1876         else
1877                 *supported = false;
1878
1879         CONN_UNLOCK;
1880         return CONNECTION_ERROR_NONE;
1881 }
1882
1883
1884 /* Cellular profile **********************************************************/
1885 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1886                                                 connection_cellular_service_type_e* type)
1887 {
1888         CONN_LOCK;
1889
1890         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1891
1892         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1893                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1894                 CONN_UNLOCK;
1895                 return CONNECTION_ERROR_INVALID_PARAMETER;
1896         }
1897
1898         net_profile_info_t *profile_info = profile;
1899
1900         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1901                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1902                 CONN_UNLOCK;
1903                 return CONNECTION_ERROR_INVALID_PARAMETER;
1904         }
1905
1906         *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1907
1908         if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1909                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed"); //LCOV_EXCL_LINE
1910                 CONN_UNLOCK; //LCOV_EXCL_LINE
1911                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1912         }
1913
1914         CONN_UNLOCK;
1915         return CONNECTION_ERROR_NONE;
1916 }
1917
1918 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1919 {
1920         CONN_LOCK;
1921
1922         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1923
1924         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1925                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1926                 CONN_UNLOCK;
1927                 return CONNECTION_ERROR_INVALID_PARAMETER;
1928         }
1929
1930         net_profile_info_t *profile_info = profile;
1931
1932         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1933                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1934                 CONN_UNLOCK; //LCOV_EXCL_LINE
1935                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1936         }
1937
1938         *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1939         if (*apn == NULL) {
1940                 CONN_UNLOCK; //LCOV_EXCL_LINE
1941                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1942         }
1943
1944         CONN_UNLOCK;
1945         return CONNECTION_ERROR_NONE;
1946 }
1947
1948 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1949                 connection_cellular_auth_type_e *type, char** user_name, char** password)
1950 {
1951         CONN_LOCK;
1952
1953         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1954
1955         if (!(_connection_libnet_check_profile_validity(profile)) ||
1956             type == NULL || user_name == NULL || password == NULL) {
1957                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1958                 CONN_UNLOCK;
1959                 return CONNECTION_ERROR_INVALID_PARAMETER;
1960         }
1961
1962         net_profile_info_t *profile_info = profile;
1963
1964         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1965                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1966                 CONN_UNLOCK;
1967                 return CONNECTION_ERROR_INVALID_PARAMETER;
1968         }
1969
1970         switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1971         //LCOV_EXCL_START
1972         case NET_PDP_AUTH_NONE:
1973                 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1974                 break;
1975         case NET_PDP_AUTH_PAP:
1976                 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1977                 break;
1978         case NET_PDP_AUTH_CHAP:
1979                 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1980                 break;
1981         default:
1982                 CONN_UNLOCK;
1983                 return CONNECTION_ERROR_OPERATION_FAILED;
1984         //LCOV_EXCL_STOP
1985         }
1986
1987         *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1988         if (*user_name == NULL) {
1989                 CONN_UNLOCK; //LCOV_EXCL_LINE
1990                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1991         }
1992
1993         *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1994         if (*password == NULL) {
1995                 g_free(*user_name); //LCOV_EXCL_LINE
1996                 CONN_UNLOCK; //LCOV_EXCL_LINE
1997                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1998         }
1999
2000         CONN_UNLOCK;
2001         return CONNECTION_ERROR_NONE;
2002 }
2003
2004 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
2005 {
2006         CONN_LOCK;
2007
2008         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2009
2010         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
2011                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2012                 CONN_UNLOCK;
2013                 return CONNECTION_ERROR_INVALID_PARAMETER;
2014         }
2015
2016         net_profile_info_t *profile_info = profile;
2017
2018         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2019                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2020                 CONN_UNLOCK;
2021                 return CONNECTION_ERROR_INVALID_PARAMETER;
2022         }
2023
2024         *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
2025         if (*home_url == NULL) {
2026                 CONN_UNLOCK; //LCOV_EXCL_LINE
2027                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
2028         }
2029
2030         CONN_UNLOCK;
2031         return CONNECTION_ERROR_NONE;
2032 }
2033
2034 EXPORT_API int connection_profile_get_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
2035 {
2036         CONN_LOCK;
2037
2038         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2039
2040         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
2041                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2042                 CONN_UNLOCK;
2043                 return CONNECTION_ERROR_INVALID_PARAMETER;
2044         }
2045
2046         net_profile_info_t *profile_info = profile;
2047
2048         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2049                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2050                 CONN_UNLOCK;
2051                 return CONNECTION_ERROR_INVALID_PARAMETER;
2052         }
2053
2054         switch (profile_info->ProfileInfo.Pdp.PdnType) {
2055         //LCOV_EXCL_START
2056         case NET_PDN_TYPE_UNKNOWN:
2057                 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
2058                 break;
2059         case NET_PDN_TYPE_IPV4:
2060                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
2061                 break;
2062         case NET_PDN_TYPE_IPV6:
2063                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
2064                 break;
2065         case NET_PDN_TYPE_IPV4_IPV6:
2066                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
2067                 break;
2068         default:
2069                 CONN_UNLOCK;
2070                 return CONNECTION_ERROR_OPERATION_FAILED;
2071         //LCOV_EXCL_STOP
2072         }
2073
2074         CONN_UNLOCK;
2075         return CONNECTION_ERROR_NONE;
2076 }
2077
2078 EXPORT_API int connection_profile_get_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
2079 {
2080         CONN_LOCK;
2081
2082         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2083
2084         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
2085                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2086                 CONN_UNLOCK;
2087                 return CONNECTION_ERROR_INVALID_PARAMETER;
2088         }
2089
2090         net_profile_info_t *profile_info = profile;
2091
2092         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2093                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2094                 CONN_UNLOCK;
2095                 return CONNECTION_ERROR_INVALID_PARAMETER;
2096         }
2097
2098         switch (profile_info->ProfileInfo.Pdp.RoamPdnType) {
2099         //LCOV_EXCL_START
2100         case NET_PDN_TYPE_UNKNOWN:
2101                 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
2102                 break;
2103         case NET_PDN_TYPE_IPV4:
2104                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
2105                 break;
2106         case NET_PDN_TYPE_IPV6:
2107                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
2108                 break;
2109         case NET_PDN_TYPE_IPV4_IPV6:
2110                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
2111                 break;
2112         default:
2113                 CONN_UNLOCK;
2114                 return CONNECTION_ERROR_OPERATION_FAILED;
2115         //LCOV_EXCL_STOP
2116         }
2117
2118         CONN_UNLOCK;
2119         return CONNECTION_ERROR_NONE;
2120 }
2121
2122 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
2123 {
2124         CONN_LOCK;
2125
2126         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2127
2128         if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
2129                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2130                 CONN_UNLOCK;
2131                 return CONNECTION_ERROR_INVALID_PARAMETER;
2132         }
2133
2134         net_profile_info_t *profile_info = profile;
2135
2136         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2137                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2138                 CONN_UNLOCK;
2139                 return CONNECTION_ERROR_INVALID_PARAMETER;
2140         }
2141
2142         if (profile_info->ProfileInfo.Pdp.Roaming)
2143                 *is_roaming = true;
2144         else
2145                 *is_roaming = false;
2146
2147         CONN_UNLOCK;
2148         return CONNECTION_ERROR_NONE;
2149 }
2150
2151 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
2152 {
2153         CONN_LOCK;
2154
2155         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2156
2157         if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
2158                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2159                 CONN_UNLOCK;
2160                 return CONNECTION_ERROR_INVALID_PARAMETER;
2161         }
2162
2163         net_profile_info_t *profile_info = profile;
2164
2165         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2166                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2167                 CONN_UNLOCK;
2168                 return CONNECTION_ERROR_INVALID_PARAMETER;
2169         }
2170
2171         if (profile_info->ProfileInfo.Pdp.Hidden)
2172                 *is_hidden = true;
2173         else
2174                 *is_hidden = false;
2175
2176         CONN_UNLOCK;
2177         return CONNECTION_ERROR_NONE;
2178 }
2179
2180 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
2181 {
2182         CONN_LOCK;
2183
2184         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2185
2186         if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
2187                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2188                 CONN_UNLOCK;
2189                 return CONNECTION_ERROR_INVALID_PARAMETER;
2190         }
2191
2192         net_profile_info_t *profile_info = profile;
2193
2194         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2195                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2196                 CONN_UNLOCK;
2197                 return CONNECTION_ERROR_INVALID_PARAMETER;
2198         }
2199
2200         if (profile_info->ProfileInfo.Pdp.Editable)
2201                 *is_editable = true;
2202         else
2203                 *is_editable = false;
2204
2205         CONN_UNLOCK;
2206         return CONNECTION_ERROR_NONE;
2207 }
2208
2209 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
2210 {
2211         CONN_LOCK;
2212
2213         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2214
2215         if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
2216                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2217                 CONN_UNLOCK;
2218                 return CONNECTION_ERROR_INVALID_PARAMETER;
2219         }
2220
2221         net_profile_info_t *profile_info = profile;
2222
2223         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2224                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2225                 CONN_UNLOCK;
2226                 return CONNECTION_ERROR_INVALID_PARAMETER;
2227         }
2228
2229         if (profile_info->ProfileInfo.Pdp.DefaultConn)
2230                 *is_default = true;
2231         else
2232                 *is_default = false;
2233
2234         CONN_UNLOCK;
2235         return CONNECTION_ERROR_NONE;
2236 }
2237
2238 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
2239                 connection_cellular_service_type_e service_type)
2240 {
2241         CONN_LOCK;
2242
2243         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2244
2245         if (!(_connection_libnet_check_profile_validity(profile))) {
2246                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2247                 CONN_UNLOCK;
2248                 return CONNECTION_ERROR_INVALID_PARAMETER;
2249         }
2250
2251         net_profile_info_t *profile_info = profile;
2252
2253         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2254                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2255                 CONN_UNLOCK;
2256                 return CONNECTION_ERROR_INVALID_PARAMETER;
2257         }
2258
2259         switch (service_type) {
2260         //LCOV_EXCL_START
2261         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
2262                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
2263                 break;
2264         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
2265                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
2266                 break;
2267         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
2268                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
2269                 break;
2270         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
2271                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
2272                 break;
2273         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
2274                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
2275                 break;
2276         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
2277                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
2278                 break;
2279         case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
2280         default:
2281                 CONN_UNLOCK;
2282                 return CONNECTION_ERROR_INVALID_PARAMETER;
2283         //LCOV_EXCL_STOP
2284         }
2285
2286         CONN_UNLOCK;
2287         return CONNECTION_ERROR_NONE;
2288 }
2289
2290 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
2291 {
2292         CONN_LOCK;
2293
2294         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2295
2296         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
2297                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2298                 CONN_UNLOCK;
2299                 return CONNECTION_ERROR_INVALID_PARAMETER;
2300         }
2301
2302         net_profile_info_t *profile_info = profile;
2303
2304         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2305                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2306                 CONN_UNLOCK;
2307                 return CONNECTION_ERROR_INVALID_PARAMETER;
2308         }
2309
2310         g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
2311
2312         CONN_UNLOCK;
2313         return CONNECTION_ERROR_NONE;
2314 }
2315
2316 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
2317                 connection_cellular_auth_type_e type, const char* user_name, const char* password)
2318 {
2319         CONN_LOCK;
2320
2321         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2322
2323         if (!(_connection_libnet_check_profile_validity(profile)) ||
2324             user_name == NULL || password == NULL) {
2325                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2326                 CONN_UNLOCK;
2327                 return CONNECTION_ERROR_INVALID_PARAMETER;
2328         }
2329
2330         net_profile_info_t *profile_info = profile;
2331
2332         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2333                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2334                 CONN_UNLOCK;
2335                 return CONNECTION_ERROR_INVALID_PARAMETER;
2336         }
2337
2338         switch (type) {
2339         //LCOV_EXCL_START
2340         case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
2341                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
2342                 break;
2343         case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
2344                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
2345                 break;
2346         case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
2347                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
2348                 break;
2349         default:
2350                 CONN_UNLOCK;
2351                 return CONNECTION_ERROR_INVALID_PARAMETER;
2352         //LCOV_EXCL_STOP
2353         }
2354
2355         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
2356         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
2357
2358         CONN_UNLOCK;
2359         return CONNECTION_ERROR_NONE;
2360 }
2361
2362 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
2363 {
2364         CONN_LOCK;
2365
2366         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2367
2368         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
2369                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2370                 CONN_UNLOCK;
2371                 return CONNECTION_ERROR_INVALID_PARAMETER;
2372         }
2373
2374         net_profile_info_t *profile_info = profile;
2375
2376         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2377                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2378                 CONN_UNLOCK;
2379                 return CONNECTION_ERROR_INVALID_PARAMETER;
2380         }
2381
2382         g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
2383
2384         CONN_UNLOCK;
2385         return CONNECTION_ERROR_NONE;
2386 }
2387
2388 EXPORT_API int connection_profile_set_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
2389 {
2390         CONN_LOCK;
2391
2392         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2393
2394         if (!(_connection_libnet_check_profile_validity(profile))) {
2395                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2396                 CONN_UNLOCK;
2397                 return CONNECTION_ERROR_INVALID_PARAMETER;
2398         }
2399
2400         net_profile_info_t *profile_info = profile;
2401
2402         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2403                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2404                 CONN_UNLOCK;
2405                 return CONNECTION_ERROR_INVALID_PARAMETER;
2406         }
2407
2408         switch (type) {
2409         //LCOV_EXCL_START
2410         case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
2411                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4;
2412                 break;
2413         case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
2414                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV6;
2415                 break;
2416         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
2417                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
2418                 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
2419                                                 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
2420                 break;
2421         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
2422                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
2423                 break;
2424         default:
2425                 CONN_UNLOCK;
2426                 return CONNECTION_ERROR_INVALID_PARAMETER;
2427         //LCOV_EXCL_STOP
2428         }
2429
2430         CONN_UNLOCK;
2431         return CONNECTION_ERROR_NONE;
2432 }
2433
2434 EXPORT_API int connection_profile_set_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
2435 {
2436         CONN_LOCK;
2437
2438         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2439
2440         if (!(_connection_libnet_check_profile_validity(profile))) {
2441                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2442                 CONN_UNLOCK;
2443                 return CONNECTION_ERROR_INVALID_PARAMETER;
2444         }
2445
2446         net_profile_info_t *profile_info = profile;
2447
2448         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2449                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2450                 CONN_UNLOCK;
2451                 return CONNECTION_ERROR_INVALID_PARAMETER;
2452         }
2453
2454         switch (type) {
2455         //LCOV_EXCL_START
2456         case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
2457                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4;
2458                 break;
2459         case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
2460                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV6;
2461                 break;
2462         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
2463                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
2464                 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
2465                                                 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
2466                 break;
2467         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
2468                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
2469                 break;
2470         default:
2471                 CONN_UNLOCK;
2472                 return CONNECTION_ERROR_INVALID_PARAMETER;
2473         //LCOV_EXCL_STOP
2474         }
2475
2476         CONN_UNLOCK;
2477         return CONNECTION_ERROR_NONE;
2478 }
2479
2480 EXPORT_API int connection_profile_get_ipv6_state(connection_profile_h profile, connection_profile_state_e *state)
2481 {
2482         CONN_LOCK;
2483
2484         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2485                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2486
2487         if (!(_connection_libnet_check_profile_validity(profile)) ||
2488                         state == NULL) {
2489                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2490                 CONN_UNLOCK;
2491                 return CONNECTION_ERROR_INVALID_PARAMETER;
2492         }
2493
2494         net_profile_info_t *profile_info = profile;
2495         *state = _profile_convert_to_cp_state(profile_info->ProfileState6);
2496
2497         CONN_UNLOCK;
2498         return CONNECTION_ERROR_NONE;
2499 }
2500
2501 EXPORT_API int connection_profile_set_dns_config_type(connection_profile_h profile,
2502                 connection_address_family_e address_family, connection_dns_config_type_e type)
2503 {
2504         CONN_LOCK;
2505
2506         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2507                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2508
2509         if (!(_connection_libnet_check_profile_validity(profile))) {
2510                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2511                 CONN_UNLOCK;
2512                 return CONNECTION_ERROR_INVALID_PARAMETER;
2513         }
2514
2515         if ((address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2516                                 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2517                         (type != CONNECTION_DNS_CONFIG_TYPE_STATIC &&
2518                          type != CONNECTION_DNS_CONFIG_TYPE_DYNAMIC)) {
2519                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2520                 CONN_UNLOCK; //LCOV_EXCL_LINE
2521                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2522         }
2523
2524         net_dns_config_type_t *profileType = NULL;
2525         net_dns_config_type_t *profileType6 = NULL;
2526         net_profile_info_t *profile_info = profile;
2527
2528         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2529         if (net_info == NULL) {
2530                 CONN_UNLOCK; //LCOV_EXCL_LINE
2531                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
2532         }
2533
2534         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
2535                 profileType = &net_info->DnsConfigType;
2536                 net_info->DnsAddr[0].Data.Ipv4.s_addr = 0;
2537                 net_info->DnsAddr[1].Data.Ipv4.s_addr = 0;
2538                 *profileType = type;
2539         } else {
2540                 profileType6 = &net_info->DnsConfigType6;
2541                 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[0].Data.Ipv6);
2542                 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[1].Data.Ipv6);
2543                 *profileType6 = type;
2544         }
2545
2546         CONN_UNLOCK;
2547         return CONNECTION_ERROR_NONE;
2548 }
2549
2550 EXPORT_API int connection_profile_get_dns_config_type(connection_profile_h profile,
2551                 connection_address_family_e address_family, connection_dns_config_type_e *type)
2552 {
2553         CONN_LOCK;
2554
2555         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2556                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2557
2558         if (!(_connection_libnet_check_profile_validity(profile)) ||
2559                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2560                          address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2561                         type == NULL) {
2562                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2563                 CONN_UNLOCK;
2564                 return CONNECTION_ERROR_INVALID_PARAMETER;
2565         }
2566
2567         net_dns_config_type_t profileType;
2568         net_profile_info_t *profile_info = profile;
2569         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2570         if (net_info == NULL) {
2571                 CONN_UNLOCK; //LCOV_EXCL_LINE
2572                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
2573         }
2574
2575         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
2576                 profileType = net_info->DnsConfigType;
2577         else
2578                 profileType = net_info->DnsConfigType6;
2579
2580         switch (profileType) {
2581         case NET_DNS_CONFIG_TYPE_STATIC:
2582                 *type = CONNECTION_DNS_CONFIG_TYPE_STATIC;
2583                 break;
2584         case NET_DNS_CONFIG_TYPE_DYNAMIC:
2585                 *type = CONNECTION_DNS_CONFIG_TYPE_DYNAMIC;
2586                 break;
2587         default:
2588                 *type = CONNECTION_DNS_CONFIG_TYPE_NONE;
2589                 break;
2590         }
2591
2592         CONN_UNLOCK;
2593         return CONNECTION_ERROR_NONE;
2594 }
2595
2596 EXPORT_API int connection_profile_set_prefix_length(connection_profile_h profile,
2597                 connection_address_family_e address_family, int prefix_len)
2598 {
2599         CONN_LOCK;
2600
2601         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2602                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2603
2604         if (!(_connection_libnet_check_profile_validity(profile)) ||
2605                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2606                         address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
2607                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2608                 CONN_UNLOCK;
2609                 return CONNECTION_ERROR_INVALID_PARAMETER;
2610         }
2611
2612         net_profile_info_t *profile_info = profile;
2613         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2614         if (net_info == NULL) {
2615                 CONN_UNLOCK; //LCOV_EXCL_LINE
2616                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
2617         }
2618
2619         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
2620                 net_info->PrefixLen = prefix_len;
2621                 net_info->SubnetMask.Data.Ipv4.s_addr = __profile_convert_prefix_len_to_netmask(prefix_len);
2622         } else
2623                 net_info->PrefixLen6 = prefix_len;
2624
2625         CONN_UNLOCK;
2626         return CONNECTION_ERROR_NONE;
2627 }
2628
2629 EXPORT_API int connection_profile_get_prefix_length(connection_profile_h profile,
2630                 connection_address_family_e address_family, int *prefix_len)
2631 {
2632         CONN_LOCK;
2633
2634         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2635                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2636
2637         if (!(_connection_libnet_check_profile_validity(profile)) ||
2638                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2639                         address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2640                         prefix_len == NULL) {
2641                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2642                 CONN_UNLOCK;
2643                 return CONNECTION_ERROR_INVALID_PARAMETER;
2644         }
2645
2646         net_profile_info_t *profile_info = profile;
2647         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2648         if (net_info == NULL) {
2649                 CONN_UNLOCK; //LCOV_EXCL_LINE
2650                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
2651         }
2652
2653         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
2654                 *prefix_len =  net_info->PrefixLen;
2655         else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
2656                 *prefix_len =  net_info->PrefixLen6;
2657
2658         CONN_UNLOCK;
2659         return CONNECTION_ERROR_NONE;
2660 }
2661
2662 EXPORT_API int connection_profile_is_ethernet_eap_enabled(connection_profile_h profile, bool *enabled)
2663 {
2664         CONN_LOCK;
2665
2666         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2667                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2668
2669         if (!(_connection_libnet_check_profile_validity(profile)) ||
2670                         enabled == NULL) {
2671                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2672                 CONN_UNLOCK;
2673                 return CONNECTION_ERROR_INVALID_PARAMETER;
2674         }
2675
2676         int ret = _connection_libnet_ethernet_eap_enabled(enabled);
2677         if (ret != CONNECTION_ERROR_NONE) {
2678                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get EAP over Ethernet enabled status."); //LCOV_EXCL_LINE
2679                 CONN_UNLOCK; //LCOV_EXCL_LINE
2680                 return ret; //LCOV_EXCL_LINE
2681         }
2682
2683         CONNECTION_LOG(CONNECTION_INFO, "EAP over Ethernet enabled status: [%s]", enabled ? "true" : "false");
2684
2685         CONN_UNLOCK;
2686         return CONNECTION_ERROR_NONE;
2687 }
2688
2689 EXPORT_API int connection_profile_enable_ethernet_eap(connection_profile_h profile, bool enable)
2690 {
2691         CONN_LOCK;
2692
2693         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2694                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2695
2696         if (!_connection_libnet_check_profile_validity(profile)) {
2697                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2698                 CONN_UNLOCK;
2699                 return CONNECTION_ERROR_INVALID_PARAMETER;
2700         }
2701
2702         net_profile_info_t *profile_info = profile;
2703         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2704
2705         if (!net_info) {
2706                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation"); //LCOV_EXCL_LINE
2707                 CONN_UNLOCK; //LCOV_EXCL_LINE
2708                 return CONNECTION_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2709         }
2710
2711         int ret = _connection_libnet_enable_ethernet_eap(enable, net_info->ProfileName);
2712         if (ret != CONNECTION_ERROR_NONE) {
2713                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to enable EAP over ethernet"); //LCOV_EXCL_LINE
2714                 CONN_UNLOCK; //LCOV_EXCL_LINE
2715                 return ret; //LCOV_EXCL_LINE
2716         }
2717
2718         net_info->use_eapol = enable;
2719
2720         CONN_UNLOCK;
2721         return CONNECTION_ERROR_NONE;
2722 }
2723
2724 EXPORT_API int connection_profile_set_ethernet_eap_type(connection_profile_h profile,
2725                         connection_ethernet_eap_type_e type)
2726 {
2727         CONN_LOCK;
2728
2729         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2730                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2731
2732         if (!_connection_libnet_check_profile_validity(profile)) {
2733                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2734                 CONN_UNLOCK;
2735                 return CONNECTION_ERROR_INVALID_PARAMETER;
2736         }
2737
2738         net_profile_info_t *profile_info = profile;
2739         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2740
2741         if (!net_info || net_info->use_eapol == false) {
2742                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation"); //LCOV_EXCL_LINE
2743                 CONN_UNLOCK; //LCOV_EXCL_LINE
2744                 return CONNECTION_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2745         }
2746         net_info->eap.eap_type = type;
2747
2748         CONN_UNLOCK;
2749         return CONNECTION_ERROR_NONE;
2750 }
2751
2752 EXPORT_API int connection_profile_get_ethernet_eap_type(connection_profile_h profile,
2753                         connection_ethernet_eap_type_e *type)
2754 {
2755         CONN_LOCK;
2756
2757         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2758                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2759
2760         if (!_connection_libnet_check_profile_validity(profile) || type == NULL) {
2761                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2762                 CONN_UNLOCK;
2763                 return CONNECTION_ERROR_INVALID_PARAMETER;
2764         }
2765
2766         net_profile_info_t *profile_info = profile;
2767         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2768
2769         if (!net_info || net_info->use_eapol == false) {
2770                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation"); //LCOV_EXCL_LINE
2771                 CONN_UNLOCK; //LCOV_EXCL_LINE
2772                 return CONNECTION_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2773         }
2774
2775         *type = net_info->eap.eap_type;
2776
2777         CONN_UNLOCK;
2778         return CONNECTION_ERROR_NONE;
2779 }
2780
2781 EXPORT_API int connection_profile_set_ethernet_eap_passphrase(connection_profile_h profile,
2782                         const char *user_name, const char *password)
2783 {
2784         CONN_LOCK;
2785
2786         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2787                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2788
2789         if (!_connection_libnet_check_profile_validity(profile) ||
2790                         user_name == NULL || password == NULL) {
2791                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2792                 CONN_UNLOCK;
2793                 return CONNECTION_ERROR_INVALID_PARAMETER;
2794         }
2795
2796         net_profile_info_t *profile_info = profile;
2797         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2798
2799         if (!net_info || false == __profile_ethernet_validate_eap_passphrase(net_info)) {
2800                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation");
2801                 CONN_UNLOCK;
2802                 return CONNECTION_ERROR_INVALID_OPERATION;
2803         }
2804
2805         g_strlcpy(net_info->eap.username, user_name, NET_USERNAME_LEN+1);
2806         g_strlcpy(net_info->eap.password, password, NET_PASSWORD_LEN+1);
2807
2808         CONN_UNLOCK;
2809         return CONNECTION_ERROR_NONE;
2810 }
2811
2812 EXPORT_API int connection_profile_get_ethernet_eap_passphrase(connection_profile_h profile,
2813                         char **user_name, bool *is_password_set)
2814 {
2815         CONN_LOCK;
2816
2817         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2818                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2819
2820         if (!_connection_libnet_check_profile_validity(profile) ||
2821                         user_name == NULL || is_password_set == NULL) {
2822                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2823                 CONN_UNLOCK;
2824                 return CONNECTION_ERROR_INVALID_PARAMETER;
2825         }
2826
2827         net_profile_info_t *profile_info = profile;
2828         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2829
2830         if (!net_info || false == __profile_ethernet_validate_eap_passphrase(net_info)) {
2831                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation");
2832                 CONN_UNLOCK;
2833                 return CONNECTION_ERROR_INVALID_OPERATION;
2834         }
2835
2836         *user_name = strdup(net_info->eap.username);
2837         if (*user_name == NULL)  {
2838                 CONN_UNLOCK; //LCOV_EXCL_LINE
2839                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
2840         }
2841
2842         if (strlen(net_info->eap.password) > 0)
2843                 *is_password_set = true;
2844         else
2845                 *is_password_set = false;
2846
2847         CONN_UNLOCK;
2848         return CONNECTION_ERROR_NONE;
2849 }
2850
2851 EXPORT_API int connection_profile_set_ethernet_eap_identity(connection_profile_h profile,
2852                                 const char *identity)
2853 {
2854         CONN_LOCK;
2855
2856         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2857                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2858
2859         if (!_connection_libnet_check_profile_validity(profile) ||
2860                         identity == NULL ) {
2861                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2862                 CONN_UNLOCK;
2863                 return CONNECTION_ERROR_INVALID_PARAMETER;
2864         }
2865
2866         net_profile_info_t *profile_info = profile;
2867         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2868
2869         if (!net_info || false == __profile_ethernet_validate_eap_identity(net_info)) {
2870                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation"); //LCOV_EXCL_LINE
2871                 CONN_UNLOCK; //LCOV_EXCL_LINE
2872                 return CONNECTION_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2873         }
2874
2875         g_strlcpy(net_info->eap.username, identity, NET_USERNAME_LEN+1);
2876
2877         CONN_UNLOCK;
2878         return CONNECTION_ERROR_NONE;
2879 }
2880
2881 EXPORT_API int connection_profile_get_ethernet_eap_identity(connection_profile_h profile,
2882                                 char **identity)
2883 {
2884         CONN_LOCK;
2885
2886         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2887                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2888
2889         if (!_connection_libnet_check_profile_validity(profile) ||
2890                         identity == NULL ) {
2891                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2892                 CONN_UNLOCK;
2893                 return CONNECTION_ERROR_INVALID_PARAMETER;
2894         }
2895
2896         net_profile_info_t *profile_info = profile;
2897         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2898
2899         if (!net_info || false == __profile_ethernet_validate_eap_identity(net_info)) {
2900                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation"); //LCOV_EXCL_LINE
2901                 CONN_UNLOCK; //LCOV_EXCL_LINE
2902                 return CONNECTION_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2903         }
2904
2905         *identity = strdup(net_info->eap.username);
2906         if (*identity == NULL)  {
2907                 CONN_UNLOCK; //LCOV_EXCL_LINE
2908                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
2909         }
2910
2911         CONN_UNLOCK;
2912         return CONNECTION_ERROR_NONE;
2913 }
2914
2915 EXPORT_API int connection_profile_set_ethernet_eap_ca_cert_file(connection_profile_h profile,
2916                                 const char *file)
2917 {
2918         CONN_LOCK;
2919
2920         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2921                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2922
2923         if (!_connection_libnet_check_profile_validity(profile) ||
2924                         file == NULL ) {
2925                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2926                 CONN_UNLOCK;
2927                 return CONNECTION_ERROR_INVALID_PARAMETER;
2928         }
2929
2930         net_profile_info_t *profile_info = profile;
2931         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2932
2933         if (!net_info || false == __profile_ethernet_validate_eap_ca_cert_file(net_info)) {
2934                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation");
2935                 CONN_UNLOCK;
2936                 return CONNECTION_ERROR_INVALID_OPERATION;
2937         }
2938
2939         g_strlcpy(net_info->eap.ca_cert_filename, file, NET_CA_CERT_FILENAME_LEN+1);
2940
2941         CONN_UNLOCK;
2942         return CONNECTION_ERROR_NONE;
2943 }
2944
2945 EXPORT_API int connection_profile_get_ethernet_eap_ca_cert_file(connection_profile_h profile,
2946                                 char **file)
2947 {
2948         CONN_LOCK;
2949
2950         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2951                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2952
2953         if (!_connection_libnet_check_profile_validity(profile) ||
2954                         file == NULL ) {
2955                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2956                 CONN_UNLOCK;
2957                 return CONNECTION_ERROR_INVALID_PARAMETER;
2958         }
2959
2960         net_profile_info_t *profile_info = profile;
2961         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2962
2963         if (!net_info || false == __profile_ethernet_validate_eap_ca_cert_file(net_info)) {
2964                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation");
2965                 CONN_UNLOCK;
2966                 return CONNECTION_ERROR_INVALID_OPERATION;
2967         }
2968
2969         *file = strdup(net_info->eap.ca_cert_filename);
2970         if (*file == NULL)  {
2971                 CONN_UNLOCK; //LCOV_EXCL_LINE
2972                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
2973         }
2974
2975         CONN_UNLOCK;
2976         return CONNECTION_ERROR_NONE;
2977 }
2978
2979 EXPORT_API int connection_profile_set_ethernet_eap_client_cert_file(connection_profile_h profile,
2980                                 const char *file)
2981 {
2982         CONN_LOCK;
2983
2984         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2985                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2986
2987         if (!_connection_libnet_check_profile_validity(profile) ||
2988                         file == NULL ) {
2989                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2990                 CONN_UNLOCK;
2991                 return CONNECTION_ERROR_INVALID_PARAMETER;
2992         }
2993
2994         net_profile_info_t *profile_info = profile;
2995         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2996
2997         if (!net_info || false == __profile_ethernet_validate_eap_client_cert_file(net_info)) {
2998                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation");
2999                 CONN_UNLOCK;
3000                 return CONNECTION_ERROR_INVALID_OPERATION;
3001         }
3002
3003         g_strlcpy(net_info->eap.client_cert_filename, file, NET_CLIENT_CERT_FILENAME_LEN+1);
3004
3005         CONN_UNLOCK;
3006         return CONNECTION_ERROR_NONE;
3007 }
3008
3009 EXPORT_API int connection_profile_get_ethernet_eap_client_cert_file(connection_profile_h profile,
3010                                 char **file)
3011 {
3012         CONN_LOCK;
3013
3014         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
3015                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
3016
3017         if (!_connection_libnet_check_profile_validity(profile) ||
3018                         file == NULL ) {
3019                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
3020                 CONN_UNLOCK;
3021                 return CONNECTION_ERROR_INVALID_PARAMETER;
3022         }
3023
3024         net_profile_info_t *profile_info = profile;
3025         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
3026
3027         if (!net_info || false == __profile_ethernet_validate_eap_client_cert_file(net_info)) {
3028                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation");
3029                 CONN_UNLOCK;
3030                 return CONNECTION_ERROR_INVALID_OPERATION;
3031         }
3032
3033         *file = strdup(net_info->eap.client_cert_filename);
3034         if (*file == NULL)  {
3035                 CONN_UNLOCK; //LCOV_EXCL_LINE
3036                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
3037         }
3038
3039         CONN_UNLOCK;
3040         return CONNECTION_ERROR_NONE;
3041 }
3042
3043 EXPORT_API int connection_profile_get_ethernet_eap_private_key_file(connection_profile_h profile,
3044                                 char **file)
3045 {
3046         CONN_LOCK;
3047
3048         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
3049                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
3050
3051         if (!_connection_libnet_check_profile_validity(profile) ||
3052                         file == NULL ) {
3053                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
3054                 CONN_UNLOCK;
3055                 return CONNECTION_ERROR_INVALID_PARAMETER;
3056         }
3057
3058         net_profile_info_t *profile_info = profile;
3059         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
3060
3061         if (!net_info || false == __profile_ethernet_validate_eap_private_key_file(net_info)) {
3062                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation");
3063                 CONN_UNLOCK;
3064                 return CONNECTION_ERROR_INVALID_OPERATION;
3065         }
3066
3067         *file = strdup(net_info->eap.private_key_filename);
3068         if (*file == NULL)  {
3069                 CONN_UNLOCK; //LCOV_EXCL_LINE
3070                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
3071         }
3072
3073         CONN_UNLOCK;
3074         return CONNECTION_ERROR_NONE;
3075 }
3076
3077 EXPORT_API int connection_profile_set_ethernet_eap_private_key_info(connection_profile_h profile,
3078                                 const char *file, const char *password)
3079 {
3080         CONN_LOCK;
3081
3082         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
3083                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
3084
3085         if (!_connection_libnet_check_profile_validity(profile) ||
3086                         file == NULL || password == NULL) {
3087                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
3088                 CONN_UNLOCK;
3089                 return CONNECTION_ERROR_INVALID_PARAMETER;
3090         }
3091
3092         net_profile_info_t *profile_info = profile;
3093         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
3094
3095         if (!net_info || false == __profile_ethernet_validate_eap_private_key_file(net_info)) {
3096                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation");
3097                 CONN_UNLOCK;
3098                 return CONNECTION_ERROR_INVALID_OPERATION;
3099         }
3100
3101         g_strlcpy(net_info->eap.private_key_filename, file, NET_PRIVATE_KEY_FILENAME_LEN+1);
3102         g_strlcpy(net_info->eap.private_key_passwd, password, NET_PRIVATE_KEY_PASSWD_LEN+1);
3103
3104         CONN_UNLOCK;
3105         return CONNECTION_ERROR_NONE;
3106 }
3107
3108 EXPORT_API int connection_profile_set_ethernet_eap_anonymous_identity(connection_profile_h profile,
3109                                 const char *anonymous_identity)
3110 {
3111         CONN_LOCK;
3112
3113         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
3114                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
3115
3116         if (!_connection_libnet_check_profile_validity(profile) ||
3117                       anonymous_identity == NULL ) {
3118                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
3119                 CONN_UNLOCK;
3120                 return CONNECTION_ERROR_INVALID_PARAMETER;
3121         }
3122
3123         net_profile_info_t *profile_info = profile;
3124         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
3125
3126         if (!net_info || false == __profile_ethernet_validate_eap_anonymous_identity(net_info)) {
3127                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation");
3128                 CONN_UNLOCK;
3129                 return CONNECTION_ERROR_INVALID_OPERATION;
3130         }
3131
3132         g_strlcpy(net_info->eap.anonymous_identity, anonymous_identity, NET_USERNAME_LEN+1);
3133
3134         CONN_UNLOCK;
3135         return CONNECTION_ERROR_NONE;
3136 }
3137
3138 EXPORT_API int connection_profile_get_ethernet_eap_anonymous_identity(connection_profile_h profile,
3139                                 char **anonymous_identity)
3140 {
3141         CONN_LOCK;
3142
3143         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
3144                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
3145
3146         if (!_connection_libnet_check_profile_validity(profile) ||
3147                         anonymous_identity == NULL ) {
3148                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
3149                 CONN_UNLOCK;
3150                 return CONNECTION_ERROR_INVALID_PARAMETER;
3151         }
3152
3153         net_profile_info_t *profile_info = profile;
3154         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
3155
3156         if (!net_info || false == __profile_ethernet_validate_eap_anonymous_identity(net_info)) {
3157                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation");
3158                 CONN_UNLOCK;
3159                 return CONNECTION_ERROR_INVALID_OPERATION;
3160         }
3161
3162         *anonymous_identity= strdup(net_info->eap.anonymous_identity);
3163         if (*anonymous_identity== NULL)  {
3164                 CONN_UNLOCK; //LCOV_EXCL_LINE
3165                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
3166         }
3167
3168         CONN_UNLOCK;
3169         return CONNECTION_ERROR_NONE;
3170 }
3171
3172 EXPORT_API int connection_profile_set_ethernet_eap_pac_file(connection_profile_h profile,
3173                                 const char *file)
3174 {
3175         CONN_LOCK;
3176
3177         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
3178                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
3179
3180         if (!_connection_libnet_check_profile_validity(profile) ||
3181                         file == NULL ) {
3182                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
3183                 CONN_UNLOCK;
3184                 return CONNECTION_ERROR_INVALID_PARAMETER;
3185         }
3186
3187         net_profile_info_t *profile_info = profile;
3188         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
3189
3190         if (!net_info || false == __profile_ethernet_validate_eap_pac_file(net_info)) {
3191                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation");
3192                 CONN_UNLOCK;
3193                 return CONNECTION_ERROR_INVALID_OPERATION;
3194         }
3195
3196         g_strlcpy(net_info->eap.pac_filename, file, NET_PAC_FILENAME_LEN+1);
3197
3198         CONN_UNLOCK;
3199         return CONNECTION_ERROR_NONE;
3200 }
3201
3202 EXPORT_API int connection_profile_get_ethernet_eap_pac_file(connection_profile_h profile,
3203                                 char **file)
3204 {
3205         CONN_LOCK;
3206
3207         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
3208                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
3209
3210         if (!_connection_libnet_check_profile_validity(profile) ||
3211                         file == NULL ) {
3212                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
3213                 CONN_UNLOCK;
3214                 return CONNECTION_ERROR_INVALID_PARAMETER;
3215         }
3216
3217         net_profile_info_t *profile_info = profile;
3218         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
3219
3220         if (!net_info || false == __profile_ethernet_validate_eap_pac_file(net_info)) {
3221                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation");
3222                 CONN_UNLOCK;
3223                 return CONNECTION_ERROR_INVALID_OPERATION;
3224         }
3225
3226         *file = strdup(net_info->eap.pac_filename);
3227         if (*file == NULL)  {
3228                 CONN_UNLOCK; //LCOV_EXCL_LINE
3229                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
3230         }
3231
3232         CONN_UNLOCK;
3233         return CONNECTION_ERROR_NONE;
3234 }
3235
3236 EXPORT_API int connection_profile_set_ethernet_eap_auth_type(connection_profile_h profile,
3237                         connection_ethernet_eap_auth_type_e type)
3238 {
3239         CONN_LOCK;
3240
3241         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
3242                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
3243
3244         if (!_connection_libnet_check_profile_validity(profile)) {
3245                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
3246                 CONN_UNLOCK;
3247                 return CONNECTION_ERROR_INVALID_PARAMETER;
3248         }
3249
3250         net_profile_info_t *profile_info = profile;
3251         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
3252
3253         if (!net_info || false == __profile_ethernet_validate_eap_auth_type(net_info)) {
3254                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation");
3255                 CONN_UNLOCK;
3256                 return CONNECTION_ERROR_INVALID_OPERATION;
3257         }
3258
3259         net_info->eap.eap_auth = type;
3260
3261         CONN_UNLOCK;
3262         return CONNECTION_ERROR_NONE;
3263 }
3264
3265 EXPORT_API int connection_profile_get_ethernet_eap_auth_type(connection_profile_h profile,
3266                         connection_ethernet_eap_auth_type_e *type)
3267 {
3268         CONN_LOCK;
3269
3270         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
3271                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
3272
3273         if (!_connection_libnet_check_profile_validity(profile) || type == NULL) {
3274                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
3275                 CONN_UNLOCK;
3276                 return CONNECTION_ERROR_INVALID_PARAMETER;
3277         }
3278
3279         net_profile_info_t *profile_info = profile;
3280         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
3281
3282         if (!net_info || false == __profile_ethernet_validate_eap_auth_type(net_info)) {
3283                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation");
3284                 CONN_UNLOCK;
3285                 return CONNECTION_ERROR_INVALID_OPERATION;
3286         }
3287
3288         *type = net_info->eap.eap_auth;
3289
3290         CONN_UNLOCK;
3291         return CONNECTION_ERROR_NONE;
3292 }
3293
3294 EXPORT_API int connection_profile_set_ethernet_eap_peap_version(connection_profile_h profile,
3295                         connection_ethernet_eap_peap_version_e version)
3296 {
3297         CONN_LOCK;
3298
3299         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
3300                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
3301
3302         if (!_connection_libnet_check_profile_validity(profile)) {
3303                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
3304                 CONN_UNLOCK;
3305                 return CONNECTION_ERROR_INVALID_PARAMETER;
3306         }
3307
3308         net_profile_info_t *profile_info = profile;
3309         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
3310
3311         if (!net_info || false == __profile_ethernet_validate_eap_peap_version(net_info)) {
3312                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation");
3313                 CONN_UNLOCK;
3314                 return CONNECTION_ERROR_INVALID_OPERATION;
3315         }
3316         net_info->eap.peap_version= version;
3317
3318         CONN_UNLOCK;
3319         return CONNECTION_ERROR_NONE;
3320 }
3321
3322 EXPORT_API int connection_profile_get_ethernet_eap_peap_version(connection_profile_h profile,
3323                         connection_ethernet_eap_peap_version_e *version)
3324 {
3325         CONN_LOCK;
3326
3327         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
3328                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
3329
3330         if (!_connection_libnet_check_profile_validity(profile) || version == NULL) {
3331                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
3332                 CONN_UNLOCK;
3333                 return CONNECTION_ERROR_INVALID_PARAMETER;
3334         }
3335
3336         net_profile_info_t *profile_info = profile;
3337         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
3338
3339         if (!net_info || false == __profile_ethernet_validate_eap_peap_version(net_info)) {
3340                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid operation");
3341                 CONN_UNLOCK;
3342                 return CONNECTION_ERROR_INVALID_OPERATION;
3343         }
3344
3345         *version = net_info->eap.peap_version;
3346
3347         CONN_UNLOCK;
3348         return CONNECTION_ERROR_NONE;
3349 }