src/net_wifi_ap.c

   1 /*
   2  * Copyright (c) 2012-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 <string.h>
  20 #include <stdlib.h>
  21 #include <arpa/inet.h>
  22 #include <netinet/in.h>
  23
  24 #include "net_wifi_private.h"
  25
  26 #define MAX_PREFIX_LENGTH 6
  27
  28 static char *__ap_convert_ip_to_string(net_addr_t *ip_addr, wifi_address_family_e address_family)
  29 {
  30         unsigned char *ipaddr = NULL;
  31         char *ipstr = NULL;
  32
  33         if (address_family == WIFI_ADDRESS_FAMILY_IPV4) {
  34                 ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr;
  35                 ipstr = g_try_malloc0(INET_ADDRSTRLEN);
  36                 if (ipstr == NULL)
  37                         return NULL;
  38
  39                 inet_ntop(AF_INET, ipaddr, ipstr, INET_ADDRSTRLEN);
  40         } else {
  41                 //LCOV_EXCL_START
  42                 ipaddr = (unsigned char *)&ip_addr->Data.Ipv6;
  43                 ipstr = g_try_malloc0(INET6_ADDRSTRLEN);
  44                 if (ipstr == NULL)
  45                         return NULL;
  46
  47                 inet_ntop(AF_INET6, ipaddr, ipstr, INET6_ADDRSTRLEN);
  48                 //LCOV_EXCL_STOP
  49         }
  50         return ipstr;
  51 }
  52
  53 static void __wifi_init_ap(net_profile_info_t *profile_info, const char *essid)
  54 {
  55         profile_info->profile_type = NET_DEVICE_WIFI;
  56         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
  57         profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
  58         profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
  59         profile_info->ProfileInfo.Wlan.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
  60         profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
  61         profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
  62         g_strlcpy(profile_info->ProfileInfo.Wlan.essid, essid, NET_WLAN_ESSID_LEN+1);
  63 }
  64
  65 static char *__wifi_create_profile_name(const char *ssid, const int net_mode, const int sec_mode)
  66 {
  67         char *buf = NULL;
  68         char *pbuf = NULL;
  69         const char *hidden_str = "hidden";
  70         char buf_tmp[32] = { 0, };
  71         int i;
  72         int ssid_len = 0;
  73         int actual_len = 0;
  74         const char *mode = "managed";
  75         char *g_sec = NULL;
  76
  77         if (net_mode == NETPM_WLAN_CONNMODE_ADHOC) {
  78                 WIFI_LOG(WIFI_ERROR, "wlan_mode is adhoc"); //LCOV_EXCL_LINE
  79                 return NULL; //LCOV_EXCL_LINE
  80         }
  81
  82         switch (sec_mode) {
  83         //LCOV_EXCL_START
  84         case WLAN_SEC_MODE_NONE:
  85                 g_sec = "none";
  86                 break;
  87         case WLAN_SEC_MODE_WEP:
  88                 g_sec = "wep";
  89                 break;
  90         case WLAN_SEC_MODE_WPA_PSK:
  91         case WLAN_SEC_MODE_WPA2_PSK:
  92                 g_sec = "psk";
  93                 break;
  94         case WLAN_SEC_MODE_IEEE8021X:
  95                 g_sec = "ieee8021x";
  96                 break;
  97         default:
  98                 WIFI_LOG(WIFI_ERROR, "Invalid security type");
  99                 return NULL;
 100         //LCOV_EXCL_STOP
 101         }
 102
 103         if (NULL != ssid) {
 104                 ssid_len = strlen(ssid);
 105                 actual_len = ssid_len * 2;
 106         } else {
 107                 ssid_len = strlen(hidden_str);
 108                 actual_len = ssid_len;
 109         }
 110
 111         buf = g_try_malloc0(actual_len + strlen(mode) + strlen(g_sec) + 3);
 112         if (buf == NULL)
 113                 return NULL;
 114
 115         if (NULL != ssid) {
 116                 pbuf = buf;
 117
 118                 for (i = 0; i < ssid_len; i++) {
 119                         g_snprintf(pbuf, 3, "%02x", ssid[i]);
 120                         pbuf += 2;
 121                 }
 122         } else
 123                 g_strlcat(buf, hidden_str,
 124                                 actual_len + strlen(mode) + strlen(g_sec) + 3);
 125
 126         g_snprintf(buf_tmp, 32, "_%s_%s", mode, g_sec);
 127         g_strlcat(buf, buf_tmp,
 128                         actual_len + strlen(mode) + strlen(g_sec) + 3);
 129
 130         WIFI_LOG(WIFI_INFO, "Profile name: %s", buf);
 131
 132         return buf;
 133 }
 134
 135 static bool _wifi_set_profile_name_to_ap(net_profile_info_t *ap_info)
 136 {
 137         char *profile_name = NULL;
 138
 139         if (ap_info == NULL) {
 140                 WIFI_LOG(WIFI_ERROR, "profile_info is NULL"); //LCOV_EXCL_LINE
 141                 return false; //LCOV_EXCL_LINE
 142         }
 143
 144         profile_name = __wifi_create_profile_name(
 145                         ap_info->ProfileInfo.Wlan.is_hidden == TRUE ?
 146                                         NULL : ap_info->ProfileInfo.Wlan.essid,
 147                         ap_info->ProfileInfo.Wlan.wlan_mode,
 148                         ap_info->ProfileInfo.Wlan.security_info.sec_mode);
 149         if (profile_name == NULL) {
 150                 WIFI_LOG(WIFI_ERROR, "Failed to make a group name"); //LCOV_EXCL_LINE
 151                 return false; //LCOV_EXCL_LINE
 152         }
 153
 154         g_strlcpy(ap_info->ProfileInfo.Wlan.net_info.ProfileName,
 155                         profile_name, NET_PROFILE_NAME_LEN_MAX);
 156
 157         g_free(profile_name);
 158
 159         return true;
 160 }
 161
 162 wifi_connection_state_e _wifi_convert_to_ap_state(net_state_type_t state)
 163 {
 164         wifi_connection_state_e ap_state;
 165
 166         switch (state) {
 167         case NET_STATE_TYPE_ONLINE:
 168         case NET_STATE_TYPE_READY:
 169                 ap_state = WIFI_CONNECTION_STATE_CONNECTED;
 170                 break;
 171         case NET_STATE_TYPE_FAILURE:
 172                 ap_state = WIFI_CONNECTION_STATE_FAILURE;
 173                 break;
 174         case NET_STATE_TYPE_IDLE:
 175         case NET_STATE_TYPE_DISCONNECT:
 176                 ap_state = WIFI_CONNECTION_STATE_DISCONNECTED;
 177                 break;
 178         case NET_STATE_TYPE_ASSOCIATION:
 179                 ap_state = WIFI_CONNECTION_STATE_ASSOCIATION;
 180                 break;
 181         case NET_STATE_TYPE_CONFIGURATION:
 182                 ap_state = WIFI_CONNECTION_STATE_CONFIGURATION;
 183                 break;
 184         default:
 185                 ap_state = -1;
 186                 break;
 187         }
 188
 189         return ap_state;
 190 }
 191
 192 /* Wi-Fi AP ******************************************************************/
 193 EXPORT_API int wifi_ap_create(const char* essid, wifi_ap_h* ap)
 194 {
 195         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_create");
 196         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 197
 198         if (essid == NULL || ap == NULL) {
 199                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 200                 return WIFI_ERROR_INVALID_PARAMETER;
 201         }
 202
 203         net_profile_info_t *ap_info = g_try_malloc0(sizeof(net_profile_info_t));
 204         if (ap_info == NULL)
 205                 return WIFI_ERROR_OUT_OF_MEMORY;
 206
 207         __wifi_init_ap(ap_info, essid);
 208
 209         _wifi_libnet_add_to_ap_list((wifi_ap_h)ap_info);
 210         *ap = (wifi_ap_h)ap_info;
 211
 212         return WIFI_ERROR_NONE;
 213 }
 214
 215 EXPORT_API int wifi_ap_hidden_create(const char* essid, wifi_ap_h* ap)
 216 {
 217         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_hidden_create");
 218         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 219
 220         if (essid == NULL || ap == NULL) {
 221                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 222                 return WIFI_ERROR_INVALID_PARAMETER;
 223         }
 224
 225         net_profile_info_t *ap_info = g_try_malloc0(sizeof(net_profile_info_t));
 226         if (ap_info == NULL)
 227                 return WIFI_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 228
 229         __wifi_init_ap(ap_info, essid);
 230         ap_info->ProfileInfo.Wlan.is_hidden = TRUE;
 231
 232         _wifi_libnet_add_to_ap_list((wifi_ap_h)ap_info);
 233         *ap = (wifi_ap_h)ap_info;
 234
 235         return WIFI_ERROR_NONE;
 236 }
 237
 238 EXPORT_API int wifi_ap_destroy(wifi_ap_h ap)
 239 {
 240         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_destroy");
 241         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 242
 243         if (_wifi_libnet_check_ap_validity(ap) == false) {
 244                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 245                 return WIFI_ERROR_INVALID_PARAMETER;
 246         }
 247
 248         _wifi_libnet_remove_from_ap_list(ap);
 249
 250         return WIFI_ERROR_NONE;
 251 }
 252
 253 EXPORT_API int wifi_ap_clone(wifi_ap_h* cloned_ap, wifi_ap_h origin)
 254 {
 255         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_clone");
 256         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 257
 258         if (_wifi_libnet_check_ap_validity(origin) == false || cloned_ap == NULL) {
 259                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 260                 return WIFI_ERROR_INVALID_PARAMETER;
 261         }
 262
 263         net_profile_info_t *ap_info = g_try_malloc0(sizeof(net_profile_info_t));
 264         if (ap_info == NULL)
 265                 return WIFI_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 266
 267         memcpy(ap_info, origin, sizeof(net_profile_info_t));
 268
 269         _wifi_libnet_add_to_ap_list((wifi_ap_h)ap_info);
 270         *cloned_ap = (wifi_ap_h)ap_info;
 271
 272         return WIFI_ERROR_NONE;
 273 }
 274
 275 EXPORT_API int wifi_ap_refresh(wifi_ap_h ap)
 276 {
 277         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_refresh");
 278         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 279
 280         net_profile_info_t ap_info_local;
 281         net_profile_info_t *ap_info = ap;
 282
 283         if (_wifi_libnet_check_ap_validity(ap) == false) {
 284                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 285                 return WIFI_ERROR_INVALID_PARAMETER;
 286         }
 287
 288         int rv = NET_ERR_NONE;
 289         rv = net_get_profile_info(ap_info->ProfileName, &ap_info_local);
 290         if (rv == NET_ERR_ACCESS_DENIED) {
 291                 WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE
 292                 return WIFI_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 293         } else if (rv != NET_ERR_NONE) {
 294                 WIFI_LOG(WIFI_ERROR, "Failed to getprofile_info"); //LCOV_EXCL_LINE
 295                 return WIFI_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 296         }
 297
 298         memcpy(ap, &ap_info_local, sizeof(net_profile_info_t));
 299
 300         return WIFI_ERROR_NONE;
 301 }
 302
 303 /* Wi-Fi network information *************************************************/
 304 EXPORT_API int wifi_ap_get_essid(wifi_ap_h ap, char** essid)
 305 {
 306         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_essid");
 307         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 308
 309         if (_wifi_libnet_check_ap_validity(ap) == false || essid == NULL) {
 310                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 311                 return WIFI_ERROR_INVALID_PARAMETER;
 312         }
 313
 314         net_profile_info_t *profile_info = ap;
 315         *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
 316         if (*essid == NULL)
 317                 return WIFI_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 318
 319         return WIFI_ERROR_NONE;
 320 }
 321
 322 EXPORT_API int wifi_ap_get_bssid(wifi_ap_h ap, char** bssid)
 323 {
 324         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_bssid");
 325         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 326
 327         if (_wifi_libnet_check_ap_validity(ap) == false || bssid == NULL) {
 328                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 329                 return WIFI_ERROR_INVALID_PARAMETER;
 330         }
 331
 332         net_profile_info_t *profile_info = ap;
 333         *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
 334         if (*bssid == NULL)
 335                 return WIFI_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 336
 337         return WIFI_ERROR_NONE;
 338 }
 339
 340 EXPORT_API int wifi_ap_get_rssi(wifi_ap_h ap, int* rssi)
 341 {
 342         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_rssi");
 343         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 344
 345         if (_wifi_libnet_check_ap_validity(ap) == false || rssi == NULL) {
 346                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 347                 return WIFI_ERROR_INVALID_PARAMETER;
 348         }
 349
 350         net_profile_info_t *profile_info = ap;
 351         *rssi = (int)(profile_info->ProfileInfo.Wlan.Strength - 120);
 352
 353         return WIFI_ERROR_NONE;
 354 }
 355
 356 EXPORT_API int wifi_ap_get_frequency(wifi_ap_h ap, int* frequency)
 357 {
 358         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_frequency");
 359         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 360
 361         if (_wifi_libnet_check_ap_validity(ap) == false || frequency == NULL) {
 362                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 363                 return WIFI_ERROR_INVALID_PARAMETER;
 364         }
 365
 366         net_profile_info_t *profile_info = ap;
 367         *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
 368
 369         return WIFI_ERROR_NONE;
 370 }
 371
 372 EXPORT_API int wifi_ap_get_max_speed(wifi_ap_h ap, int* max_speed)
 373 {
 374         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_max_speed");
 375         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 376
 377         if (_wifi_libnet_check_ap_validity(ap) == false || max_speed == NULL) {
 378                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 379                 return WIFI_ERROR_INVALID_PARAMETER;
 380         }
 381
 382         net_profile_info_t *profile_info = ap;
 383         *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate / 1000000;
 384
 385         return WIFI_ERROR_NONE;
 386 }
 387
 388 EXPORT_API int wifi_ap_is_favorite(wifi_ap_h ap, bool* favorite)
 389 {
 390         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_is_favorite");
 391         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 392
 393         if (_wifi_libnet_check_ap_validity(ap) == false || favorite == NULL) {
 394                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 395                 return WIFI_ERROR_INVALID_PARAMETER;
 396         }
 397
 398         net_profile_info_t *profile_info = ap;
 399
 400         if (profile_info->Favourite)
 401                 *favorite = true;
 402         else
 403                 *favorite = false;
 404
 405         return WIFI_ERROR_NONE;
 406 }
 407
 408 EXPORT_API int wifi_ap_is_passpoint(wifi_ap_h ap, bool* passpoint)
 409 {
 410         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_is_passpoint");
 411         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 412
 413         if (_wifi_libnet_check_ap_validity(ap) == false || passpoint == NULL) {
 414                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 415                 return WIFI_ERROR_INVALID_PARAMETER;
 416         }
 417
 418         net_profile_info_t *profile_info = ap;
 419
 420         if (profile_info->ProfileInfo.Wlan.passpoint)
 421                 *passpoint = true;
 422         else
 423                 *passpoint = false;
 424
 425         return WIFI_ERROR_NONE;
 426 }
 427
 428 EXPORT_API int wifi_ap_get_connection_state(wifi_ap_h ap, wifi_connection_state_e* state)
 429 {
 430         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_connection_state");
 431         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 432
 433         if (_wifi_libnet_check_ap_validity(ap) == false || state == NULL) {
 434                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 435                 return WIFI_ERROR_INVALID_PARAMETER;
 436         }
 437
 438         net_profile_info_t *profile_info = ap;
 439
 440         *state = _wifi_convert_to_ap_state(profile_info->ProfileState);
 441
 442         if (*state < 0)
 443                 return WIFI_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 444
 445         return WIFI_ERROR_NONE;
 446 }
 447
 448 EXPORT_API int wifi_ap_get_ip_config_type(wifi_ap_h ap, wifi_address_family_e address_family, wifi_ip_config_type_e* type)
 449 {
 450         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_ip_config_type");
 451         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 452         net_ip_config_type_t profileType ;
 453
 454         if (_wifi_libnet_check_ap_validity(ap) == false ||
 455             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 456              address_family != WIFI_ADDRESS_FAMILY_IPV6) ||
 457             type == NULL) {
 458                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 459                 return WIFI_ERROR_INVALID_PARAMETER;
 460         }
 461
 462         net_profile_info_t *profile_info = ap;
 463
 464         if (address_family == WIFI_ADDRESS_FAMILY_IPV4)
 465                 profileType = profile_info->ProfileInfo.Wlan.net_info.IpConfigType ;
 466         else
 467                 profileType = profile_info->ProfileInfo.Wlan.net_info.IpConfigType6 ; //LCOV_EXCL_LINE
 468
 469         if (address_family == WIFI_ADDRESS_FAMILY_IPV4) {
 470                 switch (profileType) {
 471                 //LCOV_EXCL_START
 472                 case NET_IP_CONFIG_TYPE_STATIC:
 473                         *type = WIFI_IP_CONFIG_TYPE_STATIC;
 474                         break;
 475
 476                 case NET_IP_CONFIG_TYPE_DYNAMIC:
 477                         *type = WIFI_IP_CONFIG_TYPE_DYNAMIC;
 478                         break;
 479
 480                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 481                         *type = WIFI_IP_CONFIG_TYPE_AUTO;
 482                         break;
 483
 484                 case NET_IP_CONFIG_TYPE_FIXED:
 485                         *type = WIFI_IP_CONFIG_TYPE_FIXED;
 486                         break;
 487
 488                 case NET_IP_CONFIG_TYPE_OFF:
 489                         *type = WIFI_IP_CONFIG_TYPE_NONE;
 490                         break;
 491
 492                 default:
 493                         return WIFI_ERROR_OPERATION_FAILED;
 494                 //LCOV_EXCL_STOP
 495                 }
 496         } else {
 497                 //LCOV_EXCL_START
 498                 switch (profileType) {
 499                 case NET_IP_CONFIG_TYPE_STATIC:
 500                         *type = WIFI_IP_CONFIG_TYPE_STATIC;
 501                         break;
 502                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 503                         *type = WIFI_IP_CONFIG_TYPE_AUTO;
 504                         break;
 505                 case NET_IP_CONFIG_TYPE_OFF:
 506                         *type = WIFI_IP_CONFIG_TYPE_NONE;
 507                         break;
 508                 default:
 509                         return WIFI_ERROR_OPERATION_FAILED;
 510                 }
 511                 //LCOV_EXCL_STOP
 512         }
 513
 514         return WIFI_ERROR_NONE;
 515 }
 516
 517 EXPORT_API int wifi_ap_set_ip_config_type(wifi_ap_h ap, wifi_address_family_e address_family, wifi_ip_config_type_e type)
 518 {
 519         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_set_ip_config_type");
 520         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 521         net_ip_config_type_t *profileType = NULL;
 522
 523         if (_wifi_libnet_check_ap_validity(ap) == false ||
 524             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 525              address_family != WIFI_ADDRESS_FAMILY_IPV6)) {
 526                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 527                 return WIFI_ERROR_INVALID_PARAMETER;
 528         }
 529
 530         int rv = _wifi_libnet_check_get_privilege();
 531         if (rv == WIFI_ERROR_PERMISSION_DENIED) {
 532                 WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE
 533                 return rv;
 534         }
 535
 536         rv = _wifi_libnet_check_profile_privilege();
 537         if (rv == WIFI_ERROR_PERMISSION_DENIED) {
 538                 WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE
 539                 return rv;
 540         }
 541
 542         net_profile_info_t *profile_info = ap;
 543
 544         if (address_family == WIFI_ADDRESS_FAMILY_IPV4)
 545                 profileType = &profile_info->ProfileInfo.Wlan.net_info.IpConfigType ;
 546         else
 547                 profileType = &profile_info->ProfileInfo.Wlan.net_info.IpConfigType6 ;
 548
 549         if (address_family == WIFI_ADDRESS_FAMILY_IPV4) {
 550                 switch (type) {
 551                 //LCOV_EXCL_START
 552                 case WIFI_IP_CONFIG_TYPE_STATIC:
 553                         *profileType = NET_IP_CONFIG_TYPE_STATIC;
 554                         profile_info->ProfileInfo.Wlan.net_info.IpAddr.Data.Ipv4.s_addr = 0;
 555                         profile_info->ProfileInfo.Wlan.net_info.SubnetMask.Data.Ipv4.s_addr = 0;
 556                         profile_info->ProfileInfo.Wlan.net_info.GatewayAddr.Data.Ipv4.s_addr = 0 ;
 557                         break;
 558
 559                 case WIFI_IP_CONFIG_TYPE_DYNAMIC:
 560                         *profileType = NET_IP_CONFIG_TYPE_DYNAMIC;
 561                         break;
 562
 563                 case WIFI_IP_CONFIG_TYPE_AUTO:
 564                         *profileType = NET_IP_CONFIG_TYPE_AUTO_IP;
 565                         break;
 566
 567                 case WIFI_IP_CONFIG_TYPE_FIXED:
 568                         *profileType = NET_IP_CONFIG_TYPE_FIXED;
 569                         break;
 570
 571                 case WIFI_IP_CONFIG_TYPE_NONE:
 572                         *profileType = NET_IP_CONFIG_TYPE_OFF;
 573                         break;
 574
 575                 default:
 576                         return WIFI_ERROR_INVALID_PARAMETER;
 577                 //LCOV_EXCL_STOP
 578                 }
 579         } else {
 580         //LCOV_EXCL_START
 581                 switch (type) {
 582                 case WIFI_IP_CONFIG_TYPE_STATIC:
 583                         *profileType = NET_IP_CONFIG_TYPE_STATIC;
 584                         inet_pton(AF_INET6, "::", &profile_info->ProfileInfo.Wlan.net_info.IpAddr6.Data.Ipv6);
 585                         profile_info->ProfileInfo.Wlan.net_info.PrefixLen6 = 0 ;
 586                         inet_pton(AF_INET6, "::", &profile_info->ProfileInfo.Wlan.net_info.GatewayAddr6.Data.Ipv6);
 587                         break;
 588                 case WIFI_IP_CONFIG_TYPE_AUTO:
 589                         *profileType = NET_IP_CONFIG_TYPE_AUTO_IP;
 590                         break;
 591                 case WIFI_IP_CONFIG_TYPE_NONE:
 592                         *profileType = NET_IP_CONFIG_TYPE_OFF;
 593                         break;
 594                 default:
 595                         return WIFI_ERROR_INVALID_PARAMETER;
 596                 }
 597         //LCOV_EXCL_STOP
 598         }
 599
 600         if (_wifi_libnet_check_profile_name_validity(profile_info->ProfileName) == false)
 601                 return WIFI_ERROR_NONE;
 602
 603         return _wifi_update_ap_info(profile_info);
 604 }
 605
 606 EXPORT_API int wifi_ap_get_ip_address(wifi_ap_h ap, wifi_address_family_e address_family, char** ip_address)
 607 {
 608         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_ip_address");
 609         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 610
 611         if (_wifi_libnet_check_ap_validity(ap) == false ||
 612             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 613              address_family != WIFI_ADDRESS_FAMILY_IPV6) ||
 614             ip_address == NULL) {
 615                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 616                 return WIFI_ERROR_INVALID_PARAMETER;
 617         }
 618
 619         net_profile_info_t *profile_info = ap;
 620         if (address_family == WIFI_ADDRESS_FAMILY_IPV4)
 621                 *ip_address = __ap_convert_ip_to_string(
 622                                 &profile_info->ProfileInfo.Wlan.net_info.IpAddr,
 623                                 address_family);
 624         else
 625                 *ip_address = __ap_convert_ip_to_string(
 626                                 &profile_info->ProfileInfo.Wlan.net_info.IpAddr6,
 627                                 address_family);
 628
 629         if (*ip_address == NULL)
 630                 return WIFI_ERROR_OUT_OF_MEMORY;
 631
 632         return WIFI_ERROR_NONE;
 633 }
 634
 635 EXPORT_API int wifi_ap_set_ip_address(wifi_ap_h ap, wifi_address_family_e address_family, const char* ip_address)
 636 {
 637         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_set_ip_address");
 638         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 639
 640         if (_wifi_libnet_check_ap_validity(ap) == false ||
 641             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 642              address_family != WIFI_ADDRESS_FAMILY_IPV6)) {
 643                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 644                 return WIFI_ERROR_INVALID_PARAMETER;
 645         }
 646
 647         int rv = _wifi_libnet_check_get_privilege();
 648         if (rv == WIFI_ERROR_PERMISSION_DENIED) {
 649                 WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE
 650                 return rv;
 651         }
 652
 653         rv = _wifi_libnet_check_profile_privilege();
 654         if (rv == WIFI_ERROR_PERMISSION_DENIED) {
 655                 WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE
 656                 return rv;
 657         }
 658
 659         net_profile_info_t *profile_info = ap;
 660
 661         if (address_family == WIFI_ADDRESS_FAMILY_IPV4) {
 662                 if (ip_address == NULL)
 663                         profile_info->ProfileInfo.Wlan.net_info.IpAddr.Data.Ipv4.s_addr = 0;
 664                 else if (inet_aton(ip_address,
 665                                 &(profile_info->ProfileInfo.Wlan.net_info.IpAddr.Data.Ipv4)) == 0)
 666                         return WIFI_ERROR_INVALID_PARAMETER;
 667         } else {
 668         //LCOV_EXCL_START
 669                 if (ip_address == NULL)
 670                         inet_pton(AF_INET6, "::",
 671                                 &profile_info->ProfileInfo.Wlan.net_info.IpAddr6.Data.Ipv6);
 672                 else if (inet_pton(AF_INET6, ip_address,
 673                                 &profile_info->ProfileInfo.Wlan.net_info.IpAddr6.Data.Ipv6) == 0)
 674                         return WIFI_ERROR_INVALID_PARAMETER;
 675         //LCOV_EXCL_STOP
 676         }
 677
 678         if (_wifi_libnet_check_profile_name_validity(profile_info->ProfileName) == false)
 679                 return WIFI_ERROR_NONE;
 680
 681         return _wifi_update_ap_info(profile_info);
 682 }
 683
 684 EXPORT_API int wifi_ap_get_subnet_mask(wifi_ap_h ap, wifi_address_family_e address_family, char** subnet_mask)
 685 {
 686         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_subnet_mask");
 687         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 688         char* prefixlen;
 689
 690         if (_wifi_libnet_check_ap_validity(ap) == false ||
 691             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 692              address_family != WIFI_ADDRESS_FAMILY_IPV6) ||
 693             subnet_mask == NULL) {
 694                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 695                 return WIFI_ERROR_INVALID_PARAMETER;
 696         }
 697
 698         net_profile_info_t *profile_info = ap;
 699         if (address_family == WIFI_ADDRESS_FAMILY_IPV4)
 700                 *subnet_mask = __ap_convert_ip_to_string(
 701                         &profile_info->ProfileInfo.Wlan.net_info.SubnetMask,
 702                         address_family);
 703         else {
 704                 //LCOV_EXCL_START
 705                 prefixlen = g_try_malloc0(MAX_PREFIX_LENGTH);
 706                 if (prefixlen != NULL) {
 707                         snprintf(prefixlen, MAX_PREFIX_LENGTH, "%d",
 708                                 profile_info->ProfileInfo.Wlan.net_info.PrefixLen6);
 709                         *subnet_mask = prefixlen;
 710                 } else
 711                         *subnet_mask = NULL;
 712                 //LCOV_EXCL_STOP
 713         }
 714
 715         if (*subnet_mask == NULL)
 716                 return WIFI_ERROR_OUT_OF_MEMORY;
 717
 718         return WIFI_ERROR_NONE;
 719 }
 720
 721 EXPORT_API int wifi_ap_set_subnet_mask(wifi_ap_h ap, wifi_address_family_e address_family, const char* subnet_mask)
 722 {
 723         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_set_subnet_mask");
 724         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 725
 726         if (_wifi_libnet_check_ap_validity(ap) == false ||
 727             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 728              address_family != WIFI_ADDRESS_FAMILY_IPV6)) {
 729                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 730                 return WIFI_ERROR_INVALID_PARAMETER;
 731         }
 732
 733         int rv = _wifi_libnet_check_get_privilege();
 734         if (rv == WIFI_ERROR_PERMISSION_DENIED) {
 735                 WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE
 736                 return rv;
 737         }
 738
 739         rv = _wifi_libnet_check_profile_privilege();
 740         if (rv == WIFI_ERROR_PERMISSION_DENIED) {
 741                 WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE
 742                 return rv;
 743         }
 744
 745         net_profile_info_t *profile_info = ap;
 746
 747         /* Based on the family of address provided subnet mask should be set.
 748          * For IPv6 address subnet mask is prefix length, an integer,  while for
 749          * Ipv6 address subnet mask is a ipv6 address.
 750          */
 751         if (address_family == WIFI_ADDRESS_FAMILY_IPV6) {
 752                 //LCOV_EXCL_START
 753                 if (subnet_mask == NULL)
 754                         profile_info->ProfileInfo.Wlan.net_info.PrefixLen6 = 0;
 755                 else {
 756                         /* subnet mask provided as input parameter is a string
 757                          * while for IPv6 address subnet mask in prefix length
 758                          * which should be in integer form */
 759                         profile_info->ProfileInfo.Wlan.net_info.PrefixLen6 =
 760                                 atoi(subnet_mask) ;
 761                 }
 762                 //LCOV_EXCL_STOP
 763         } else {
 764                 if (subnet_mask == NULL)
 765                         profile_info->ProfileInfo.Wlan.net_info.SubnetMask.Data.Ipv4.s_addr = 0;
 766                 else if (inet_pton(AF_INET, subnet_mask,
 767                                 &(profile_info->ProfileInfo.Wlan.net_info.SubnetMask.Data.Ipv4)) < 1)
 768                         return WIFI_ERROR_INVALID_PARAMETER;
 769         }
 770
 771
 772         if (_wifi_libnet_check_profile_name_validity(profile_info->ProfileName) == false)
 773                 return WIFI_ERROR_NONE;
 774
 775         return _wifi_update_ap_info(profile_info);
 776 }
 777
 778 EXPORT_API int wifi_ap_get_gateway_address(wifi_ap_h ap, wifi_address_family_e address_family, char** gateway_address)
 779 {
 780         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_gateway_address");
 781         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 782
 783         if (_wifi_libnet_check_ap_validity(ap) == false ||
 784             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 785              address_family != WIFI_ADDRESS_FAMILY_IPV6) ||
 786             gateway_address == NULL) {
 787                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 788                 return WIFI_ERROR_INVALID_PARAMETER;
 789         }
 790
 791         net_profile_info_t *profile_info = ap;
 792
 793         /* Based on the family of address provided, gateway should be set.
 794          * For IPv6 address gateway is of form GatewayAddr6 but for IPv4
 795          * gateway is of form GatewayAddr.
 796          */
 797         if (address_family == WIFI_ADDRESS_FAMILY_IPV4)
 798                 *gateway_address = __ap_convert_ip_to_string(
 799                         &profile_info->ProfileInfo.Wlan.net_info.GatewayAddr,
 800                         address_family);
 801         else
 802                 *gateway_address = __ap_convert_ip_to_string( //LCOV_EXCL_LINE
 803                         &profile_info->ProfileInfo.Wlan.net_info.GatewayAddr6,
 804                         address_family);
 805
 806         if (*gateway_address == NULL)
 807                 return WIFI_ERROR_OUT_OF_MEMORY;
 808
 809         return WIFI_ERROR_NONE;
 810 }
 811
 812 EXPORT_API int wifi_ap_set_gateway_address(wifi_ap_h ap, wifi_address_family_e address_family, const char* gateway_address)
 813 {
 814         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_set_gateway_address");
 815         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 816
 817         if (_wifi_libnet_check_ap_validity(ap) == false ||
 818             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 819              address_family != WIFI_ADDRESS_FAMILY_IPV6)) {
 820                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 821                 return WIFI_ERROR_INVALID_PARAMETER;
 822         }
 823
 824         int rv = _wifi_libnet_check_get_privilege();
 825         if (rv == WIFI_ERROR_PERMISSION_DENIED) {
 826                 WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE
 827                 return rv;
 828         }
 829
 830         rv = _wifi_libnet_check_profile_privilege();
 831         if (rv == WIFI_ERROR_PERMISSION_DENIED) {
 832                 WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE
 833                 return rv;
 834         }
 835
 836         net_profile_info_t *profile_info = ap;
 837         if (address_family == WIFI_ADDRESS_FAMILY_IPV6) {
 838                 //LCOV_EXCL_START
 839                 if (gateway_address == NULL)
 840                         inet_pton(AF_INET6, "::",
 841                                 &profile_info->ProfileInfo.Wlan.net_info.GatewayAddr6.Data.Ipv6);
 842                 else if (inet_pton(AF_INET6, gateway_address,
 843                                 &profile_info->ProfileInfo.Wlan.net_info.GatewayAddr6.Data.Ipv6) < 1)
 844                         return WIFI_ERROR_INVALID_PARAMETER;
 845                 //LCOV_EXCL_STOP
 846         } else {
 847                 if (gateway_address == NULL)
 848                         profile_info->ProfileInfo.Wlan.net_info.GatewayAddr.Data.Ipv4.s_addr = 0;
 849                 else if (inet_pton(AF_INET, gateway_address,
 850                                 &profile_info->ProfileInfo.Wlan.net_info.GatewayAddr.Data.Ipv4) < 1)
 851                         return WIFI_ERROR_INVALID_PARAMETER;
 852         }
 853
 854         if (_wifi_libnet_check_profile_name_validity(profile_info->ProfileName) == false)
 855                 return WIFI_ERROR_NONE;
 856
 857         return _wifi_update_ap_info(profile_info);
 858 }
 859
 860 EXPORT_API int wifi_ap_get_proxy_address(wifi_ap_h ap, wifi_address_family_e address_family, char** proxy_address)
 861 {
 862         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_proxy_address");
 863         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 864
 865         if (_wifi_libnet_check_ap_validity(ap) == false ||
 866             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 867              address_family != WIFI_ADDRESS_FAMILY_IPV6) ||
 868             proxy_address == NULL) {
 869                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 870                 return WIFI_ERROR_INVALID_PARAMETER;
 871         }
 872
 873         net_profile_info_t *profile_info = ap;
 874         *proxy_address = g_strdup(profile_info->ProfileInfo.Wlan.net_info.ProxyAddr);
 875         if (*proxy_address == NULL)
 876                 return WIFI_ERROR_OUT_OF_MEMORY;
 877
 878         return WIFI_ERROR_NONE;
 879 }
 880
 881 EXPORT_API int wifi_ap_set_proxy_address(wifi_ap_h ap, wifi_address_family_e address_family, const char* proxy_address)
 882 {
 883         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_set_proxy_address");
 884         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 885
 886         if (_wifi_libnet_check_ap_validity(ap) == false ||
 887             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
 888              address_family != WIFI_ADDRESS_FAMILY_IPV6)) {
 889                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 890                 return WIFI_ERROR_INVALID_PARAMETER;
 891         }
 892
 893         int rv = _wifi_libnet_check_get_privilege();
 894         if (rv == WIFI_ERROR_PERMISSION_DENIED) {
 895                 WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE
 896                 return rv;
 897         }
 898
 899         rv = _wifi_libnet_check_profile_privilege();
 900         if (rv == WIFI_ERROR_PERMISSION_DENIED) {
 901                 WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE
 902                 return rv;
 903         }
 904
 905         net_profile_info_t *profile_info = ap;
 906
 907         if (proxy_address == NULL)
 908                 profile_info->ProfileInfo.Wlan.net_info.ProxyAddr[0] = '\0';
 909         else
 910                 g_strlcpy(profile_info->ProfileInfo.Wlan.net_info.ProxyAddr,
 911                                 proxy_address, NET_PROXY_LEN_MAX+1);
 912
 913         if (_wifi_libnet_check_profile_name_validity(profile_info->ProfileName) == false)
 914                 return WIFI_ERROR_NONE;
 915
 916         return _wifi_update_ap_info(profile_info);
 917 }
 918
 919 EXPORT_API int wifi_ap_get_proxy_type(wifi_ap_h ap, wifi_proxy_type_e* type)
 920 {
 921         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_proxy_type");
 922         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 923
 924         if (_wifi_libnet_check_ap_validity(ap) == false || type == NULL) {
 925                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 926                 return WIFI_ERROR_INVALID_PARAMETER;
 927         }
 928
 929         net_profile_info_t *profile_info = ap;
 930
 931         switch (profile_info->ProfileInfo.Wlan.net_info.ProxyMethod) {
 932         //LCOV_EXCL_START
 933         case NET_PROXY_TYPE_DIRECT:
 934                 *type = WIFI_PROXY_TYPE_DIRECT;
 935                 break;
 936         case NET_PROXY_TYPE_AUTO:
 937                 *type = WIFI_PROXY_TYPE_AUTO;
 938                 break;
 939         case NET_PROXY_TYPE_MANUAL:
 940                 *type = WIFI_PROXY_TYPE_MANUAL;
 941                 break;
 942         case NET_PROXY_TYPE_UNKNOWN:
 943                 *type = WIFI_PROXY_TYPE_DIRECT;
 944                 break;
 945         default:
 946                 return WIFI_ERROR_OPERATION_FAILED;
 947         //LCOV_EXCL_STOP
 948         }
 949
 950         return WIFI_ERROR_NONE;
 951 }
 952
 953 EXPORT_API int wifi_ap_set_proxy_type(wifi_ap_h ap, wifi_proxy_type_e proxy_type)
 954 {
 955         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_set_proxy_type");
 956         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 957
 958         if (_wifi_libnet_check_ap_validity(ap) == false) {
 959                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
 960                 return WIFI_ERROR_INVALID_PARAMETER;
 961         }
 962
 963         int rv = _wifi_libnet_check_get_privilege();
 964         if (rv == WIFI_ERROR_PERMISSION_DENIED) {
 965                 WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE
 966                 return rv;
 967         }
 968
 969         rv = _wifi_libnet_check_profile_privilege();
 970         if (rv == WIFI_ERROR_PERMISSION_DENIED) {
 971                 WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE
 972                 return rv;
 973         }
 974
 975         net_profile_info_t *profile_info = ap;
 976
 977         switch (proxy_type) {
 978         //LCOV_EXCL_START
 979         case WIFI_PROXY_TYPE_DIRECT:
 980                 profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
 981                 break;
 982         case WIFI_PROXY_TYPE_AUTO:
 983                 profile_info->ProfileInfo.Wlan.net_info.ProxyAddr[0] = '\0';
 984                 profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_AUTO;
 985                 break;
 986         case WIFI_PROXY_TYPE_MANUAL:
 987                 profile_info->ProfileInfo.Wlan.net_info.ProxyAddr[0] = '\0';
 988                 profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_MANUAL;
 989                 break;
 990         default:
 991                 return WIFI_ERROR_INVALID_PARAMETER;
 992         //LCOV_EXCL_STOP
 993         }
 994
 995         if (_wifi_libnet_check_profile_name_validity(profile_info->ProfileName) == false)
 996                 return WIFI_ERROR_NONE;
 997
 998         rv = _wifi_update_ap_info(profile_info);
 999         if (rv != NET_ERR_NONE && proxy_type == WIFI_PROXY_TYPE_MANUAL) {
1000                 g_strlcpy(profile_info->ProfileInfo.Wlan.net_info.ProxyAddr, "0.0.0.0:8080", 15);
1001                 rv = _wifi_update_ap_info(profile_info);
1002         }
1003
1004         return rv;
1005 }
1006
1007 EXPORT_API int wifi_ap_get_dns_address(wifi_ap_h ap, int order, wifi_address_family_e address_family, char** dns_address)
1008 {
1009         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_dns_address");
1010         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1011
1012         if (_wifi_libnet_check_ap_validity(ap) == false ||
1013             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
1014              address_family != WIFI_ADDRESS_FAMILY_IPV6) ||
1015             dns_address == NULL ||
1016             order <= 0 ||
1017             order > NET_DNS_ADDR_MAX) {
1018                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1019                 return WIFI_ERROR_INVALID_PARAMETER;
1020         }
1021
1022         net_profile_info_t *profile_info = ap;
1023
1024         if (address_family == WIFI_ADDRESS_FAMILY_IPV4)
1025                 *dns_address = __ap_convert_ip_to_string(
1026                                 &profile_info->ProfileInfo.Wlan.net_info.DnsAddr[order-1],
1027                                 address_family);
1028         else
1029                 *dns_address = __ap_convert_ip_to_string( //LCOV_EXCL_LINE
1030                                 &profile_info->ProfileInfo.Wlan.net_info.DnsAddr6[order-1],
1031                                 address_family);
1032
1033         if (*dns_address == NULL)
1034                 return WIFI_ERROR_OUT_OF_MEMORY;
1035
1036         return WIFI_ERROR_NONE;
1037 }
1038
1039 EXPORT_API int wifi_ap_set_dns_address(wifi_ap_h ap, int order, wifi_address_family_e address_family, const char* dns_address)
1040 {
1041         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_set_dns_address");
1042         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1043
1044         if (_wifi_libnet_check_ap_validity(ap) == false ||
1045             (address_family != WIFI_ADDRESS_FAMILY_IPV4 &&
1046              address_family != WIFI_ADDRESS_FAMILY_IPV6) ||
1047             order <= 0 ||
1048             order > NET_DNS_ADDR_MAX) {
1049                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1050                 return WIFI_ERROR_INVALID_PARAMETER;
1051         }
1052
1053         int rv = _wifi_libnet_check_get_privilege();
1054         if (rv == WIFI_ERROR_PERMISSION_DENIED) {
1055                 WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE
1056                 return rv;
1057         }
1058
1059         rv = _wifi_libnet_check_profile_privilege();
1060         if (rv == WIFI_ERROR_PERMISSION_DENIED) {
1061                 WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE
1062                 return rv;
1063         }
1064
1065         net_profile_info_t *profile_info = ap;
1066
1067         if (address_family == WIFI_ADDRESS_FAMILY_IPV6) {
1068                 //LCOV_EXCL_START
1069                 profile_info->ProfileInfo.Wlan.net_info.DnsAddr6[order-1].Type =
1070                         NET_ADDR_IPV6;
1071                 if (dns_address == NULL)
1072                         inet_pton(AF_INET6, "::",
1073                                         &profile_info->ProfileInfo.Wlan.net_info.DnsAddr6[order-1].Data.Ipv6);
1074                 else if (inet_pton(AF_INET6, dns_address,
1075                                         &profile_info->ProfileInfo.Wlan.net_info.DnsAddr6[order-1].Data.Ipv6) < 1)
1076                         return WIFI_ERROR_INVALID_PARAMETER;
1077
1078                 if (profile_info->ProfileInfo.Wlan.net_info.DnsCount6 < order)
1079                         profile_info->ProfileInfo.Wlan.net_info.DnsCount6 = order;
1080                 //LCOV_EXCL_STOP
1081         } else {
1082                 profile_info->ProfileInfo.Wlan.net_info.DnsAddr[order-1].Type =
1083                         NET_ADDR_IPV4;
1084                 if (dns_address == NULL)
1085                         profile_info->ProfileInfo.Wlan.net_info.DnsAddr[order-1].Data.Ipv4.s_addr = 0;
1086                 else if (inet_pton(AF_INET, dns_address,
1087                                         &(profile_info->ProfileInfo.Wlan.net_info.DnsAddr[order-1].Data.Ipv4)) < 1)
1088                         return WIFI_ERROR_INVALID_PARAMETER;
1089
1090                 if (profile_info->ProfileInfo.Wlan.net_info.DnsCount < order)
1091                         profile_info->ProfileInfo.Wlan.net_info.DnsCount = order;
1092         }
1093
1094         if (_wifi_libnet_check_profile_name_validity(profile_info->ProfileName) == false)
1095                 return WIFI_ERROR_NONE;
1096
1097         return _wifi_update_ap_info(profile_info);
1098 }
1099
1100 /* Wi-Fi security information ************************************************/
1101 EXPORT_API int wifi_ap_get_security_type(wifi_ap_h ap, wifi_security_type_e* type)
1102 {
1103         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_security_type");
1104         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1105
1106         if (_wifi_libnet_check_ap_validity(ap) == false || type == NULL) {
1107                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1108                 return WIFI_ERROR_INVALID_PARAMETER;
1109         }
1110
1111         net_profile_info_t *profile_info = ap;
1112
1113         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1114         //LCOV_EXCL_START
1115         case WLAN_SEC_MODE_NONE:
1116                 *type = WIFI_SECURITY_TYPE_NONE;
1117                 break;
1118         case WLAN_SEC_MODE_WEP:
1119                 *type = WIFI_SECURITY_TYPE_WEP; //LCOV_EXCL_LINE
1120                 break;
1121         case WLAN_SEC_MODE_IEEE8021X:
1122                 *type = WIFI_SECURITY_TYPE_EAP; //LCOV_EXCL_LINE
1123                 break;
1124         case WLAN_SEC_MODE_WPA_PSK:
1125                 *type = WIFI_SECURITY_TYPE_WPA_PSK; //LCOV_EXCL_LINE
1126                 break;
1127         case WLAN_SEC_MODE_WPA2_PSK:
1128                 *type = WIFI_SECURITY_TYPE_WPA2_PSK; //LCOV_EXCL_LINE
1129                 break;
1130         default:
1131                 return WIFI_ERROR_OPERATION_FAILED;
1132         //LCOV_EXCL_STOP
1133         }
1134
1135         return WIFI_ERROR_NONE;
1136 }
1137
1138 EXPORT_API int wifi_ap_set_security_type(wifi_ap_h ap, wifi_security_type_e type)
1139 {
1140         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_set_security_type");
1141         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1142
1143         if (_wifi_libnet_check_ap_validity(ap) == false) {
1144                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1145                 return WIFI_ERROR_INVALID_PARAMETER;
1146         }
1147
1148         net_profile_info_t *profile_info = ap;
1149
1150         switch (type) {
1151         //LCOV_EXCL_START
1152         case WIFI_SECURITY_TYPE_NONE:
1153                 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE; //LCOV_EXCL_LINE
1154                 break;
1155         case WIFI_SECURITY_TYPE_WEP:
1156                 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_WEP; //LCOV_EXCL_LINE
1157                 break;
1158         case WIFI_SECURITY_TYPE_EAP:
1159                 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_IEEE8021X;
1160                 break;
1161         case WIFI_SECURITY_TYPE_WPA_PSK:
1162                 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_WPA_PSK; //LCOV_EXCL_LINE
1163                 break;
1164         case WIFI_SECURITY_TYPE_WPA2_PSK:
1165                 profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_WPA2_PSK;
1166                 break;
1167         default:
1168                 return WIFI_ERROR_INVALID_PARAMETER;
1169         //LCOV_EXCL_STOP
1170         }
1171
1172         _wifi_set_profile_name_to_ap(profile_info);
1173
1174         return WIFI_ERROR_NONE;
1175 }
1176
1177 EXPORT_API int wifi_ap_get_encryption_type(wifi_ap_h ap, wifi_encryption_type_e* type)
1178 {
1179         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_encryption_type");
1180         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1181
1182         if (_wifi_libnet_check_ap_validity(ap) == false || type == NULL) {
1183                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1184                 return WIFI_ERROR_INVALID_PARAMETER;
1185         }
1186
1187         net_profile_info_t *profile_info = ap;
1188
1189         switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1190         //LCOV_EXCL_START
1191         case WLAN_ENC_MODE_NONE:
1192                 *type = WIFI_ENCRYPTION_TYPE_NONE;
1193                 break;
1194         case WLAN_ENC_MODE_WEP:
1195                 *type = WIFI_ENCRYPTION_TYPE_WEP; //LCOV_EXCL_LINE
1196                 break;
1197         case WLAN_ENC_MODE_TKIP:
1198                 *type = WIFI_ENCRYPTION_TYPE_TKIP; //LCOV_EXCL_LINE
1199                 break;
1200         case WLAN_ENC_MODE_AES:
1201                 *type = WIFI_ENCRYPTION_TYPE_AES; //LCOV_EXCL_LINE
1202                 break;
1203         case WLAN_ENC_MODE_TKIP_AES_MIXED:
1204                 *type = WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED; //LCOV_EXCL_LINE
1205                 break;
1206         default:
1207                 return WIFI_ERROR_OPERATION_FAILED;
1208         //LCOV_EXCL_STOP
1209         }
1210
1211         return WIFI_ERROR_NONE;
1212 }
1213
1214 EXPORT_API int wifi_ap_set_encryption_type(wifi_ap_h ap, wifi_encryption_type_e type)
1215 {
1216         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_set_encryption_type");
1217         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1218
1219         if (_wifi_libnet_check_ap_validity(ap) == false) {
1220                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1221                 return WIFI_ERROR_INVALID_PARAMETER;
1222         }
1223
1224         net_profile_info_t *profile_info = ap;
1225
1226         switch (type) {
1227         //LCOV_EXCL_START
1228         case WIFI_ENCRYPTION_TYPE_NONE:
1229                 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE; //LCOV_EXCL_LINE
1230                 break;
1231         case WIFI_ENCRYPTION_TYPE_WEP:
1232                 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_WEP; //LCOV_EXCL_LINE
1233                 break;
1234         case WIFI_ENCRYPTION_TYPE_TKIP:
1235                 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_TKIP; //LCOV_EXCL_LINE
1236                 break;
1237         case WIFI_ENCRYPTION_TYPE_AES:
1238                 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_AES;
1239                 break;
1240         case WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED:
1241                 profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_TKIP_AES_MIXED; //LCOV_EXCL_LINE
1242                 break;
1243         default:
1244                 return WIFI_ERROR_INVALID_PARAMETER;
1245         //LCOV_EXCL_STOP
1246         }
1247
1248         return WIFI_ERROR_NONE;
1249 }
1250
1251 EXPORT_API int wifi_ap_is_passphrase_required(wifi_ap_h ap, bool* required)
1252 {
1253         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_is_passphrase_required");
1254         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1255
1256         if (_wifi_libnet_check_ap_validity(ap) == false || required == NULL) {
1257                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1258                 return WIFI_ERROR_INVALID_PARAMETER;
1259         }
1260
1261         net_profile_info_t *profile_info = ap;
1262
1263         if (profile_info->Favourite) {
1264                 *required = false;
1265                 return WIFI_ERROR_NONE;
1266         }
1267
1268         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1269         //LCOV_EXCL_START
1270         case WLAN_SEC_MODE_NONE:
1271                 *required = false;
1272                 break;
1273         case WLAN_SEC_MODE_WEP:
1274         case WLAN_SEC_MODE_IEEE8021X:
1275         case WLAN_SEC_MODE_WPA_PSK:
1276         case WLAN_SEC_MODE_WPA2_PSK:
1277                 *required = true;
1278                 break;
1279         default:
1280                 return WIFI_ERROR_OPERATION_FAILED;
1281         //LCOV_EXCL_STOP
1282         }
1283
1284         return WIFI_ERROR_NONE;
1285 }
1286
1287 EXPORT_API int wifi_ap_set_passphrase(wifi_ap_h ap, const char* passphrase)
1288 {
1289         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_set_passphrase");
1290         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1291
1292         if (_wifi_libnet_check_ap_validity(ap) == false || passphrase == NULL) {
1293                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1294                 return WIFI_ERROR_INVALID_PARAMETER;
1295         }
1296
1297         net_profile_info_t *profile_info = ap;
1298
1299         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1300         //LCOV_EXCL_START
1301         case WLAN_SEC_MODE_WEP:
1302                 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.wep.wepKey,
1303                                 passphrase, NETPM_WLAN_MAX_WEP_KEY_LEN+1);
1304                 break;
1305         case WLAN_SEC_MODE_WPA_PSK:
1306         case WLAN_SEC_MODE_WPA2_PSK:
1307                 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1308                                 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN+1);
1309                 break;
1310         case WLAN_SEC_MODE_NONE:
1311         case WLAN_SEC_MODE_IEEE8021X:
1312         default:
1313                 return WIFI_ERROR_OPERATION_FAILED;
1314         //LCOV_EXCL_STOP
1315         }
1316
1317         return WIFI_ERROR_NONE;
1318 }
1319
1320 EXPORT_API int wifi_ap_is_wps_supported(wifi_ap_h ap, bool* supported)
1321 {
1322         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_is_wps_supported");
1323         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1324
1325         if (_wifi_libnet_check_ap_validity(ap) == false || supported == NULL) {
1326                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1327                 return WIFI_ERROR_INVALID_PARAMETER;
1328         }
1329
1330         net_profile_info_t *profile_info = ap;
1331
1332         if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1333                 *supported = true;
1334         else
1335                 *supported = false;
1336
1337         return WIFI_ERROR_NONE;
1338 }
1339
1340 /* Wi-Fi EAP *****************************************************************/
1341 EXPORT_API int wifi_ap_set_eap_passphrase(wifi_ap_h ap, const char* user_name, const char* password)
1342 {
1343         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_set_eap_passphrase");
1344         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1345
1346         if (_wifi_libnet_check_ap_validity(ap) == false || (user_name == NULL && password == NULL)) {
1347                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1348                 return WIFI_ERROR_INVALID_PARAMETER;
1349         }
1350
1351         net_profile_info_t *profile_info = ap;
1352         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1353                 return WIFI_ERROR_INVALID_OPERATION;
1354
1355         if (user_name)
1356                 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.username,
1357                                 user_name, NETPM_WLAN_USERNAME_LEN+1);
1358
1359         if (password)
1360                 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.password,
1361                                 password, NETPM_WLAN_PASSWORD_LEN+1);
1362
1363         return WIFI_ERROR_NONE;
1364 }
1365
1366 EXPORT_API int wifi_ap_get_eap_passphrase(wifi_ap_h ap, char** user_name, bool* is_password_set)
1367 {
1368         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_eap_passphrase");
1369         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1370
1371         if (_wifi_libnet_check_ap_validity(ap) == false || user_name == NULL || is_password_set == NULL) {
1372                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1373                 return WIFI_ERROR_INVALID_PARAMETER;
1374         }
1375
1376         net_profile_info_t *profile_info = ap;
1377         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1378                 return WIFI_ERROR_INVALID_OPERATION;
1379
1380         *user_name = g_strdup(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.username);
1381         if (*user_name == NULL)
1382                 return WIFI_ERROR_OUT_OF_MEMORY;
1383
1384         if (strlen(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.password) > 0)
1385                 *is_password_set = true;
1386         else
1387                 *is_password_set = false;
1388
1389
1390         return WIFI_ERROR_NONE;
1391 }
1392
1393 EXPORT_API int wifi_ap_get_eap_ca_cert_file(wifi_ap_h ap, char** file)
1394 {
1395         net_profile_info_t *profile_info = NULL;
1396
1397         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_eap_ca_cert_file");
1398         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1399
1400         if (_wifi_libnet_check_ap_validity(ap) == false || file == NULL) {
1401                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1402                 return WIFI_ERROR_INVALID_PARAMETER;
1403         }
1404
1405         profile_info = (net_profile_info_t *)ap;
1406         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1407                 return WIFI_ERROR_INVALID_OPERATION;
1408
1409         *file = g_strdup(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.ca_cert_filename);
1410         if (*file == NULL)
1411                 return WIFI_ERROR_OUT_OF_MEMORY;
1412
1413         return WIFI_ERROR_NONE;
1414 }
1415
1416 EXPORT_API int wifi_ap_set_eap_ca_cert_file(wifi_ap_h ap, const char* file)
1417 {
1418         net_profile_info_t *profile_info = NULL;
1419
1420         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_set_eap_ca_cert_file");
1421         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1422
1423         if (_wifi_libnet_check_ap_validity(ap) == false || file == NULL) {
1424                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1425                 return WIFI_ERROR_INVALID_PARAMETER;
1426         }
1427
1428         profile_info = (net_profile_info_t *)ap;
1429         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1430                 return WIFI_ERROR_INVALID_OPERATION;
1431
1432         g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.ca_cert_filename,
1433                         file, NETPM_WLAN_CA_CERT_FILENAME_LEN+1);
1434
1435         return WIFI_ERROR_NONE;
1436 }
1437
1438 EXPORT_API int wifi_ap_get_eap_client_cert_file(wifi_ap_h ap, char** file)
1439 {
1440         net_profile_info_t *profile_info = NULL;
1441
1442         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_eap_client_cert_file");
1443         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1444
1445         if (_wifi_libnet_check_ap_validity(ap) == false || file == NULL) {
1446                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1447                 return WIFI_ERROR_INVALID_PARAMETER;
1448         }
1449
1450         profile_info = (net_profile_info_t *)ap;
1451         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1452                 return WIFI_ERROR_INVALID_OPERATION;
1453
1454         *file = g_strdup(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.client_cert_filename);
1455         if (*file == NULL)
1456                 return WIFI_ERROR_OUT_OF_MEMORY;
1457
1458         return WIFI_ERROR_NONE;
1459 }
1460
1461 EXPORT_API int wifi_ap_set_eap_client_cert_file(wifi_ap_h ap, const char* file)
1462 {
1463         net_profile_info_t *profile_info = NULL;
1464
1465         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_set_eap_client_cert_file");
1466         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1467
1468         if (_wifi_libnet_check_ap_validity(ap) == false || file == NULL) {
1469                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1470                 return WIFI_ERROR_INVALID_PARAMETER;
1471         }
1472
1473         profile_info = (net_profile_info_t *)ap;
1474         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1475                 return WIFI_ERROR_INVALID_OPERATION;
1476
1477         g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.client_cert_filename,
1478                         file, NETPM_WLAN_CLIENT_CERT_FILENAME_LEN+1);
1479
1480         return WIFI_ERROR_NONE;
1481 }
1482
1483 EXPORT_API int wifi_ap_get_eap_private_key_file(wifi_ap_h ap, char** file)
1484 {
1485         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_eap_private_key_file");
1486         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1487
1488         if (_wifi_libnet_check_ap_validity(ap) == false || file == NULL) {
1489                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1490                 return WIFI_ERROR_INVALID_PARAMETER;
1491         }
1492
1493         net_profile_info_t *profile_info = ap;
1494         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1495                 return WIFI_ERROR_INVALID_OPERATION;
1496
1497         *file = g_strdup(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.private_key_filename);
1498         if (*file == NULL)
1499                 return WIFI_ERROR_OUT_OF_MEMORY;
1500
1501         return WIFI_ERROR_NONE;
1502 }
1503
1504 EXPORT_API int wifi_ap_set_eap_private_key_info(wifi_ap_h ap, const char* file, const char* password)
1505 {
1506         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_set_eap_private_key_info");
1507         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1508
1509         if (_wifi_libnet_check_ap_validity(ap) == false || file == NULL) {
1510                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1511                 return WIFI_ERROR_INVALID_PARAMETER;
1512         }
1513
1514         net_profile_info_t *profile_info = ap;
1515         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1516                 return WIFI_ERROR_INVALID_OPERATION;
1517
1518         g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.private_key_filename,
1519                         file, NETPM_WLAN_PRIVATE_KEY_FILENAME_LEN+1);
1520
1521         if (password) {
1522                 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.eap.private_key_passwd,
1523                                 password, NETPM_WLAN_PRIVATE_KEY_PASSWD_LEN+1);
1524         }
1525
1526         return WIFI_ERROR_NONE;
1527 }
1528
1529 EXPORT_API int wifi_ap_get_eap_type(wifi_ap_h ap, wifi_eap_type_e* type)
1530 {
1531         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_eap_type");
1532         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1533
1534         if (_wifi_libnet_check_ap_validity(ap) == false || type == NULL) {
1535                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1536                 return WIFI_ERROR_INVALID_PARAMETER;
1537         }
1538
1539         net_profile_info_t *profile_info = ap;
1540         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1541                 return WIFI_ERROR_INVALID_OPERATION;
1542
1543         switch (profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_type) {
1544         //LCOV_EXCL_START
1545         case WLAN_SEC_EAP_TYPE_PEAP:
1546                 *type = WIFI_EAP_TYPE_PEAP;
1547                 break;
1548         case WLAN_SEC_EAP_TYPE_TLS:
1549                 *type = WIFI_EAP_TYPE_TLS;
1550                 break;
1551         case WLAN_SEC_EAP_TYPE_TTLS:
1552                 *type = WIFI_EAP_TYPE_TTLS;
1553                 break;
1554         case WLAN_SEC_EAP_TYPE_SIM:
1555                 *type = WIFI_EAP_TYPE_SIM;
1556                 break;
1557         case WLAN_SEC_EAP_TYPE_AKA:
1558                 *type = WIFI_EAP_TYPE_AKA;
1559                 break;
1560         default:
1561                 return WIFI_ERROR_OPERATION_FAILED;
1562         //LCOV_EXCL_STOP
1563         }
1564
1565         return WIFI_ERROR_NONE;
1566 }
1567
1568 EXPORT_API int wifi_ap_set_eap_type(wifi_ap_h ap, wifi_eap_type_e type)
1569 {
1570         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_set_eap_type");
1571         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1572
1573         if (_wifi_libnet_check_ap_validity(ap) == false) {
1574                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1575                 return WIFI_ERROR_INVALID_PARAMETER;
1576         }
1577
1578         net_profile_info_t *profile_info = ap;
1579         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1580                 return WIFI_ERROR_INVALID_OPERATION;
1581
1582         switch (type) {
1583         //LCOV_EXCL_START
1584         case WIFI_EAP_TYPE_PEAP:
1585                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_PEAP;
1586                 break;
1587         case WIFI_EAP_TYPE_TLS:
1588                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_TLS;
1589                 break;
1590         case WIFI_EAP_TYPE_TTLS:
1591                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_TTLS;
1592                 break;
1593         case WIFI_EAP_TYPE_SIM:
1594                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_SIM;
1595                 break;
1596         case WIFI_EAP_TYPE_AKA:
1597                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_AKA;
1598                 break;
1599         default:
1600                 return WIFI_ERROR_INVALID_PARAMETER;
1601         //LCOV_EXCL_STOP
1602         }
1603
1604         return WIFI_ERROR_NONE;
1605 }
1606
1607 EXPORT_API int wifi_ap_get_eap_auth_type(wifi_ap_h ap, wifi_eap_auth_type_e* type)
1608 {
1609         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_get_eap_auth_type");
1610         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1611
1612         if (_wifi_libnet_check_ap_validity(ap) == false || type == NULL) {
1613                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1614                 return WIFI_ERROR_INVALID_PARAMETER;
1615         }
1616
1617         net_profile_info_t *profile_info = ap;
1618         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1619                 return WIFI_ERROR_INVALID_OPERATION;
1620
1621         switch (profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_auth) {
1622         //LCOV_EXCL_START
1623         case WLAN_SEC_EAP_AUTH_NONE:
1624                 *type = WIFI_EAP_AUTH_TYPE_NONE;
1625                 break;
1626         case WLAN_SEC_EAP_AUTH_PAP:
1627                 *type = WIFI_EAP_AUTH_TYPE_PAP;
1628                 break;
1629         case WLAN_SEC_EAP_AUTH_MSCHAP:
1630                 *type = WIFI_EAP_AUTH_TYPE_MSCHAP;
1631                 break;
1632         case WLAN_SEC_EAP_AUTH_MSCHAPV2:
1633                 *type = WIFI_EAP_AUTH_TYPE_MSCHAPV2;
1634                 break;
1635         case WLAN_SEC_EAP_AUTH_GTC:
1636                 *type = WIFI_EAP_AUTH_TYPE_GTC;
1637                 break;
1638         case WLAN_SEC_EAP_AUTH_MD5:
1639                 *type = WIFI_EAP_AUTH_TYPE_MD5;
1640                 break;
1641         default:
1642                 return WIFI_ERROR_OPERATION_FAILED;
1643         //LCOV_EXCL_STOP
1644         }
1645
1646         return WIFI_ERROR_NONE;
1647 }
1648
1649 EXPORT_API int wifi_ap_set_eap_auth_type(wifi_ap_h ap, wifi_eap_auth_type_e type)
1650 {
1651         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_ap_set_eap_auth_type");
1652         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1653
1654         if (_wifi_libnet_check_ap_validity(ap) == false) {
1655                 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1656                 return WIFI_ERROR_INVALID_PARAMETER;
1657         }
1658
1659         net_profile_info_t *profile_info = ap;
1660         if (profile_info->ProfileInfo.Wlan.security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X)
1661                 return WIFI_ERROR_INVALID_OPERATION;
1662
1663         switch (type) {
1664         //LCOV_EXCL_START
1665         case WIFI_EAP_AUTH_TYPE_NONE:
1666                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_NONE;
1667                 break;
1668         case WIFI_EAP_AUTH_TYPE_PAP:
1669                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_PAP;
1670                 break;
1671         case WIFI_EAP_AUTH_TYPE_MSCHAP:
1672                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_MSCHAP;
1673                 break;
1674         case WIFI_EAP_AUTH_TYPE_MSCHAPV2:
1675                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_MSCHAPV2;
1676                 break;
1677         case WIFI_EAP_AUTH_TYPE_GTC:
1678                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_GTC;
1679                 break;
1680         case WIFI_EAP_AUTH_TYPE_MD5:
1681                 profile_info->ProfileInfo.Wlan.security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_MD5;
1682                 break;
1683         default:
1684                 return WIFI_ERROR_INVALID_PARAMETER;
1685         //LCOV_EXCL_STOP
1686         }
1687
1688         return WIFI_ERROR_NONE;
1689 }