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