src/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 "network_internal.h"
  25 #include "wifi_internal.h"
  26
  27 #define MAX_PREFIX_LENGTH 6
  28
  29 //LCOV_EXCL_START
  30 static char *__ap_convert_ip_to_string(net_addr_s *ip_addr,
  31                 wifi_manager_address_family_e address_family)
  32 {
  33         unsigned char *ipaddr = NULL;
  34         char *ipstr = NULL;
  35
  36         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) {
  37                 ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr;
  38                 ipstr = g_try_malloc0(INET_ADDRSTRLEN);
  39                 if (ipstr == NULL)
  40                         return NULL;
  41
  42                 inet_ntop(AF_INET, ipaddr, ipstr, INET_ADDRSTRLEN);
  43         } else {
  44                 ipaddr = (unsigned char *)&ip_addr->Data.Ipv6;
  45                 ipstr = g_try_malloc0(INET6_ADDRSTRLEN);
  46                 if (ipstr == NULL)
  47                         return NULL;
  48
  49                 inet_ntop(AF_INET6, ipaddr, ipstr, INET6_ADDRSTRLEN);
  50         }
  51         return ipstr;
  52 }
  53
  54 static void __wifi_init_ap(wifi_manager_handle_s *wifi_handle,
  55                 net_profile_info_s *profile_info, const char *essid)
  56 {
  57         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
  58         profile_info->net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
  59         profile_info->net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
  60         profile_info->wlan_mode = NET_WLAN_CONNMODE_AUTO;
  61         profile_info->security_info.sec_mode = WLAN_SEC_MODE_NONE;
  62         profile_info->security_info.enc_mode = WLAN_ENC_MODE_NONE;
  63         g_strlcpy(profile_info->essid, essid, NET_WLAN_ESSID_LEN+1);
  64
  65         profile_info->network_info = wifi_handle->network_info;
  66 }
  67
  68 static char *__wifi_create_profile_name(const char *ssid,
  69                 const int net_mode, const int sec_mode)
  70 {
  71         char *buf = NULL;
  72         char *pbuf = NULL;
  73         const char *hidden_str = "hidden";
  74         char buf_tmp[32] = { 0, };
  75         int i;
  76         int ssid_len = 0;
  77         int actual_len = 0;
  78         const char *mode = "managed";
  79         char *g_sec = NULL;
  80
  81         if (net_mode == NET_WLAN_CONNMODE_ADHOC) {
  82                 WIFI_LOG(WIFI_ERROR, "wlan_mode is adhoc");
  83                 return NULL;
  84         }
  85
  86         switch (sec_mode) {
  87         case WLAN_SEC_MODE_NONE:
  88                 g_sec = "none";
  89                 break;
  90         case WLAN_SEC_MODE_WEP:
  91                 g_sec = "wep";
  92                 break;
  93         case WLAN_SEC_MODE_IEEE8021X:
  94                 g_sec = "ieee8021x";
  95                 break;
  96         case WLAN_SEC_MODE_WPA_PSK:
  97         case WLAN_SEC_MODE_WPA2_PSK:
  98                 g_sec = "psk";
  99                 break;
 100         case WLAN_SEC_MODE_WPA_FT_PSK:
 101                 g_sec = "ft_psk";
 102                 break;
 103         case WLAN_SEC_MODE_SAE:
 104                 g_sec = "sae";
 105                 break;
 106         case WLAN_SEC_MODE_OWE:
 107                 g_sec = "owe";
 108                 break;
 109         case WLAN_SEC_MODE_DPP:
 110                 g_sec = "dpp";
 111                 break;
 112         default:
 113                 WIFI_LOG(WIFI_ERROR, "Invalid security type");
 114                 return NULL;
 115         }
 116
 117         if (NULL != ssid) {
 118                 ssid_len = strlen(ssid);
 119                 actual_len = ssid_len * 2;
 120         } else {
 121                 ssid_len = strlen(hidden_str);
 122                 actual_len = ssid_len;
 123         }
 124
 125         buf = g_try_malloc0(actual_len + strlen(mode) + strlen(g_sec) + 3);
 126         if (buf == NULL)
 127                 return NULL;
 128
 129         if (NULL != ssid) {
 130                 pbuf = buf;
 131
 132                 for (i = 0; i < ssid_len; i++) {
 133                         g_snprintf(pbuf, 3, "%02x", ssid[i]);
 134                         pbuf += 2;
 135                 }
 136         } else
 137                 g_strlcat(buf, hidden_str,
 138                                 actual_len + strlen(mode) + strlen(g_sec) + 3);
 139
 140         g_snprintf(buf_tmp, 32, "_%s_%s", mode, g_sec);
 141         g_strlcat(buf, buf_tmp,
 142                         actual_len + strlen(mode) + strlen(g_sec) + 3);
 143
 144         WIFI_LOG(WIFI_INFO, "Profile name: %s", buf);
 145
 146         return buf;
 147 }
 148
 149 int __ap_convert_netmask_to_prefix_len(const char *netmask)
 150 {
 151         if (netmask == NULL)
 152                 return 0;
 153
 154         in_addr_t mask = inet_network(netmask);
 155         int prefix_len = 0;
 156
 157         for (; mask; mask <<= 1)
 158                 ++prefix_len;
 159
 160         return prefix_len;
 161 }
 162
 163 static in_addr_t __ap_convert_prefix_len_to_netmask(int prefix_len)
 164 {
 165         return (prefix_len ? (in_addr_t) 0xFFFFFFFFu >> (32 - prefix_len) : 0);
 166 }
 167
 168 static wifi_manager_rssi_level_e __ap_convert_dbm_to_level_24(int rssi_dbm)
 169 {
 170         wifi_manager_rssi_level_e rssi_level = WIFI_MANAGER_RSSI_LEVEL_0;
 171
 172         /* Wi-Fi Signal Strength Display (for 2.4G (dB))
 173          *
 174          * Excellent :     ~ -63
 175          * Good      : -64 ~ -74
 176          * Weak      : -75 ~ -82
 177          * Very weak : -83 ~ -88
 178          * No signal : -89 ~
 179          */
 180
 181         if (rssi_dbm >= -63)
 182                 rssi_level = WIFI_MANAGER_RSSI_LEVEL_4;
 183         else if (rssi_dbm >= -74)
 184                 rssi_level = WIFI_MANAGER_RSSI_LEVEL_3;
 185         else if (rssi_dbm >= -82)
 186                 rssi_level = WIFI_MANAGER_RSSI_LEVEL_2;
 187         else if (rssi_dbm >= -88)
 188                 rssi_level = WIFI_MANAGER_RSSI_LEVEL_1;
 189         else
 190                 rssi_level = WIFI_MANAGER_RSSI_LEVEL_0;
 191
 192         return rssi_level;
 193 }
 194
 195 static wifi_manager_rssi_level_e __ap_convert_dbm_to_level_50(int rssi_dbm)
 196 {
 197         wifi_manager_rssi_level_e rssi_level = WIFI_MANAGER_RSSI_LEVEL_0;
 198
 199         /* Wi-Fi Signal Strength Display (for 5G (dB))
 200          *
 201          * Excellent :     ~ -67
 202          * Good      : -68 ~ -76
 203          * Weak      : -77 ~ -82
 204          * Very weak : -83 ~ -88
 205          * No signal : -89 ~
 206          */
 207
 208         if (rssi_dbm >= -67)
 209                 rssi_level = WIFI_MANAGER_RSSI_LEVEL_4;
 210         else if (rssi_dbm >= -76)
 211                 rssi_level = WIFI_MANAGER_RSSI_LEVEL_3;
 212         else if (rssi_dbm >= -82)
 213                 rssi_level = WIFI_MANAGER_RSSI_LEVEL_2;
 214         else if (rssi_dbm >= -88)
 215                 rssi_level = WIFI_MANAGER_RSSI_LEVEL_1;
 216         else
 217                 rssi_level = WIFI_MANAGER_RSSI_LEVEL_0;
 218
 219         return rssi_level;
 220 }
 221
 222 static bool _wifi_set_profile_name_to_ap(net_profile_info_s *ap_info)
 223 {
 224         char *profile_name = NULL;
 225
 226         if (ap_info == NULL) {
 227                 WIFI_LOG(WIFI_ERROR, "profile_info is NULL");
 228                 return false;
 229         }
 230
 231         profile_name = __wifi_create_profile_name(
 232                         ap_info->is_hidden == TRUE ?
 233                                         NULL : ap_info->essid,
 234                         ap_info->wlan_mode,
 235                         ap_info->security_info.sec_mode);
 236         if (profile_name == NULL) {
 237                 WIFI_LOG(WIFI_ERROR, "Failed to make a group name");
 238                 return false;
 239         }
 240
 241         g_strlcpy(ap_info->net_info.ProfileName,
 242                         profile_name, NET_PROFILE_NAME_LEN_MAX + 1);
 243
 244         g_free(profile_name);
 245
 246         return true;
 247 }
 248
 249 wifi_manager_connection_state_e _wifi_convert_to_ap_state(net_state_type_e state)
 250 {
 251         wifi_manager_connection_state_e ap_state;
 252
 253         switch (state) {
 254         case NET_STATE_TYPE_ONLINE:
 255         case NET_STATE_TYPE_READY:
 256                 ap_state = WIFI_MANAGER_CONNECTION_STATE_CONNECTED;
 257                 break;
 258         case NET_STATE_TYPE_FAILURE:
 259                 ap_state = WIFI_MANAGER_CONNECTION_STATE_FAILURE;
 260                 break;
 261         case NET_STATE_TYPE_IDLE:
 262         case NET_STATE_TYPE_DISCONNECT:
 263                 ap_state = WIFI_MANAGER_CONNECTION_STATE_DISCONNECTED;
 264                 break;
 265         case NET_STATE_TYPE_ASSOCIATION:
 266                 ap_state = WIFI_MANAGER_CONNECTION_STATE_ASSOCIATION;
 267                 break;
 268         case NET_STATE_TYPE_CONFIGURATION:
 269                 ap_state = WIFI_MANAGER_CONNECTION_STATE_CONFIGURATION;
 270                 break;
 271         default:
 272                 ap_state = -1;
 273                 break;
 274         }
 275
 276         return ap_state;
 277 }
 278
 279 wifi_manager_error_e __wifi_convert_to_ap_error_state(net_error_state_type_e error)
 280 {
 281         wifi_manager_error_e ap_error_state;
 282
 283         switch (error) {
 284         case NET_STATE_ERROR_OUT_OF_RANGE:
 285                 ap_error_state = WIFI_MANAGER_ERROR_OUT_OF_RANGE;
 286                 break;
 287         case NET_STATE_ERROR_PIN_MISSING:
 288                 ap_error_state = WIFI_MANAGER_ERROR_PIN_MISSING;
 289                 break;
 290         case NET_STATE_ERROR_DHCP_FAILED:
 291                 ap_error_state = WIFI_MANAGER_ERROR_DHCP_FAILED;
 292                 break;
 293         case NET_STATE_ERROR_CONNECT_FAILED:
 294                 ap_error_state = WIFI_MANAGER_ERROR_OPERATION_FAILED;
 295                 break;
 296         case NET_STATE_ERROR_LOGIN_FAILED:
 297                 ap_error_state = WIFI_MANAGER_ERROR_LOGIN_FAILED;
 298                 break;
 299         case NET_STATE_ERROR_AUTH_FAILED:
 300                 ap_error_state = WIFI_MANAGER_ERROR_AUTHENTICATION_FAILED;
 301                 break;
 302         case NET_STATE_ERROR_ASSOC_FAILED:
 303                 ap_error_state = WIFI_MANAGER_ERROR_ASSOCIATION_FAILED;
 304                 break;
 305         case NET_STATE_ERROR_INVALID_KEY:
 306                 ap_error_state = WIFI_MANAGER_ERROR_INVALID_KEY;
 307                 break;
 308         default:
 309                 ap_error_state = WIFI_MANAGER_ERROR_NONE;
 310                 break;
 311         }
 312
 313         return ap_error_state;
 314 }
 315
 316 wifi_manager_connection_mode_e __ap_convert_string_to_connection_mode(char *mode)
 317 {
 318         if (g_strcmp0(mode, "802.11b") == 0)
 319                 return WIFI_MANAGER_CONNECTION_MODE_80211_B;
 320         else if (g_strcmp0(mode, "802.11g") == 0)
 321                 return WIFI_MANAGER_CONNECTION_MODE_80211_G;
 322         else if (g_strcmp0(mode, "802.11n") == 0)
 323                 return WIFI_MANAGER_CONNECTION_MODE_80211_N;
 324         else if (g_strcmp0(mode, "802.11a") == 0)
 325                 return WIFI_MANAGER_CONNECTION_MODE_80211_A;
 326         else if (g_strcmp0(mode, "802.11ac") == 0)
 327                 return WIFI_MANAGER_CONNECTION_MODE_80211_AC;
 328         else if (g_strcmp0(mode, "802.11ax") == 0)
 329                 return WIFI_MANAGER_CONNECTION_MODE_80211_AX;
 330         else
 331                 return WIFI_MANAGER_CONNECTION_MODE_UNKNOWN;
 332 }
 333 //LCOV_EXCL_STOP
 334
 335 EXPORT_API int wifi_manager_ap_create(wifi_manager_h wifi,
 336         const char *essid, wifi_manager_ap_h *ap)
 337 {
 338         __NETWORK_CAPI_FUNC_ENTER__;
 339
 340         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 341
 342         RET_ERR_IF_HANDLE_IS_NOT_VALID_OR_NOT_INITIALIZED(wifi, __NETWORK_CAPI_FUNC_EXIT__);
 343
 344         if (!_wifi_check_essid_validity(essid) || ap == NULL) {
 345                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 346                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 347                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 348         }
 349
 350         net_profile_info_s *ap_info = g_try_malloc0(sizeof(net_profile_info_s));
 351         if (ap_info == NULL) {
 352                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 353                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 354         }
 355
 356         __wifi_init_ap(wifi, ap_info, essid);
 357
 358         _wifi_add_to_ap_list(ap_info);
 359         *ap = (wifi_manager_ap_h)ap_info;
 360
 361         __NETWORK_CAPI_FUNC_EXIT__;
 362
 363         return WIFI_MANAGER_ERROR_NONE;
 364 }
 365
 366 EXPORT_API int wifi_manager_ap_hidden_create(wifi_manager_h wifi,
 367                 const char *essid, wifi_manager_ap_h *ap)
 368 {
 369         __NETWORK_CAPI_FUNC_ENTER__;
 370
 371         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 372
 373         RET_ERR_IF_HANDLE_IS_NOT_VALID_OR_NOT_INITIALIZED(wifi, __NETWORK_CAPI_FUNC_EXIT__);
 374
 375         if (essid == NULL || ap == NULL) {
 376                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 377                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 378                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 379         }
 380
 381         net_profile_info_s *ap_info = g_try_malloc0(sizeof(net_profile_info_s));
 382         if (ap_info == NULL) {
 383                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 384                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 385         }
 386
 387         __wifi_init_ap(wifi, ap_info, essid);
 388         ap_info->is_hidden = TRUE;
 389
 390         _wifi_add_to_ap_list(ap_info);
 391         *ap = (wifi_manager_ap_h)ap_info;
 392
 393         __NETWORK_CAPI_FUNC_EXIT__;
 394
 395         return WIFI_MANAGER_ERROR_NONE;
 396 }
 397
 398 EXPORT_API int wifi_manager_ap_destroy(wifi_manager_ap_h ap)
 399 {
 400         /* __NETWORK_CAPI_FUNC_ENTER__; */
 401
 402         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 403
 404         net_profile_info_s *ap_info = (net_profile_info_s *)ap;
 405
 406         if (_wifi_check_ap_validity(ap) == false) {
 407                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 408                 /* __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE */
 409                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 410         }
 411
 412         _wifi_remove_from_ap_list(ap);
 413
 414         g_slist_free_full(ap_info->vsie_list, g_free);
 415         g_slist_free_full(ap_info->bssid_list, g_free);
 416         g_free(ap);
 417
 418         /* __NETWORK_CAPI_FUNC_EXIT__; */
 419
 420         return WIFI_MANAGER_ERROR_NONE;
 421 }
 422
 423 EXPORT_API int wifi_manager_ap_clone(wifi_manager_ap_h *cloned_ap, wifi_manager_ap_h origin)
 424 {
 425         /* __NETWORK_CAPI_FUNC_ENTER__; */
 426
 427         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 428
 429         if (_wifi_check_ap_validity(origin) == false || cloned_ap == NULL) {
 430                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 431                 /* __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE */
 432                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 433         }
 434
 435         net_profile_info_s *origin_info = origin;
 436         net_profile_info_s *ap_info = g_try_malloc0(sizeof(net_profile_info_s));
 437         if (ap_info == NULL) {
 438                 /* __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE */
 439                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 440         }
 441
 442         memcpy(ap_info, origin, sizeof(net_profile_info_s));
 443         ap_info->vsie_list = g_slist_copy_deep(origin_info->vsie_list,
 444                                                         _wifi_copy_vsie_list, NULL);
 445         ap_info->bssid_list = g_slist_copy_deep(origin_info->bssid_list,
 446                                                         _wifi_copy_bssid_list, NULL);
 447
 448         _wifi_add_to_ap_list(ap_info);
 449         *cloned_ap = (wifi_manager_ap_h)ap_info;
 450
 451         /* __NETWORK_CAPI_FUNC_EXIT__; */
 452
 453         return WIFI_MANAGER_ERROR_NONE;
 454 }
 455
 456 EXPORT_API int wifi_manager_ap_refresh(wifi_manager_ap_h ap)
 457 {
 458         __NETWORK_CAPI_FUNC_ENTER__;
 459
 460         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 461
 462         net_profile_info_s ap_info_local;
 463         net_profile_info_s *ap_info = ap;
 464
 465         if (_wifi_check_ap_validity(ap) == false) {
 466                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 467                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 468                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 469         }
 470
 471         int rv = NET_ERR_NONE;
 472         rv = net_get_profile_info(ap_info->network_info, ap_info->ProfileName, &ap_info_local);
 473         if (rv == NET_ERR_ACCESS_DENIED) {
 474                 WIFI_LOG(WIFI_ERROR, "Access denied"); //LCOV_EXCL_LINE
 475                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 476                 return WIFI_MANAGER_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 477         } else if (rv != NET_ERR_NONE) {
 478                 WIFI_LOG(WIFI_ERROR, "Failed to getprofile_info"); //LCOV_EXCL_LINE
 479                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 480                 return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 481         }
 482
 483         if (ap_info->vsie_list)
 484                 g_slist_free_full(ap_info->vsie_list, g_free);
 485         if (ap_info->bssid_list)
 486                 g_slist_free_full(ap_info->bssid_list, g_free);
 487
 488         memcpy(ap, &ap_info_local, sizeof(net_profile_info_s));
 489         ap_info->vsie_list = g_slist_copy_deep(ap_info_local.vsie_list,
 490                         _wifi_copy_vsie_list, NULL);
 491         ap_info->bssid_list = g_slist_copy_deep(ap_info_local.bssid_list,
 492                         _wifi_copy_bssid_list, NULL);
 493
 494         __NETWORK_CAPI_FUNC_EXIT__;
 495
 496         return WIFI_MANAGER_ERROR_NONE;
 497 }
 498
 499 /* Wi-Fi network information ************************************************/
 500 EXPORT_API int wifi_manager_ap_get_essid(wifi_manager_ap_h ap, char **essid)
 501 {
 502         /* __NETWORK_CAPI_FUNC_ENTER__; */
 503
 504         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 505
 506         if (_wifi_check_ap_validity(ap) == false || essid == NULL) {
 507                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 508                 /* __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE */
 509                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 510         }
 511
 512         net_profile_info_s *profile_info = ap;
 513         *essid = g_strdup(profile_info->essid);
 514         if (*essid == NULL) {
 515                 /* __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE */
 516                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 517         }
 518
 519         /* __NETWORK_CAPI_FUNC_EXIT__; */
 520
 521         return WIFI_MANAGER_ERROR_NONE;
 522 }
 523
 524 EXPORT_API int wifi_manager_ap_get_raw_ssid(wifi_manager_ap_h ap, char **ssid, int *ssid_len)
 525 {
 526         __NETWORK_CAPI_FUNC_ENTER__;
 527
 528         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 529
 530         if (_wifi_check_ap_validity(ap) == false || ssid == NULL ||
 531                         ssid_len == NULL) {
 532                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 533                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 534                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 535         }
 536
 537         net_profile_info_s *profile_info = ap;
 538         *ssid = g_try_malloc0(NET_WLAN_RAW_SSID_LEN + 1);
 539         if (*ssid == NULL) {
 540                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 541                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 542         }
 543
 544         memcpy(*ssid, profile_info->raw_ssid, NET_WLAN_RAW_SSID_LEN);
 545         *ssid_len = profile_info->raw_ssid_len;
 546
 547         __NETWORK_CAPI_FUNC_EXIT__;
 548
 549         return WIFI_MANAGER_ERROR_NONE;
 550 }
 551
 552 EXPORT_API int wifi_manager_ap_get_bssid(wifi_manager_ap_h ap, char **bssid)
 553 {
 554         __NETWORK_CAPI_FUNC_ENTER__;
 555
 556         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 557
 558         if (_wifi_check_ap_validity(ap) == false || bssid == NULL) {
 559                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 560                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 561                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 562         }
 563
 564         net_profile_info_s *profile_info = ap;
 565         *bssid = g_strdup(profile_info->bssid);
 566         if (*bssid == NULL) {
 567                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 568                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 569         }
 570
 571         __NETWORK_CAPI_FUNC_EXIT__;
 572
 573         return WIFI_MANAGER_ERROR_NONE;
 574 }
 575
 576 EXPORT_API int wifi_manager_ap_get_rssi(wifi_manager_ap_h ap, int *rssi)
 577 {
 578         /* __NETWORK_CAPI_FUNC_ENTER__; */
 579
 580         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 581
 582         if (_wifi_check_ap_validity(ap) == false || rssi == NULL) {
 583                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 584                 /* __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE */
 585                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 586         }
 587
 588         net_profile_info_s *profile_info = ap;
 589         *rssi = (int)(profile_info->Strength - 120);
 590
 591         /* __NETWORK_CAPI_FUNC_EXIT__; */
 592
 593         return WIFI_MANAGER_ERROR_NONE;
 594 }
 595
 596 EXPORT_API int wifi_manager_ap_get_rssi_level(wifi_manager_ap_h ap, wifi_manager_rssi_level_e *rssi_level)
 597 {
 598         __NETWORK_CAPI_FUNC_ENTER__;
 599
 600         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 601
 602         int rssi_dbm = 0;
 603
 604         if (_wifi_check_ap_validity(ap) == false || rssi_level == NULL) {
 605                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 606                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 607                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 608         }
 609
 610         net_profile_info_s *profile_info = ap;
 611         rssi_dbm = (int)(profile_info->Strength - 120);
 612
 613         if (profile_info->frequency > 4900)
 614                 *rssi_level = __ap_convert_dbm_to_level_50(rssi_dbm);
 615         else
 616                 *rssi_level = __ap_convert_dbm_to_level_24(rssi_dbm);
 617
 618         __NETWORK_CAPI_FUNC_EXIT__;
 619
 620         return WIFI_MANAGER_ERROR_NONE;
 621 }
 622
 623 EXPORT_API int wifi_manager_ap_get_frequency(wifi_manager_ap_h ap, int *frequency)
 624 {
 625         __NETWORK_CAPI_FUNC_ENTER__;
 626
 627         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 628
 629         if (_wifi_check_ap_validity(ap) == false || frequency == NULL) {
 630                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 631                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 632                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 633         }
 634
 635         net_profile_info_s *profile_info = ap;
 636         *frequency = (int)profile_info->frequency;
 637
 638         __NETWORK_CAPI_FUNC_EXIT__;
 639
 640         return WIFI_MANAGER_ERROR_NONE;
 641 }
 642
 643 EXPORT_API int wifi_manager_ap_foreach_vsie(wifi_manager_ap_h ap,
 644                 wifi_manager_ap_vsie_cb callback, void *user_data)
 645 {
 646         __NETWORK_CAPI_FUNC_ENTER__;
 647
 648         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 649
 650         if (_wifi_check_ap_validity(ap) == false || callback == NULL) {
 651                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 652                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 653                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 654         }
 655
 656         net_profile_info_s *profile_info = ap;
 657
 658         bool rv;
 659         GSList *list;
 660         for (list = profile_info->vsie_list; list; list = list->next) {
 661                 unsigned char *vsie = (unsigned char *)list->data;
 662                 int length = vsie[1] + 2;
 663
 664                 rv = callback(vsie, length, user_data);
 665                 if (rv == false)
 666                         break;
 667         }
 668
 669         __NETWORK_CAPI_FUNC_EXIT__;
 670         return WIFI_MANAGER_ERROR_NONE;
 671 }
 672
 673 EXPORT_API int wifi_manager_ap_get_max_speed(wifi_manager_ap_h ap, int *max_speed)
 674 {
 675         __NETWORK_CAPI_FUNC_ENTER__;
 676
 677         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 678
 679         if (_wifi_check_ap_validity(ap) == false || max_speed == NULL) {
 680                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 681                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 682                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 683         }
 684
 685         net_profile_info_s *profile_info = ap;
 686         *max_speed = profile_info->max_rate;
 687
 688         __NETWORK_CAPI_FUNC_EXIT__;
 689
 690         return WIFI_MANAGER_ERROR_NONE;
 691 }
 692
 693 EXPORT_API int wifi_manager_ap_is_favorite(wifi_manager_ap_h ap, bool *favorite)
 694 {
 695         /* __NETWORK_CAPI_FUNC_ENTER__; */
 696
 697         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 698
 699         if (_wifi_check_ap_validity(ap) == false || favorite == NULL) {
 700                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 701                 /* __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE */
 702                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 703         }
 704
 705         net_profile_info_s *profile_info = ap;
 706
 707         if (profile_info->Favourite)
 708                 *favorite = true;
 709         else
 710                 *favorite = false;
 711
 712         /* __NETWORK_CAPI_FUNC_EXIT__; */
 713
 714         return WIFI_MANAGER_ERROR_NONE;
 715 }
 716
 717 EXPORT_API int wifi_manager_ap_is_passpoint(wifi_manager_ap_h ap, bool *passpoint)
 718 {
 719         __NETWORK_CAPI_FUNC_ENTER__;
 720
 721         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 722
 723         if (_wifi_check_ap_validity(ap) == false || passpoint == NULL) {
 724                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 725                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 726                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 727         }
 728
 729         net_profile_info_s *profile_info = ap;
 730
 731         if (profile_info->passpoint)
 732                 *passpoint = true;
 733         else
 734                 *passpoint = false;
 735
 736         __NETWORK_CAPI_FUNC_EXIT__;
 737
 738         return WIFI_MANAGER_ERROR_NONE;
 739 }
 740
 741 EXPORT_API int wifi_manager_ap_get_connection_state(wifi_manager_ap_h ap,
 742                 wifi_manager_connection_state_e *state)
 743 {
 744         /* __NETWORK_CAPI_FUNC_ENTER__; */
 745
 746         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 747
 748         if (_wifi_check_ap_validity(ap) == false || state == NULL) {
 749                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 750                 /* __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE */
 751                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 752         }
 753
 754         net_profile_info_s *profile_info = ap;
 755
 756         *state = _wifi_convert_to_ap_state(profile_info->ProfileState);
 757
 758         if (*state < -1) {
 759                 /* __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE */
 760                 return WIFI_MANAGER_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 761         }
 762
 763         /* __NETWORK_CAPI_FUNC_EXIT__; */
 764
 765         return WIFI_MANAGER_ERROR_NONE;
 766 }
 767
 768 EXPORT_API int wifi_manager_ap_get_ip_config_type(wifi_manager_ap_h ap,
 769                 wifi_manager_address_family_e address_family, wifi_manager_ip_config_type_e *type)
 770 {
 771         __NETWORK_CAPI_FUNC_ENTER__;
 772
 773         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 774         net_ip_config_type_e profileType ;
 775
 776         if (_wifi_check_ap_validity(ap) == false ||
 777             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
 778              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) ||
 779             type == NULL) {
 780                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 781                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 782                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 783         }
 784
 785         net_profile_info_s *profile_info = ap;
 786
 787         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4)
 788                 profileType = profile_info->net_info.IpConfigType ;
 789         else
 790                 profileType = profile_info->net_info.IpConfigType6 ; //LCOV_EXCL_LINE
 791
 792         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) {
 793                 switch (profileType) {
 794                 //LCOV_EXCL_START
 795                 case NET_IP_CONFIG_TYPE_STATIC:
 796                         *type = WIFI_MANAGER_IP_CONFIG_TYPE_STATIC;
 797                         break;
 798
 799                 case NET_IP_CONFIG_TYPE_DYNAMIC:
 800                         *type = WIFI_MANAGER_IP_CONFIG_TYPE_DYNAMIC;
 801                         break;
 802
 803                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 804                         *type = WIFI_MANAGER_IP_CONFIG_TYPE_AUTO;
 805                         break;
 806
 807                 case NET_IP_CONFIG_TYPE_FIXED:
 808                         *type = WIFI_MANAGER_IP_CONFIG_TYPE_FIXED;
 809                         break;
 810
 811                 case NET_IP_CONFIG_TYPE_OFF:
 812                         *type = WIFI_MANAGER_IP_CONFIG_TYPE_NONE;
 813                         break;
 814
 815                 default:
 816                         __NETWORK_CAPI_FUNC_EXIT__;
 817                         return WIFI_MANAGER_ERROR_OPERATION_FAILED;
 818                 //LCOV_EXCL_STOP
 819                 }
 820         } else {
 821                 //LCOV_EXCL_START
 822                 switch (profileType) {
 823                 case NET_IP_CONFIG_TYPE_STATIC:
 824                         *type = WIFI_MANAGER_IP_CONFIG_TYPE_STATIC;
 825                         break;
 826                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 827                         *type = WIFI_MANAGER_IP_CONFIG_TYPE_AUTO;
 828                         break;
 829                 case NET_IP_CONFIG_TYPE_OFF:
 830                         *type = WIFI_MANAGER_IP_CONFIG_TYPE_NONE;
 831                         break;
 832                 default:
 833                         __NETWORK_CAPI_FUNC_EXIT__;
 834                         return WIFI_MANAGER_ERROR_OPERATION_FAILED;
 835                 }
 836                 //LCOV_EXCL_STOP
 837         }
 838
 839         __NETWORK_CAPI_FUNC_EXIT__;
 840
 841         return WIFI_MANAGER_ERROR_NONE;
 842 }
 843
 844 EXPORT_API int wifi_manager_ap_set_ip_config_type(wifi_manager_ap_h ap,
 845                 wifi_manager_address_family_e address_family, wifi_manager_ip_config_type_e type)
 846 {
 847         __NETWORK_CAPI_FUNC_ENTER__;
 848
 849         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 850         net_ip_config_type_e *profileType = NULL;
 851
 852         if (_wifi_check_ap_validity(ap) == false ||
 853             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
 854              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6)) {
 855                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 856                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 857                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 858         }
 859
 860         net_profile_info_s *profile_info = ap;
 861
 862         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4)
 863                 profileType = &profile_info->net_info.IpConfigType ;
 864         else
 865                 profileType = &profile_info->net_info.IpConfigType6 ;
 866
 867         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) {
 868                 //LCOV_EXCL_START
 869                 switch (type) {
 870                 case WIFI_MANAGER_IP_CONFIG_TYPE_STATIC:
 871                         *profileType = NET_IP_CONFIG_TYPE_STATIC;
 872                         profile_info->net_info.IpAddr.Data.Ipv4.s_addr = 0;
 873                         profile_info->net_info.SubnetMask.Data.Ipv4.s_addr = 0;
 874                         profile_info->net_info.GatewayAddr.Data.Ipv4.s_addr = 0 ;
 875                         break;
 876
 877                 case WIFI_MANAGER_IP_CONFIG_TYPE_DYNAMIC:
 878                         *profileType = NET_IP_CONFIG_TYPE_DYNAMIC;
 879                         break;
 880
 881                 case WIFI_MANAGER_IP_CONFIG_TYPE_AUTO:
 882                         *profileType = NET_IP_CONFIG_TYPE_AUTO_IP;
 883                         break;
 884
 885                 case WIFI_MANAGER_IP_CONFIG_TYPE_FIXED:
 886                         *profileType = NET_IP_CONFIG_TYPE_FIXED;
 887                         break;
 888
 889                 case WIFI_MANAGER_IP_CONFIG_TYPE_NONE:
 890                         *profileType = NET_IP_CONFIG_TYPE_OFF;
 891                         break;
 892
 893                 default:
 894                         __NETWORK_CAPI_FUNC_EXIT__;
 895                         return WIFI_MANAGER_ERROR_INVALID_PARAMETER;
 896                 }
 897                 //LCOV_EXCL_STOP
 898         } else {
 899                 //LCOV_EXCL_START
 900                 switch (type) {
 901                 case WIFI_MANAGER_IP_CONFIG_TYPE_STATIC:
 902                         *profileType = NET_IP_CONFIG_TYPE_STATIC;
 903                         inet_pton(AF_INET6, "::", &profile_info->net_info.IpAddr6.Data.Ipv6);
 904                         profile_info->net_info.PrefixLen6 = 0 ;
 905                         inet_pton(AF_INET6, "::", &profile_info->net_info.GatewayAddr6.Data.Ipv6);
 906                         break;
 907                 case WIFI_MANAGER_IP_CONFIG_TYPE_AUTO:
 908                         *profileType = NET_IP_CONFIG_TYPE_AUTO_IP;
 909                         break;
 910                 case WIFI_MANAGER_IP_CONFIG_TYPE_NONE:
 911                         *profileType = NET_IP_CONFIG_TYPE_OFF;
 912                         break;
 913                 default:
 914                         __NETWORK_CAPI_FUNC_EXIT__;
 915                         return WIFI_MANAGER_ERROR_INVALID_PARAMETER;
 916                 }
 917                 //LCOV_EXCL_STOP
 918         }
 919
 920         __NETWORK_CAPI_FUNC_EXIT__;
 921
 922         return WIFI_MANAGER_ERROR_NONE;
 923 }
 924
 925 EXPORT_API int wifi_manager_ap_get_ip_address(wifi_manager_ap_h ap,
 926                 wifi_manager_address_family_e address_family, char **ip_address)
 927 {
 928         __NETWORK_CAPI_FUNC_ENTER__;
 929
 930         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 931
 932         if (_wifi_check_ap_validity(ap) == false ||
 933             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
 934              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) ||
 935             ip_address == NULL) {
 936                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 937                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 938                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 939         }
 940
 941         net_profile_info_s *profile_info = ap;
 942         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) {
 943                 *ip_address = __ap_convert_ip_to_string(
 944                                 &profile_info->net_info.IpAddr,
 945                                 address_family);
 946                 if (g_strcmp0(*ip_address, "0.0.0.0") == 0) {
 947                         WIFI_LOG(WIFI_ERROR, "Invalid IP Address [%s]", *ip_address); //LCOV_EXCL_LINE
 948                         __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 949                         return WIFI_MANAGER_ERROR_NO_CONNECTION; //LCOV_EXCL_LINE
 950                 }
 951         } else if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV6) {
 952                 if (net_get_preferred_ipv6_address(profile_info->network_info,
 953                                 profile_info->ProfileName, ip_address) != NET_ERR_NONE) {
 954                         WIFI_LOG(WIFI_ERROR, "Failed to get preferred ipv6 address");
 955                         *ip_address = __ap_convert_ip_to_string(
 956                                         &profile_info->net_info.IpAddr6,
 957                                         address_family);
 958                 }
 959         }
 960
 961         if (*ip_address == NULL) {
 962                 WIFI_LOG(WIFI_ERROR, "Out of memory"); //LCOV_EXCL_LINE
 963                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 964                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 965         }
 966
 967         WIFI_LOG(WIFI_INFO, "Wi-Fi IP Address [%s]", *ip_address);
 968
 969         __NETWORK_CAPI_FUNC_EXIT__;
 970         return WIFI_MANAGER_ERROR_NONE;
 971 }
 972
 973 EXPORT_API int wifi_manager_ap_set_ip_address(wifi_manager_ap_h ap,
 974                 wifi_manager_address_family_e address_family, const char *ip_address)
 975 {
 976         __NETWORK_CAPI_FUNC_ENTER__;
 977
 978         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 979
 980         if (_wifi_check_ap_validity(ap) == false ||
 981             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
 982              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6)) {
 983                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 984                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
 985                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 986         }
 987
 988         net_profile_info_s *profile_info = ap;
 989
 990         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) {
 991                 if (ip_address == NULL)
 992                         profile_info->net_info.IpAddr.Data.Ipv4.s_addr = 0;
 993                 else if (inet_aton(ip_address,
 994                                 &(profile_info->net_info.IpAddr.Data.Ipv4)) == 0) {
 995                         __NETWORK_CAPI_FUNC_EXIT__;
 996                         return WIFI_MANAGER_ERROR_INVALID_PARAMETER;
 997                 }
 998         } else {
 999                 //LCOV_EXCL_START
1000                 if (ip_address == NULL)
1001                         inet_pton(AF_INET6, "::",
1002                                 &profile_info->net_info.IpAddr6.Data.Ipv6);
1003                 else if (inet_pton(AF_INET6, ip_address,
1004                                 &profile_info->net_info.IpAddr6.Data.Ipv6) == 0) {
1005                         __NETWORK_CAPI_FUNC_EXIT__;
1006                         return WIFI_MANAGER_ERROR_INVALID_PARAMETER;
1007                 }
1008                 //LCOV_EXCL_STOP
1009         }
1010
1011         __NETWORK_CAPI_FUNC_EXIT__;
1012
1013         return WIFI_MANAGER_ERROR_NONE;
1014 }
1015
1016 EXPORT_API int wifi_manager_ap_get_subnet_mask(wifi_manager_ap_h ap,
1017                 wifi_manager_address_family_e address_family, char **subnet_mask)
1018 {
1019         __NETWORK_CAPI_FUNC_ENTER__;
1020
1021         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1022         char* prefixlen;
1023
1024         if (_wifi_check_ap_validity(ap) == false ||
1025             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
1026              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) ||
1027             subnet_mask == NULL) {
1028                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1029                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1030                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1031         }
1032
1033         net_profile_info_s *profile_info = ap;
1034         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4)
1035                 *subnet_mask = __ap_convert_ip_to_string(
1036                         &profile_info->net_info.SubnetMask,
1037                         address_family);
1038         else {
1039                 //LCOV_EXCL_START
1040                 prefixlen = g_try_malloc0(MAX_PREFIX_LENGTH);
1041                 if (prefixlen != NULL) {
1042                         snprintf(prefixlen, MAX_PREFIX_LENGTH, "%d",
1043                                 profile_info->net_info.PrefixLen6);
1044                         *subnet_mask = prefixlen;
1045                 } else
1046                         *subnet_mask = NULL;
1047                 //LCOV_EXCL_STOP
1048         }
1049
1050         if (*subnet_mask == NULL) {
1051                 __NETWORK_CAPI_FUNC_EXIT__;
1052                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1053         }
1054
1055         __NETWORK_CAPI_FUNC_EXIT__;
1056
1057         return WIFI_MANAGER_ERROR_NONE;
1058 }
1059
1060 EXPORT_API int wifi_manager_ap_set_subnet_mask(wifi_manager_ap_h ap,
1061                 wifi_manager_address_family_e address_family, const char *subnet_mask)
1062 {
1063         __NETWORK_CAPI_FUNC_ENTER__;
1064
1065         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1066
1067         if (_wifi_check_ap_validity(ap) == false ||
1068             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
1069              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6)) {
1070                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1071                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1072                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1073         }
1074
1075         net_profile_info_s *profile_info = ap;
1076
1077         /* Based on the family of address provided subnet mask should be set.
1078          * For IPv6 address subnet mask is prefix length, an integer,  while for
1079          * Ipv6 address subnet mask is a ipv6 address.
1080          */
1081         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV6) {
1082                 //LCOV_EXCL_START
1083                 if (subnet_mask == NULL)
1084                         profile_info->net_info.PrefixLen6 = 0;
1085                 else {
1086                         /* subnet mask provided as input parameter is a string
1087                          * while for IPv6 address subnet mask in prefix length
1088                          * which should be in integer form */
1089                         long val;
1090                         char *endptr;
1091
1092                         errno = 0;
1093
1094                         val = strtol(subnet_mask, &endptr, 10);
1095                         if ((errno == ERANGE && (val == LONG_MAX || val == LONG_MIN))
1096                                         || (errno != 0 && val == 0)) {
1097                                 WIFI_LOG(WIFI_ERROR, "invalid subnet mask");
1098                                 __NETWORK_CAPI_FUNC_EXIT__;
1099                                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER;
1100                         }
1101
1102                         if (endptr == subnet_mask) {
1103                                 WIFI_LOG(WIFI_ERROR, "invalid subnet mask");
1104                                 __NETWORK_CAPI_FUNC_EXIT__;
1105                                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER;
1106                         }
1107
1108                         if (*endptr != '\0')
1109                                 WIFI_LOG(WIFI_WARN, "Further characters after number in subnet_mask: %s\n", endptr);
1110
1111                         if (val < 0 || val > 128) {
1112                                 WIFI_LOG(WIFI_ERROR, "invalid subnet mask");
1113                                 __NETWORK_CAPI_FUNC_EXIT__;
1114                                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER;
1115                         }
1116
1117                         profile_info->net_info.PrefixLen6 = val;
1118                 }
1119                 //LCOV_EXCL_STOP
1120         } else {
1121                 if (subnet_mask == NULL)
1122                         profile_info->net_info.SubnetMask.Data.Ipv4.s_addr = 0;
1123                 else if (inet_pton(AF_INET, subnet_mask,
1124                                 &(profile_info->net_info.SubnetMask.Data.Ipv4)) < 1) {
1125                         __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1126                         return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1127                 }
1128
1129                 profile_info->net_info.PrefixLen = __ap_convert_netmask_to_prefix_len(subnet_mask);
1130         }
1131
1132         __NETWORK_CAPI_FUNC_EXIT__;
1133
1134         return WIFI_MANAGER_ERROR_NONE;
1135 }
1136
1137 EXPORT_API int wifi_manager_ap_get_prefix_length(wifi_manager_ap_h ap,
1138                 wifi_manager_address_family_e address_family, int *prefix_len)
1139 {
1140         __NETWORK_CAPI_FUNC_ENTER__;
1141
1142         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1143
1144         if (_wifi_check_ap_validity(ap) == false ||
1145             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
1146              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) ||
1147             prefix_len == NULL) {
1148                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1149                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1150                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1151         }
1152
1153         net_profile_info_s *profile_info = ap;
1154
1155         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4)
1156                 *prefix_len = profile_info->net_info.PrefixLen;
1157         else if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV6)
1158                 *prefix_len = profile_info->net_info.PrefixLen6;
1159
1160         __NETWORK_CAPI_FUNC_EXIT__;
1161
1162         return WIFI_MANAGER_ERROR_NONE;
1163 }
1164
1165 EXPORT_API int wifi_manager_ap_set_prefix_length(wifi_manager_ap_h ap,
1166                 wifi_manager_address_family_e address_family, int prefix_len)
1167 {
1168         __NETWORK_CAPI_FUNC_ENTER__;
1169
1170         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1171
1172         if (_wifi_check_ap_validity(ap) == false ||
1173             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
1174              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6)) {
1175                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1176                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1177                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1178         }
1179
1180         net_profile_info_s *profile_info = ap;
1181
1182         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) {
1183                 profile_info->net_info.PrefixLen = prefix_len;
1184                 profile_info->net_info.SubnetMask.Data.Ipv4.s_addr =
1185                         __ap_convert_prefix_len_to_netmask(prefix_len);
1186         } else if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV6)
1187                 profile_info->net_info.PrefixLen6 = prefix_len;
1188
1189         __NETWORK_CAPI_FUNC_EXIT__;
1190
1191         return WIFI_MANAGER_ERROR_NONE;
1192 }
1193
1194 EXPORT_API int wifi_manager_ap_get_gateway_address(wifi_manager_ap_h ap,
1195                 wifi_manager_address_family_e address_family, char **gateway_address)
1196 {
1197         __NETWORK_CAPI_FUNC_ENTER__;
1198
1199         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1200
1201         if (_wifi_check_ap_validity(ap) == false ||
1202             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
1203              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) ||
1204             gateway_address == NULL) {
1205                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1206                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1207                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1208         }
1209
1210         net_profile_info_s *profile_info = ap;
1211
1212         /* Based on the family of address provided, gateway should be set.
1213          * For IPv6 address gateway is of form GatewayAddr6 but for IPv4
1214          * gateway is of form GatewayAddr.
1215          */
1216         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4)
1217                 *gateway_address = __ap_convert_ip_to_string(
1218                         &profile_info->net_info.GatewayAddr,
1219                         address_family);
1220         else
1221                 *gateway_address = __ap_convert_ip_to_string( //LCOV_EXCL_LINE
1222                         &profile_info->net_info.GatewayAddr6,
1223                         address_family);
1224
1225         if (*gateway_address == NULL) {
1226                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1227                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1228         }
1229
1230         __NETWORK_CAPI_FUNC_EXIT__;
1231
1232         return WIFI_MANAGER_ERROR_NONE;
1233 }
1234
1235 EXPORT_API int wifi_manager_ap_set_gateway_address(wifi_manager_ap_h ap,
1236                 wifi_manager_address_family_e address_family, const char *gateway_address)
1237 {
1238         __NETWORK_CAPI_FUNC_ENTER__;
1239
1240         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1241
1242         if (_wifi_check_ap_validity(ap) == false ||
1243             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
1244              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6)) {
1245                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1246                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1247                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1248         }
1249
1250         net_profile_info_s *profile_info = ap;
1251         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV6) {
1252                 //LCOV_EXCL_START
1253                 if (gateway_address == NULL)
1254                         inet_pton(AF_INET6, "::",
1255                                 &profile_info->net_info.GatewayAddr6.Data.Ipv6);
1256                 else if (inet_pton(AF_INET6, gateway_address,
1257                                 &profile_info->net_info.GatewayAddr6.Data.Ipv6) < 1) {
1258                                 __NETWORK_CAPI_FUNC_EXIT__;
1259                         return WIFI_MANAGER_ERROR_INVALID_PARAMETER;
1260                 }
1261                 //LCOV_EXCL_STOP
1262         } else {
1263                 if (gateway_address == NULL)
1264                         profile_info->net_info.GatewayAddr.Data.Ipv4.s_addr = 0;
1265                 else if (inet_pton(AF_INET, gateway_address,
1266                                 &profile_info->net_info.GatewayAddr.Data.Ipv4) < 1) {
1267                         __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1268                         return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1269                 }
1270         }
1271
1272         __NETWORK_CAPI_FUNC_EXIT__;
1273
1274         return WIFI_MANAGER_ERROR_NONE;
1275 }
1276
1277
1278 EXPORT_API int wifi_manager_ap_get_dhcp_server_address(wifi_manager_ap_h ap,
1279                 wifi_manager_address_family_e address_family, char** dhcp_server)
1280 {
1281         __NETWORK_CAPI_FUNC_ENTER__;
1282
1283         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1284
1285         if (_wifi_check_ap_validity(ap) == false ||
1286             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
1287              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) ||
1288             dhcp_server == NULL) {
1289                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1290                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1291                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1292         }
1293
1294         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV6) {
1295                 WIFI_LOG(WIFI_ERROR, "Not supported"); //LCOV_EXCL_LINE
1296                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1297                 return WIFI_MANAGER_ERROR_NOT_SUPPORTED; //LCOV_EXCL_LINE
1298         }
1299
1300         net_profile_info_s *profile_info = ap;
1301
1302         WIFI_LOG(WIFI_INFO, "IP Config %d, DHCP Server Address %s",
1303                         profile_info->net_info.IpConfigType,
1304                         profile_info->net_info.BServerAddr ? "TRUE" : "FALSE");
1305
1306         *dhcp_server = __ap_convert_ip_to_string(
1307                         &profile_info->net_info.ServerAddr,
1308                         address_family);
1309
1310         if (*dhcp_server == NULL) {
1311                 WIFI_LOG(WIFI_ERROR, "Out of memory"); //LCOV_EXCL_LINE
1312                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1313                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1314         }
1315
1316         __NETWORK_CAPI_FUNC_EXIT__;
1317
1318         return WIFI_MANAGER_ERROR_NONE;
1319 }
1320
1321
1322 EXPORT_API int wifi_manager_ap_get_dhcp_lease_duration(wifi_manager_ap_h ap,
1323                 wifi_manager_address_family_e address_family, int* dhcp_lease_duration)
1324 {
1325         __NETWORK_CAPI_FUNC_ENTER__;
1326
1327         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1328
1329         if (_wifi_check_ap_validity(ap) == false ||
1330             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
1331              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) ||
1332                 dhcp_lease_duration == NULL) {
1333                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1334                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1335                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1336         }
1337
1338         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV6) {
1339                 WIFI_LOG(WIFI_ERROR, "Not supported"); //LCOV_EXCL_LINE
1340                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1341                 return WIFI_MANAGER_ERROR_NOT_SUPPORTED; //LCOV_EXCL_LINE
1342         }
1343
1344         net_profile_info_s *profile_info = ap;
1345         net_dev_info_s *net_info = &profile_info->net_info;
1346
1347         WIFI_LOG(WIFI_INFO, "DHCP lease duration %d", net_info->DHCPLeaseDuration);
1348
1349         *dhcp_lease_duration = net_info->DHCPLeaseDuration;
1350
1351         __NETWORK_CAPI_FUNC_EXIT__;
1352
1353         return WIFI_MANAGER_ERROR_NONE;
1354 }
1355
1356 EXPORT_API int wifi_manager_ap_get_proxy_address(wifi_manager_ap_h ap,
1357                 wifi_manager_address_family_e address_family, char **proxy_address)
1358 {
1359         __NETWORK_CAPI_FUNC_ENTER__;
1360
1361         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1362
1363         if (_wifi_check_ap_validity(ap) == false ||
1364             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
1365              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) ||
1366             proxy_address == NULL) {
1367                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1368                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1369                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1370         }
1371
1372         net_profile_info_s *profile_info = ap;
1373         *proxy_address = g_strdup(profile_info->net_info.ProxyAddr);
1374         if (*proxy_address == NULL) {
1375                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1376                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1377         }
1378
1379         __NETWORK_CAPI_FUNC_EXIT__;
1380
1381         return WIFI_MANAGER_ERROR_NONE;
1382 }
1383
1384 EXPORT_API int wifi_manager_ap_set_proxy_address(wifi_manager_ap_h ap,
1385                 wifi_manager_address_family_e address_family, const char *proxy_address)
1386 {
1387         __NETWORK_CAPI_FUNC_ENTER__;
1388
1389         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1390
1391         if (_wifi_check_ap_validity(ap) == false ||
1392             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
1393              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6)) {
1394                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1395                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1396                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1397         }
1398
1399         net_profile_info_s *profile_info = ap;
1400
1401         if (proxy_address == NULL)
1402                 profile_info->net_info.ProxyAddr[0] = '\0';
1403         else
1404                 g_strlcpy(profile_info->net_info.ProxyAddr,
1405                                 proxy_address, NET_PROXY_LEN_MAX+1);
1406
1407         __NETWORK_CAPI_FUNC_EXIT__;
1408
1409         return WIFI_MANAGER_ERROR_NONE;
1410 }
1411
1412 EXPORT_API int wifi_manager_ap_get_proxy_type(wifi_manager_ap_h ap,
1413                 wifi_manager_proxy_type_e *proxy_type)
1414 {
1415         __NETWORK_CAPI_FUNC_ENTER__;
1416
1417         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1418
1419         if (_wifi_check_ap_validity(ap) == false || proxy_type == NULL) {
1420                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1421                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1422                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1423         }
1424
1425         net_profile_info_s *profile_info = ap;
1426
1427         //LCOV_EXCL_START
1428         switch (profile_info->net_info.ProxyMethod) {
1429         case NET_PROXY_TYPE_DIRECT:
1430                 *proxy_type = WIFI_MANAGER_PROXY_TYPE_DIRECT;
1431                 break;
1432         case NET_PROXY_TYPE_AUTO:
1433                 *proxy_type = WIFI_MANAGER_PROXY_TYPE_AUTO;
1434                 break;
1435         case NET_PROXY_TYPE_MANUAL:
1436                 *proxy_type = WIFI_MANAGER_PROXY_TYPE_MANUAL;
1437                 break;
1438         case NET_PROXY_TYPE_UNKNOWN:
1439                 *proxy_type = WIFI_MANAGER_PROXY_TYPE_DIRECT;
1440                 break;
1441         default:
1442                 __NETWORK_CAPI_FUNC_EXIT__;
1443                 return WIFI_MANAGER_ERROR_OPERATION_FAILED;
1444         }
1445         //LCOV_EXCL_STOP
1446
1447         __NETWORK_CAPI_FUNC_EXIT__;
1448
1449         return WIFI_MANAGER_ERROR_NONE;
1450 }
1451
1452 EXPORT_API int wifi_manager_ap_set_proxy_type(wifi_manager_ap_h ap,
1453                 wifi_manager_proxy_type_e proxy_type)
1454 {
1455         __NETWORK_CAPI_FUNC_ENTER__;
1456
1457         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1458
1459         if (_wifi_check_ap_validity(ap) == false) {
1460                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1461                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1462                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1463         }
1464
1465         net_profile_info_s *profile_info = ap;
1466
1467         //LCOV_EXCL_START
1468         switch (proxy_type) {
1469         case WIFI_MANAGER_PROXY_TYPE_DIRECT:
1470                 profile_info->net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
1471                 break;
1472         case WIFI_MANAGER_PROXY_TYPE_AUTO:
1473                 profile_info->net_info.ProxyAddr[0] = '\0';
1474                 profile_info->net_info.ProxyMethod = NET_PROXY_TYPE_AUTO;
1475                 break;
1476         case WIFI_MANAGER_PROXY_TYPE_MANUAL:
1477                 profile_info->net_info.ProxyAddr[0] = '\0';
1478                 profile_info->net_info.ProxyMethod = NET_PROXY_TYPE_MANUAL;
1479                 g_strlcpy(profile_info->net_info.ProxyAddr, "0.0.0.0:8080", 15);
1480                 break;
1481         default:
1482                 __NETWORK_CAPI_FUNC_EXIT__;
1483                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER;
1484         }
1485         //LCOV_EXCL_STOP
1486
1487         __NETWORK_CAPI_FUNC_EXIT__;
1488
1489         return WIFI_MANAGER_ERROR_NONE;
1490 }
1491
1492 EXPORT_API int wifi_manager_ap_get_dns_config_type(wifi_manager_ap_h ap,
1493                 wifi_manager_address_family_e address_family, wifi_manager_dns_config_type_e *type)
1494 {
1495         __NETWORK_CAPI_FUNC_ENTER__;
1496
1497         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1498
1499         if (_wifi_check_ap_validity(ap) == false ||
1500             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
1501              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) || type == NULL) {
1502                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1503                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1504                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1505         }
1506
1507         net_profile_info_s *profile_info = ap;
1508         net_dns_config_type_e dns_type;
1509
1510         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4)
1511                 dns_type = profile_info->net_info.DnsConfigType;
1512         else
1513                 dns_type = profile_info->net_info.DnsConfigType6;
1514
1515         switch (dns_type) {
1516         case NET_DNS_CONFIG_TYPE_STATIC:
1517                 *type = WIFI_MANAGER_DNS_CONFIG_TYPE_STATIC;
1518                 break;
1519         case NET_DNS_CONFIG_TYPE_DYNAMIC:
1520                 *type = WIFI_MANAGER_DNS_CONFIG_TYPE_DYNAMIC;
1521                 break;
1522         default:
1523                 *type = WIFI_MANAGER_DNS_CONFIG_TYPE_NONE;
1524                 break;
1525         }
1526
1527         __NETWORK_CAPI_FUNC_EXIT__;
1528
1529         return WIFI_MANAGER_ERROR_NONE;
1530 }
1531
1532 EXPORT_API int wifi_manager_ap_set_dns_config_type(wifi_manager_ap_h ap,
1533                 wifi_manager_address_family_e address_family, wifi_manager_dns_config_type_e type)
1534 {
1535         __NETWORK_CAPI_FUNC_ENTER__;
1536
1537         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1538
1539         if (_wifi_check_ap_validity(ap) == false ||
1540             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
1541              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) ||
1542                 (type != WIFI_MANAGER_DNS_CONFIG_TYPE_STATIC &&
1543                  type != WIFI_MANAGER_DNS_CONFIG_TYPE_DYNAMIC)) {
1544                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1545                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1546                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1547         }
1548
1549         net_profile_info_s *profile_info = ap;
1550         net_dns_config_type_e *dns_type;
1551
1552         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4) {
1553                 dns_type = &profile_info->net_info.DnsConfigType;
1554
1555                 profile_info->net_info.DnsAddr[0].Data.Ipv4.s_addr = 0;
1556                 profile_info->net_info.DnsAddr[1].Data.Ipv4.s_addr = 0;
1557
1558                 *dns_type = type;
1559         } else {
1560                 dns_type = &profile_info->net_info.DnsConfigType6;
1561
1562                 inet_pton(AF_INET6, "::",
1563                                 &profile_info->net_info.DnsAddr6[0].Data.Ipv6);
1564                 inet_pton(AF_INET6, "::",
1565                                 &profile_info->net_info.DnsAddr6[1].Data.Ipv6);
1566
1567                 *dns_type = type;
1568         }
1569
1570         __NETWORK_CAPI_FUNC_EXIT__;
1571
1572         return WIFI_MANAGER_ERROR_NONE;
1573 }
1574
1575 EXPORT_API int wifi_manager_ap_get_dns_address(wifi_manager_ap_h ap,
1576                 int order, wifi_manager_address_family_e address_family, char **dns_address)
1577 {
1578         __NETWORK_CAPI_FUNC_ENTER__;
1579
1580         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1581
1582         if (_wifi_check_ap_validity(ap) == false ||
1583             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
1584              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) ||
1585             dns_address == NULL ||
1586             order <= 0 ||
1587             order > NET_DNS_ADDR_MAX) {
1588                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1589                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1590                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1591         }
1592
1593         net_profile_info_s *profile_info = ap;
1594
1595         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV4)
1596                 *dns_address = __ap_convert_ip_to_string(
1597                                 &profile_info->net_info.DnsAddr[order-1],
1598                                 address_family);
1599         else
1600                 *dns_address = __ap_convert_ip_to_string( //LCOV_EXCL_LINE
1601                                 &profile_info->net_info.DnsAddr6[order-1],
1602                                 address_family);
1603
1604         if (*dns_address == NULL) {
1605                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1606                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1607         }
1608
1609         __NETWORK_CAPI_FUNC_EXIT__;
1610
1611         return WIFI_MANAGER_ERROR_NONE;
1612 }
1613
1614 EXPORT_API int wifi_manager_ap_set_dns_address(wifi_manager_ap_h ap,
1615                 int order, wifi_manager_address_family_e address_family, const char *dns_address)
1616 {
1617         __NETWORK_CAPI_FUNC_ENTER__;
1618
1619         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1620
1621         if (_wifi_check_ap_validity(ap) == false ||
1622             (address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV4 &&
1623              address_family != WIFI_MANAGER_ADDRESS_FAMILY_IPV6) ||
1624             order <= 0 ||
1625             order > NET_DNS_ADDR_MAX) {
1626                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1627                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1628                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1629         }
1630
1631         net_profile_info_s *profile_info = ap;
1632
1633         if (address_family == WIFI_MANAGER_ADDRESS_FAMILY_IPV6) {
1634                 //LCOV_EXCL_START
1635                 profile_info->net_info.DnsAddr6[order-1].Type =
1636                         NET_ADDR_IPV6;
1637                 if (dns_address == NULL)
1638                         inet_pton(AF_INET6, "::",
1639                                         &profile_info->net_info.DnsAddr6[order-1].Data.Ipv6);
1640                 else if (inet_pton(AF_INET6, dns_address,
1641                                         &profile_info->net_info.DnsAddr6[order-1].Data.Ipv6) < 1) {
1642                         __NETWORK_CAPI_FUNC_EXIT__;
1643                         return WIFI_MANAGER_ERROR_INVALID_PARAMETER;
1644                 }
1645
1646                 if (profile_info->net_info.DnsCount6 < order)
1647                         profile_info->net_info.DnsCount6 = order;
1648                 //LCOV_EXCL_STOP
1649         } else {
1650                 profile_info->net_info.DnsAddr[order-1].Type =
1651                         NET_ADDR_IPV4;
1652                 if (dns_address == NULL)
1653                         profile_info->net_info.DnsAddr[order-1].Data.Ipv4.s_addr = 0;
1654                 else if (inet_pton(AF_INET, dns_address,
1655                                         &(profile_info->net_info.DnsAddr[order-1].Data.Ipv4)) < 1) {
1656                         __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1657                         return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1658                 }
1659
1660                 if (profile_info->net_info.DnsCount < order)
1661                         profile_info->net_info.DnsCount = order;
1662         }
1663
1664         __NETWORK_CAPI_FUNC_EXIT__;
1665
1666         return WIFI_MANAGER_ERROR_NONE;
1667 }
1668
1669 EXPORT_API int wifi_manager_ap_get_countrycode(wifi_manager_ap_h ap,
1670                                                char **country_code)
1671 {
1672         __NETWORK_CAPI_FUNC_ENTER__;
1673
1674         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1675
1676         if (_wifi_check_ap_validity(ap) == false || country_code == NULL) {
1677                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1678                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1679                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1680         }
1681
1682         net_profile_info_s *profile_info = ap;
1683         if (profile_info->country_code[0] != '\0') {
1684                 *country_code = strdup(profile_info->country_code);
1685                 if (*country_code == NULL) {
1686                         __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1687                         return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1688                 }
1689         } else
1690                 *country_code = NULL;
1691
1692         __NETWORK_CAPI_FUNC_EXIT__;
1693
1694         return WIFI_MANAGER_ERROR_NONE;
1695 }
1696
1697 EXPORT_API int wifi_manager_foreach_found_bssid(wifi_manager_ap_h ap,
1698                                                 wifi_manager_found_bssid_cb callback, void *user_data)
1699 {
1700         __NETWORK_CAPI_FUNC_ENTER__;
1701
1702         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1703
1704         if (_wifi_check_ap_validity(ap) == false || callback == NULL) {
1705                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1706                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1707                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1708         }
1709
1710         net_profile_info_s *profile_info = ap;
1711
1712         bool rv;
1713         GSList *list;
1714         for (list = profile_info->bssid_list; list; list = list->next) {
1715                 net_profile_bssid_list_s *bssid_list = (net_profile_bssid_list_s *)list->data;
1716
1717                 rv = callback((const char *)bssid_list->bssid, (bssid_list->strength - 120), bssid_list->frequency, user_data);
1718                 if (rv == false)
1719                         break;
1720         }
1721
1722         __NETWORK_CAPI_FUNC_EXIT__;
1723         return WIFI_MANAGER_ERROR_NONE;
1724 }
1725
1726 /* Wi-Fi security information ************************************************/
1727 EXPORT_API int wifi_manager_ap_get_security_type(wifi_manager_ap_h ap,
1728                 wifi_manager_security_type_e *type)
1729 {
1730         /* __NETWORK_CAPI_FUNC_ENTER__; */
1731
1732         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1733
1734         if (_wifi_check_ap_validity(ap) == false || type == NULL) {
1735                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1736                 /* __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE */
1737                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1738         }
1739
1740         net_profile_info_s *profile_info = ap;
1741
1742         //LCOV_EXCL_START
1743         switch (profile_info->security_info.sec_mode) {
1744         case WLAN_SEC_MODE_NONE:
1745                 *type = WIFI_MANAGER_SECURITY_TYPE_NONE;
1746                 break;
1747         case WLAN_SEC_MODE_WEP:
1748                 *type = WIFI_MANAGER_SECURITY_TYPE_WEP;
1749                 break;
1750         case WLAN_SEC_MODE_IEEE8021X:
1751                 *type = WIFI_MANAGER_SECURITY_TYPE_EAP;
1752                 break;
1753         case WLAN_SEC_MODE_WPA_PSK:
1754                 *type = WIFI_MANAGER_SECURITY_TYPE_WPA_PSK;
1755                 break;
1756         case WLAN_SEC_MODE_WPA2_PSK:
1757                 *type = WIFI_MANAGER_SECURITY_TYPE_WPA2_PSK;
1758                 break;
1759         case WLAN_SEC_MODE_WPA_FT_PSK:
1760                 *type = WIFI_MANAGER_SECURITY_TYPE_WPA_FT_PSK;
1761                 break;
1762         case WLAN_SEC_MODE_SAE:
1763                 *type = WIFI_MANAGER_SECURITY_TYPE_SAE;
1764                 break;
1765         case WLAN_SEC_MODE_OWE:
1766                 *type = WIFI_MANAGER_SECURITY_TYPE_OWE;
1767                 break;
1768         case WLAN_SEC_MODE_DPP:
1769                 *type = WIFI_MANAGER_SECURITY_TYPE_DPP;
1770                 break;
1771         default:
1772                 /* __NETWORK_CAPI_FUNC_EXIT__; */
1773                 return WIFI_MANAGER_ERROR_OPERATION_FAILED;
1774         }
1775         //LCOV_EXCL_STOP
1776
1777         /* __NETWORK_CAPI_FUNC_EXIT__; */
1778
1779         return WIFI_MANAGER_ERROR_NONE;
1780 }
1781
1782 EXPORT_API int wifi_manager_ap_set_security_type(wifi_manager_ap_h ap,
1783                 wifi_manager_security_type_e type)
1784 {
1785         __NETWORK_CAPI_FUNC_ENTER__;
1786
1787         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1788
1789         if (_wifi_check_ap_validity(ap) == false) {
1790                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1791                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1792                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1793         }
1794
1795         net_profile_info_s *profile_info = ap;
1796
1797         //LCOV_EXCL_START
1798         switch (type) {
1799         case WIFI_MANAGER_SECURITY_TYPE_NONE:
1800                 profile_info->security_info.sec_mode = WLAN_SEC_MODE_NONE;
1801                 break;
1802         case WIFI_MANAGER_SECURITY_TYPE_WEP:
1803                 profile_info->security_info.sec_mode = WLAN_SEC_MODE_WEP;
1804                 break;
1805         case WIFI_MANAGER_SECURITY_TYPE_EAP:
1806                 profile_info->security_info.sec_mode = WLAN_SEC_MODE_IEEE8021X;
1807                 break;
1808         case WIFI_MANAGER_SECURITY_TYPE_WPA_PSK:
1809                 profile_info->security_info.sec_mode = WLAN_SEC_MODE_WPA_PSK;
1810                 break;
1811         case WIFI_MANAGER_SECURITY_TYPE_WPA2_PSK:
1812                 profile_info->security_info.sec_mode = WLAN_SEC_MODE_WPA2_PSK;
1813                 break;
1814         case WIFI_MANAGER_SECURITY_TYPE_WPA_FT_PSK:
1815                 profile_info->security_info.sec_mode = WLAN_SEC_MODE_WPA_FT_PSK;
1816                 break;
1817         case WIFI_MANAGER_SECURITY_TYPE_SAE:
1818                 profile_info->security_info.sec_mode = WLAN_SEC_MODE_SAE;
1819                 break;
1820         case WIFI_MANAGER_SECURITY_TYPE_OWE:
1821                 profile_info->security_info.sec_mode = WLAN_SEC_MODE_OWE;
1822                 break;
1823         case WIFI_MANAGER_SECURITY_TYPE_DPP:
1824                 profile_info->security_info.sec_mode = WLAN_SEC_MODE_DPP;
1825                 break;
1826         default:
1827                 __NETWORK_CAPI_FUNC_EXIT__;
1828                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER;
1829         }
1830         //LCOV_EXCL_STOP
1831
1832         _wifi_set_profile_name_to_ap(profile_info);
1833
1834         __NETWORK_CAPI_FUNC_EXIT__;
1835
1836         return WIFI_MANAGER_ERROR_NONE;
1837 }
1838
1839
1840 EXPORT_API int wifi_manager_ap_is_security_type_supported(wifi_manager_ap_h ap,
1841                                         wifi_manager_security_type_e type, bool *supported)
1842 {
1843         /* __NETWORK_CAPI_FUNC_ENTER__; */
1844
1845         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1846
1847         if (_wifi_check_ap_validity(ap) == false ||
1848                         supported == NULL ||
1849                         type < WIFI_MANAGER_SECURITY_TYPE_NONE ||
1850                         type > WIFI_MANAGER_SECURITY_TYPE_DPP) {
1851                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1852                 /* __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE */
1853                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1854         }
1855
1856         net_profile_info_s *profile_info = ap;
1857
1858         if (profile_info->security_info.sec_list[type])
1859                 *supported = true;
1860         else
1861                 *supported = false;
1862
1863         /* __NETWORK_CAPI_FUNC_EXIT__; */
1864
1865         return WIFI_MANAGER_ERROR_NONE;
1866 }
1867
1868 EXPORT_API int wifi_manager_ap_get_encryption_type(wifi_manager_ap_h ap,
1869                 wifi_manager_encryption_type_e *type)
1870 {
1871         __NETWORK_CAPI_FUNC_ENTER__;
1872
1873         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1874
1875         if (_wifi_check_ap_validity(ap) == false || type == NULL) {
1876                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1877                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1878                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1879         }
1880
1881         net_profile_info_s *profile_info = ap;
1882
1883         //LCOV_EXCL_START
1884         switch (profile_info->security_info.enc_mode) {
1885         case WLAN_ENC_MODE_NONE:
1886                 *type = WIFI_MANAGER_ENCRYPTION_TYPE_NONE;
1887                 break;
1888         case WLAN_ENC_MODE_WEP:
1889                 *type = WIFI_MANAGER_ENCRYPTION_TYPE_WEP;
1890                 break;
1891         case WLAN_ENC_MODE_TKIP:
1892                 *type = WIFI_MANAGER_ENCRYPTION_TYPE_TKIP;
1893                 break;
1894         case WLAN_ENC_MODE_AES:
1895                 *type = WIFI_MANAGER_ENCRYPTION_TYPE_AES;
1896                 break;
1897         case WLAN_ENC_MODE_TKIP_AES_MIXED:
1898                 *type = WIFI_MANAGER_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1899                 break;
1900         default:
1901                 __NETWORK_CAPI_FUNC_EXIT__;
1902                 return WIFI_MANAGER_ERROR_OPERATION_FAILED;
1903         }
1904         //LCOV_EXCL_STOP
1905
1906         __NETWORK_CAPI_FUNC_EXIT__;
1907
1908         return WIFI_MANAGER_ERROR_NONE;
1909 }
1910
1911 EXPORT_API int wifi_manager_ap_set_encryption_type(wifi_manager_ap_h ap,
1912                 wifi_manager_encryption_type_e type)
1913 {
1914         __NETWORK_CAPI_FUNC_ENTER__;
1915
1916         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1917
1918         if (_wifi_check_ap_validity(ap) == false) {
1919                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1920                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1921                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1922         }
1923
1924         net_profile_info_s *profile_info = ap;
1925
1926         //LCOV_EXCL_START
1927         switch (type) {
1928         case WIFI_MANAGER_ENCRYPTION_TYPE_NONE:
1929                 profile_info->security_info.enc_mode = WLAN_ENC_MODE_NONE;
1930                 break;
1931         case WIFI_MANAGER_ENCRYPTION_TYPE_WEP:
1932                 profile_info->security_info.enc_mode = WLAN_ENC_MODE_WEP;
1933                 break;
1934         case WIFI_MANAGER_ENCRYPTION_TYPE_TKIP:
1935                 profile_info->security_info.enc_mode = WLAN_ENC_MODE_TKIP;
1936                 break;
1937         case WIFI_MANAGER_ENCRYPTION_TYPE_AES:
1938                 profile_info->security_info.enc_mode = WLAN_ENC_MODE_AES;
1939                 break;
1940         case WIFI_MANAGER_ENCRYPTION_TYPE_TKIP_AES_MIXED:
1941                 profile_info->security_info.enc_mode = WLAN_ENC_MODE_TKIP_AES_MIXED;
1942                 break;
1943         default:
1944                 __NETWORK_CAPI_FUNC_EXIT__;
1945                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER;
1946         }
1947         //LCOV_EXCL_STOP
1948
1949         __NETWORK_CAPI_FUNC_EXIT__;
1950
1951         return WIFI_MANAGER_ERROR_NONE;
1952 }
1953
1954 EXPORT_API int wifi_manager_ap_is_passphrase_required(wifi_manager_ap_h ap,
1955                 bool *required)
1956 {
1957         __NETWORK_CAPI_FUNC_ENTER__;
1958
1959         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1960
1961         if (_wifi_check_ap_validity(ap) == false || required == NULL) {
1962                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1963                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
1964                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1965         }
1966
1967         net_profile_info_s *profile_info = ap;
1968
1969         if (profile_info->Favourite) {
1970                 *required = false;
1971                 __NETWORK_CAPI_FUNC_EXIT__;
1972                 return WIFI_MANAGER_ERROR_NONE;
1973         }
1974
1975         //LCOV_EXCL_START
1976         switch (profile_info->security_info.sec_mode) {
1977         case WLAN_SEC_MODE_NONE:
1978         case WLAN_SEC_MODE_OWE:
1979         case WLAN_SEC_MODE_DPP:
1980                 *required = false;
1981                 break;
1982         case WLAN_SEC_MODE_WEP:
1983         case WLAN_SEC_MODE_IEEE8021X:
1984         case WLAN_SEC_MODE_WPA_PSK:
1985         case WLAN_SEC_MODE_WPA2_PSK:
1986         case WLAN_SEC_MODE_WPA_FT_PSK:
1987         case WLAN_SEC_MODE_SAE:
1988                 *required = true;
1989                 break;
1990         default:
1991                 __NETWORK_CAPI_FUNC_EXIT__;
1992                 return WIFI_MANAGER_ERROR_OPERATION_FAILED;
1993         }
1994         //LCOV_EXCL_STOP
1995
1996         __NETWORK_CAPI_FUNC_EXIT__;
1997
1998         return WIFI_MANAGER_ERROR_NONE;
1999 }
2000
2001 EXPORT_API int wifi_manager_ap_set_passphrase(wifi_manager_ap_h ap, const char *passphrase)
2002 {
2003         __NETWORK_CAPI_FUNC_ENTER__;
2004
2005         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2006
2007         if (_wifi_check_ap_validity(ap) == false || passphrase == NULL) {
2008                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2009                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2010                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2011         }
2012
2013         net_profile_info_s *profile_info = ap;
2014
2015         //LCOV_EXCL_START
2016         switch (profile_info->security_info.sec_mode) {
2017         case WLAN_SEC_MODE_WEP:
2018                 g_strlcpy(profile_info->security_info.authentication.wep.wepKey,
2019                                 passphrase, NET_WLAN_MAX_WEP_KEY_LEN+1);
2020                 break;
2021         case WLAN_SEC_MODE_WPA_PSK:
2022         case WLAN_SEC_MODE_WPA2_PSK:
2023         case WLAN_SEC_MODE_WPA_FT_PSK:
2024                 g_strlcpy(profile_info->security_info.authentication.psk.pskKey,
2025                                 passphrase, NET_WLAN_MAX_PSK_PASSPHRASE_LEN+1);
2026                 break;
2027         case WLAN_SEC_MODE_SAE:
2028                 g_strlcpy(profile_info->security_info.authentication.sae.saeKey,
2029                                 passphrase, NET_WLAN_MAX_SAE_PASSPHRASE_LEN+1);
2030                 break;
2031         case WLAN_SEC_MODE_NONE:
2032         case WLAN_SEC_MODE_IEEE8021X:
2033         case WLAN_SEC_MODE_OWE:
2034         default:
2035                 __NETWORK_CAPI_FUNC_EXIT__;
2036                 return WIFI_MANAGER_ERROR_OPERATION_FAILED;
2037         }
2038         //LCOV_EXCL_STOP
2039
2040         __NETWORK_CAPI_FUNC_EXIT__;
2041
2042         return WIFI_MANAGER_ERROR_NONE;
2043 }
2044
2045 EXPORT_API int wifi_manager_ap_is_wps_supported(wifi_manager_ap_h ap, bool *supported)
2046 {
2047         /* __NETWORK_CAPI_FUNC_ENTER__; */
2048
2049         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2050
2051         if (_wifi_check_ap_validity(ap) == false || supported == NULL) {
2052                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2053                 /* __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE */
2054                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2055         }
2056
2057         net_profile_info_s *profile_info = ap;
2058
2059         if (profile_info->security_info.wps_support)
2060                 *supported = true;
2061         else
2062                 *supported = false;
2063
2064         /* __NETWORK_CAPI_FUNC_EXIT__; */
2065         return WIFI_MANAGER_ERROR_NONE;
2066 }
2067
2068 EXPORT_API int wifi_manager_ap_is_hidden(wifi_manager_ap_h ap, bool *is_hidden)
2069 {
2070         /* __NETWORK_CAPI_FUNC_ENTER__; */
2071
2072         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2073
2074         if (_wifi_check_ap_validity(ap) == false || is_hidden == NULL) {
2075                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2076                 /* __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE */
2077                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2078         }
2079
2080         net_profile_info_s *profile_info = ap;
2081
2082         if (profile_info->ap_hidden_status)
2083                 *is_hidden = true;
2084         else
2085                 *is_hidden = false;
2086
2087         /* __NETWORK_CAPI_FUNC_EXIT__; */
2088         return WIFI_MANAGER_ERROR_NONE;
2089 }
2090
2091 EXPORT_API int wifi_manager_ap_is_pmf_required(wifi_manager_ap_h ap, bool *required)
2092 {
2093         /* __NETWORK_CAPI_FUNC_ENTER__; */
2094
2095         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2096
2097         if (_wifi_check_ap_validity(ap) == false || required == NULL) {
2098                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2099                 /* __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE */
2100                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2101         }
2102
2103         net_profile_info_s *profile_info = ap;
2104
2105         if (profile_info->pmf_required)
2106                 *required = true;
2107         else
2108                 *required = false;
2109
2110         /* __NETWORK_CAPI_FUNC_EXIT__; */
2111         return WIFI_MANAGER_ERROR_NONE;
2112 }
2113
2114 /* Wi-Fi EAP *****************************************************************/
2115 EXPORT_API int wifi_manager_ap_set_eap_passphrase(wifi_manager_ap_h ap,
2116                 const char *user_name, const char *password)
2117 {
2118         __NETWORK_CAPI_FUNC_ENTER__;
2119
2120         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2121
2122         if (_wifi_check_ap_validity(ap) == false || (user_name == NULL && password == NULL)) {
2123                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2124                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2125                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2126         }
2127
2128         net_profile_info_s *profile_info = ap;
2129         if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) {
2130                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2131                 return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2132         }
2133
2134         if (user_name)
2135                 g_strlcpy(profile_info->security_info.authentication.eap.username,
2136                                 user_name, NET_WLAN_USERNAME_LEN+1);
2137
2138         if (password)
2139                 g_strlcpy(profile_info->security_info.authentication.eap.password,
2140                                 password, NET_WLAN_PASSWORD_LEN+1);
2141
2142         __NETWORK_CAPI_FUNC_EXIT__;
2143
2144         return WIFI_MANAGER_ERROR_NONE;
2145 }
2146
2147 EXPORT_API int wifi_manager_ap_get_eap_passphrase(wifi_manager_ap_h ap,
2148                 char **user_name, bool *is_password_set)
2149 {
2150         __NETWORK_CAPI_FUNC_ENTER__;
2151
2152         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2153
2154         if (_wifi_check_ap_validity(ap) == false || user_name == NULL || is_password_set == NULL) {
2155                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2156                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2157                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2158         }
2159
2160         net_profile_info_s *profile_info = ap;
2161         if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) {
2162                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2163                 return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2164         }
2165
2166         *user_name = g_strdup(profile_info->security_info.authentication.eap.username);
2167         if (*user_name == NULL)  {
2168                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2169                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
2170         }
2171
2172         if (strlen(profile_info->security_info.authentication.eap.password) > 0)
2173                 *is_password_set = true;
2174         else
2175                 *is_password_set = false;
2176
2177         __NETWORK_CAPI_FUNC_EXIT__;
2178
2179         return WIFI_MANAGER_ERROR_NONE;
2180 }
2181
2182 EXPORT_API int wifi_manager_ap_set_eap_anonymous_identity(wifi_manager_ap_h ap, const char *anonymous_identity)
2183 {
2184         __NETWORK_CAPI_FUNC_ENTER__;
2185
2186         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2187
2188         if (_wifi_check_ap_validity(ap) == false || anonymous_identity == NULL) {
2189                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2190                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2191                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2192         }
2193
2194         net_profile_info_s *profile_info = ap;
2195         if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) {
2196                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2197                 return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2198         }
2199
2200         g_strlcpy(profile_info->security_info.authentication.eap.anonymous_identity,
2201                         anonymous_identity, NET_WLAN_USERNAME_LEN+1);
2202
2203         __NETWORK_CAPI_FUNC_EXIT__;
2204
2205         return WIFI_MANAGER_ERROR_NONE;
2206 }
2207
2208 EXPORT_API int wifi_manager_ap_get_eap_anonymous_identity(wifi_manager_ap_h ap, char **anonymous_identity)
2209 {
2210         __NETWORK_CAPI_FUNC_ENTER__;
2211
2212         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2213
2214         if (_wifi_check_ap_validity(ap) == false || anonymous_identity == NULL) {
2215                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2216                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2217                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2218         }
2219
2220         net_profile_info_s *profile_info = ap;
2221         if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) {
2222                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2223                 return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2224         }
2225
2226         *anonymous_identity = strdup(profile_info->security_info.authentication.eap.anonymous_identity);
2227         if (*anonymous_identity == NULL) {
2228                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2229                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
2230         }
2231
2232         __NETWORK_CAPI_FUNC_EXIT__;
2233
2234         return WIFI_MANAGER_ERROR_NONE;
2235 }
2236
2237 EXPORT_API int wifi_manager_ap_get_eap_ca_cert_file(wifi_manager_ap_h ap, char **file)
2238 {
2239         __NETWORK_CAPI_FUNC_ENTER__;
2240
2241         net_profile_info_s *profile_info = NULL;
2242
2243         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2244
2245         if (_wifi_check_ap_validity(ap) == false || file == NULL) {
2246                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2247                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2248                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2249         }
2250
2251         profile_info = (net_profile_info_s *)ap;
2252         if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) {
2253                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2254                 return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2255         }
2256
2257         *file = g_strdup(profile_info->security_info.authentication.eap.ca_cert_filename);
2258         if (*file == NULL) {
2259                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2260                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
2261         }
2262
2263         __NETWORK_CAPI_FUNC_EXIT__;
2264
2265         return WIFI_MANAGER_ERROR_NONE;
2266 }
2267
2268 EXPORT_API int wifi_manager_ap_set_eap_ca_cert_file(wifi_manager_ap_h ap, const char *file)
2269 {
2270         __NETWORK_CAPI_FUNC_ENTER__;
2271
2272         net_profile_info_s *profile_info = NULL;
2273
2274         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2275
2276         if (_wifi_check_ap_validity(ap) == false || file == NULL) {
2277                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2278                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2279                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2280         }
2281
2282         profile_info = (net_profile_info_s *)ap;
2283         if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) {
2284                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2285                 return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2286         }
2287
2288         g_strlcpy(profile_info->security_info.authentication.eap.ca_cert_filename,
2289                         file, NET_WLAN_CA_CERT_FILENAME_LEN+1);
2290
2291         __NETWORK_CAPI_FUNC_EXIT__;
2292
2293         return WIFI_MANAGER_ERROR_NONE;
2294 }
2295
2296 EXPORT_API int wifi_manager_ap_get_eap_client_cert_file(wifi_manager_ap_h ap, char **file)
2297 {
2298         __NETWORK_CAPI_FUNC_ENTER__;
2299
2300         net_profile_info_s *profile_info = NULL;
2301
2302         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2303
2304         if (_wifi_check_ap_validity(ap) == false || file == NULL) {
2305                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2306                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2307                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2308         }
2309
2310         profile_info = (net_profile_info_s *)ap;
2311         if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) {
2312                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2313                 return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2314         }
2315
2316         *file = g_strdup(profile_info->security_info.authentication.eap.client_cert_filename);
2317         if (*file == NULL) {
2318                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2319                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
2320         }
2321
2322         __NETWORK_CAPI_FUNC_EXIT__;
2323
2324         return WIFI_MANAGER_ERROR_NONE;
2325 }
2326
2327 EXPORT_API int wifi_manager_ap_set_eap_client_cert_file(wifi_manager_ap_h ap,
2328                 const char *file)
2329 {
2330         __NETWORK_CAPI_FUNC_ENTER__;
2331
2332         net_profile_info_s *profile_info = NULL;
2333
2334         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2335
2336         if (_wifi_check_ap_validity(ap) == false || file == NULL) {
2337                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2338                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2339                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2340         }
2341
2342         profile_info = (net_profile_info_s *)ap;
2343         if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) {
2344                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2345                 return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2346         }
2347
2348         g_strlcpy(profile_info->security_info.authentication.eap.client_cert_filename,
2349                         file, NET_WLAN_CLIENT_CERT_FILENAME_LEN+1);
2350
2351         __NETWORK_CAPI_FUNC_EXIT__;
2352
2353         return WIFI_MANAGER_ERROR_NONE;
2354 }
2355
2356 EXPORT_API int wifi_manager_ap_get_eap_private_key_file(wifi_manager_ap_h ap, char **file)
2357 {
2358         __NETWORK_CAPI_FUNC_ENTER__;
2359
2360         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2361
2362         if (_wifi_check_ap_validity(ap) == false || file == NULL) {
2363                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2364                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2365                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2366         }
2367
2368         net_profile_info_s *profile_info = ap;
2369         if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) {
2370                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2371                 return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2372         }
2373
2374         *file = g_strdup(profile_info->security_info.authentication.eap.private_key_filename);
2375         if (*file == NULL) {
2376                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2377                 return WIFI_MANAGER_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
2378         }
2379
2380         __NETWORK_CAPI_FUNC_EXIT__;
2381
2382         return WIFI_MANAGER_ERROR_NONE;
2383 }
2384
2385 EXPORT_API int wifi_manager_ap_set_eap_private_key_info(wifi_manager_ap_h ap,
2386                 const char *file, const char *password)
2387 {
2388         __NETWORK_CAPI_FUNC_ENTER__;
2389
2390         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2391
2392         if (_wifi_check_ap_validity(ap) == false || file == NULL) {
2393                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2394                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2395                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2396         }
2397
2398         net_profile_info_s *profile_info = ap;
2399         if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) {
2400                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2401                 return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2402         }
2403
2404         g_strlcpy(profile_info->security_info.authentication.eap.private_key_filename,
2405                         file, NET_WLAN_PRIVATE_KEY_FILENAME_LEN+1);
2406
2407         if (password) {
2408                 g_strlcpy(profile_info->security_info.authentication.eap.private_key_passwd,
2409                                 password, NET_WLAN_PRIVATE_KEY_PASSWD_LEN+1);
2410         }
2411
2412         __NETWORK_CAPI_FUNC_EXIT__;
2413
2414         return WIFI_MANAGER_ERROR_NONE;
2415 }
2416
2417 EXPORT_API int wifi_manager_ap_get_eap_type(wifi_manager_ap_h ap,
2418                 wifi_manager_eap_type_e *type)
2419 {
2420         __NETWORK_CAPI_FUNC_ENTER__;
2421
2422         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2423
2424         if (_wifi_check_ap_validity(ap) == false || type == NULL) {
2425                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2426                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2427                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2428         }
2429
2430         net_profile_info_s *profile_info = ap;
2431         if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) {
2432                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2433                 return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2434         }
2435
2436         //LCOV_EXCL_START
2437         switch (profile_info->security_info.authentication.eap.eap_type) {
2438         case WLAN_SEC_EAP_TYPE_PEAP:
2439                 *type = WIFI_MANAGER_EAP_TYPE_PEAP;
2440                 break;
2441         case WLAN_SEC_EAP_TYPE_TLS:
2442                 *type = WIFI_MANAGER_EAP_TYPE_TLS;
2443                 break;
2444         case WLAN_SEC_EAP_TYPE_TTLS:
2445                 *type = WIFI_MANAGER_EAP_TYPE_TTLS;
2446                 break;
2447         case WLAN_SEC_EAP_TYPE_SIM:
2448                 *type = WIFI_MANAGER_EAP_TYPE_SIM;
2449                 break;
2450         case WLAN_SEC_EAP_TYPE_AKA:
2451                 *type = WIFI_MANAGER_EAP_TYPE_AKA;
2452                 break;
2453         case WLAN_SEC_EAP_TYPE_AKA_PRIME:
2454                 *type = WIFI_MANAGER_EAP_TYPE_AKA_PRIME;
2455                 break;
2456         case WLAN_SEC_EAP_TYPE_FAST:
2457                 *type = WIFI_MANAGER_EAP_TYPE_FAST;
2458                 break;
2459         case WLAN_SEC_EAP_TYPE_PWD:
2460                 *type = WIFI_MANAGER_EAP_TYPE_PWD;
2461                 break;
2462         default:
2463                 __NETWORK_CAPI_FUNC_EXIT__;
2464                 return WIFI_MANAGER_ERROR_OPERATION_FAILED;
2465         }
2466         //LCOV_EXCL_STOP
2467
2468         __NETWORK_CAPI_FUNC_EXIT__;
2469
2470         return WIFI_MANAGER_ERROR_NONE;
2471 }
2472
2473 EXPORT_API int wifi_manager_ap_set_eap_type(wifi_manager_ap_h ap,
2474                 wifi_manager_eap_type_e type)
2475 {
2476         __NETWORK_CAPI_FUNC_ENTER__;
2477
2478         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2479
2480         if (_wifi_check_ap_validity(ap) == false) {
2481                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2482                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2483                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2484         }
2485
2486         net_profile_info_s *profile_info = ap;
2487         if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) {
2488                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2489                 return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2490         }
2491
2492         //LCOV_EXCL_START
2493         switch (type) {
2494         case WIFI_MANAGER_EAP_TYPE_PEAP:
2495                 profile_info->security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_PEAP;
2496                 break;
2497         case WIFI_MANAGER_EAP_TYPE_TLS:
2498                 profile_info->security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_TLS;
2499                 break;
2500         case WIFI_MANAGER_EAP_TYPE_TTLS:
2501                 profile_info->security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_TTLS;
2502                 break;
2503         case WIFI_MANAGER_EAP_TYPE_SIM:
2504                 profile_info->security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_SIM;
2505                 break;
2506         case WIFI_MANAGER_EAP_TYPE_AKA:
2507                 profile_info->security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_AKA;
2508                 break;
2509         case WIFI_MANAGER_EAP_TYPE_AKA_PRIME:
2510                 profile_info->security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_AKA_PRIME;
2511                 break;
2512         case WIFI_MANAGER_EAP_TYPE_FAST:
2513                 profile_info->security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_FAST;
2514                 break;
2515         case WIFI_MANAGER_EAP_TYPE_PWD:
2516                 profile_info->security_info.authentication.eap.eap_type = WLAN_SEC_EAP_TYPE_PWD;
2517                 break;
2518         default:
2519                 __NETWORK_CAPI_FUNC_EXIT__;
2520                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER;
2521         }
2522         //LCOV_EXCL_STOP
2523
2524         __NETWORK_CAPI_FUNC_EXIT__;
2525
2526         return WIFI_MANAGER_ERROR_NONE;
2527 }
2528
2529 EXPORT_API int wifi_manager_ap_get_eap_auth_type(wifi_manager_ap_h ap,
2530                 wifi_manager_eap_auth_type_e *type)
2531 {
2532         __NETWORK_CAPI_FUNC_ENTER__;
2533
2534         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2535
2536         if (_wifi_check_ap_validity(ap) == false || type == NULL) {
2537                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2538                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2539                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2540         }
2541
2542         net_profile_info_s *profile_info = ap;
2543         if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) {
2544                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2545                 return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2546         }
2547
2548         //LCOV_EXCL_START
2549         switch (profile_info->security_info.authentication.eap.eap_auth) {
2550         case WLAN_SEC_EAP_AUTH_NONE:
2551                 *type = WIFI_MANAGER_EAP_AUTH_TYPE_NONE;
2552                 break;
2553         case WLAN_SEC_EAP_AUTH_PAP:
2554                 *type = WIFI_MANAGER_EAP_AUTH_TYPE_PAP;
2555                 break;
2556         case WLAN_SEC_EAP_AUTH_MSCHAP:
2557                 *type = WIFI_MANAGER_EAP_AUTH_TYPE_MSCHAP;
2558                 break;
2559         case WLAN_SEC_EAP_AUTH_MSCHAPV2:
2560                 *type = WIFI_MANAGER_EAP_AUTH_TYPE_MSCHAPV2;
2561                 break;
2562         case WLAN_SEC_EAP_AUTH_GTC:
2563                 *type = WIFI_MANAGER_EAP_AUTH_TYPE_GTC;
2564                 break;
2565         case WLAN_SEC_EAP_AUTH_MD5:
2566                 *type = WIFI_MANAGER_EAP_AUTH_TYPE_MD5;
2567                 break;
2568         default:
2569                 __NETWORK_CAPI_FUNC_EXIT__;
2570                 return WIFI_MANAGER_ERROR_OPERATION_FAILED;
2571         }
2572         //LCOV_EXCL_STOP
2573
2574         __NETWORK_CAPI_FUNC_EXIT__;
2575
2576         return WIFI_MANAGER_ERROR_NONE;
2577 }
2578
2579 EXPORT_API int wifi_manager_ap_set_eap_auth_type(wifi_manager_ap_h ap,
2580                 wifi_manager_eap_auth_type_e type)
2581 {
2582         __NETWORK_CAPI_FUNC_ENTER__;
2583
2584         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2585
2586         if (_wifi_check_ap_validity(ap) == false) {
2587                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2588                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2589                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2590         }
2591
2592         net_profile_info_s *profile_info = ap;
2593         if (profile_info->security_info.sec_mode != WLAN_SEC_MODE_IEEE8021X) {
2594                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2595                 return WIFI_MANAGER_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
2596         }
2597
2598         //LCOV_EXCL_START
2599         switch (type) {
2600         case WIFI_MANAGER_EAP_AUTH_TYPE_NONE:
2601                 profile_info->security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_NONE;
2602                 break;
2603         case WIFI_MANAGER_EAP_AUTH_TYPE_PAP:
2604                 profile_info->security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_PAP;
2605                 break;
2606         case WIFI_MANAGER_EAP_AUTH_TYPE_MSCHAP:
2607                 profile_info->security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_MSCHAP;
2608                 break;
2609         case WIFI_MANAGER_EAP_AUTH_TYPE_MSCHAPV2:
2610                 profile_info->security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_MSCHAPV2;
2611                 break;
2612         case WIFI_MANAGER_EAP_AUTH_TYPE_GTC:
2613                 profile_info->security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_GTC;
2614                 break;
2615         case WIFI_MANAGER_EAP_AUTH_TYPE_MD5:
2616                 profile_info->security_info.authentication.eap.eap_auth = WLAN_SEC_EAP_AUTH_MD5;
2617                 break;
2618         default:
2619                 __NETWORK_CAPI_FUNC_EXIT__;
2620                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER;
2621         }
2622         //LCOV_EXCL_STOP
2623
2624         __NETWORK_CAPI_FUNC_EXIT__;
2625
2626         return WIFI_MANAGER_ERROR_NONE;
2627 }
2628
2629 EXPORT_API int wifi_manager_ap_get_disconnect_reason(wifi_manager_ap_h ap,
2630                                                         wifi_manager_disconnect_reason_e *disconnect_reason)
2631 {
2632         __NETWORK_CAPI_FUNC_ENTER__;
2633
2634         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2635
2636         if (_wifi_check_ap_validity(ap) == false || disconnect_reason == NULL) {
2637                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2638                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2639                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2640         }
2641
2642         net_profile_info_s *profile_info = ap;
2643         *disconnect_reason = (int)profile_info->disconnect_reason;
2644         if (profile_info->disconnect_reason == 0)
2645                 profile_info->disconnect_reason = WIFI_REASON_UNSPECIFIED;
2646
2647         WIFI_LOG(WIFI_INFO, "Disconnect Reason Code %d",
2648                                 *disconnect_reason);
2649
2650         __NETWORK_CAPI_FUNC_EXIT__;
2651
2652         return WIFI_MANAGER_ERROR_NONE;
2653 }
2654
2655 EXPORT_API int wifi_manager_ap_get_assoc_status_code(wifi_manager_ap_h ap,
2656                                                         wifi_manager_assoc_status_code_e *status_code)
2657 {
2658         __NETWORK_CAPI_FUNC_ENTER__;
2659
2660         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2661
2662         if (_wifi_check_ap_validity(ap) == false || status_code == NULL) {
2663                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2664                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2665                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2666         }
2667
2668         net_profile_info_s *profile_info = ap;
2669         *status_code = (int)profile_info->assoc_status_code;
2670
2671         WIFI_LOG(WIFI_INFO, "Association Status Code %d",
2672                                 *status_code);
2673
2674         __NETWORK_CAPI_FUNC_EXIT__;
2675
2676         return WIFI_MANAGER_ERROR_NONE;
2677 }
2678
2679 EXPORT_API int wifi_manager_ap_foreach_ipv6_address(wifi_manager_ap_h ap,
2680                 wifi_manager_ap_ipv6_address_cb callback, void *user_data)
2681 {
2682         __NETWORK_CAPI_FUNC_ENTER__;
2683
2684         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2685
2686         GSList *ipv6_address_list = NULL;
2687         int rv = WIFI_MANAGER_ERROR_NONE;
2688
2689         if (_wifi_check_ap_validity(ap) == false || callback == NULL) {
2690                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2691                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2692                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2693         }
2694
2695         net_profile_info_s *profile_info = ap;
2696         net_state_type_e state = profile_info->ProfileState;
2697
2698         if (state != NET_STATE_TYPE_READY && state != NET_STATE_TYPE_ONLINE) {
2699                 callback(__ap_convert_ip_to_string(&profile_info->net_info.IpAddr,
2700                                         WIFI_MANAGER_ADDRESS_FAMILY_IPV6), user_data);
2701                 __NETWORK_CAPI_FUNC_EXIT__;
2702                 return WIFI_MANAGER_ERROR_NONE;
2703         }
2704
2705         if (net_foreach_ipv6_address(&ipv6_address_list) != NET_ERR_NONE) {
2706                 __NETWORK_CAPI_FUNC_EXIT__;
2707                 return WIFI_MANAGER_ERROR_OPERATION_FAILED;
2708         }
2709
2710         GSList *list;
2711         for (list = ipv6_address_list; list; list = list->next) {
2712                 rv = callback((char *)list->data, user_data);
2713                 if (rv == false)
2714                         break;
2715         }
2716
2717         g_slist_free_full(ipv6_address_list, g_free);
2718         ipv6_address_list = NULL;
2719
2720         __NETWORK_CAPI_FUNC_EXIT__;
2721
2722         return WIFI_MANAGER_ERROR_NONE;
2723 }
2724
2725 EXPORT_API int wifi_manager_ap_get_error_state(wifi_manager_ap_h ap, wifi_manager_error_e* error_state)
2726 {
2727         __NETWORK_CAPI_FUNC_ENTER__;
2728
2729         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2730
2731         if (_wifi_check_ap_validity(ap) == false || error_state == NULL) {
2732                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2733                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2734                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2735         }
2736
2737         net_profile_info_s *profile_info = ap;
2738         *error_state = __wifi_convert_to_ap_error_state(profile_info->ProfileErrorState);
2739         WIFI_LOG(WIFI_INFO, "error_state %d", *error_state);
2740
2741         __NETWORK_CAPI_FUNC_EXIT__;
2742
2743         return WIFI_MANAGER_ERROR_NONE;
2744 }
2745
2746 //LCOV_EXCL_START
2747 EXPORT_API int wifi_manager_ap_get_connection_mode(wifi_manager_ap_h ap, wifi_manager_connection_mode_e *mode)
2748 {
2749         __NETWORK_CAPI_FUNC_ENTER__;
2750
2751         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
2752
2753         if (_wifi_check_ap_validity(ap) == false || mode == NULL) {
2754                 WIFI_LOG(WIFI_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
2755                 __NETWORK_CAPI_FUNC_EXIT__; //LCOV_EXCL_LINE
2756                 return WIFI_MANAGER_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
2757         }
2758
2759         net_profile_info_s *profile_info = ap;
2760         if (profile_info->operation_mode[0] != '\0') {
2761                 *mode = __ap_convert_string_to_connection_mode(profile_info->operation_mode);
2762         } else {
2763                 __NETWORK_CAPI_FUNC_EXIT__;
2764                 return WIFI_MANAGER_ERROR_OPERATION_FAILED;
2765         }
2766
2767         __NETWORK_CAPI_FUNC_EXIT__;
2768         return WIFI_MANAGER_ERROR_NONE;
2769 }
2770 //LCOV_EXCL_STOP