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