2008-02-28 02:34:43 +01:00
|
|
|
/*
|
|
|
|
* WPA Supplicant - Driver event processing
|
2019-02-23 11:59:10 +01:00
|
|
|
* Copyright (c) 2003-2019, Jouni Malinen <j@w1.fi>
|
2008-02-28 02:34:43 +01:00
|
|
|
*
|
2012-02-11 15:46:35 +01:00
|
|
|
* This software may be distributed under the terms of the BSD license.
|
|
|
|
* See README for more details.
|
2008-02-28 02:34:43 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include "includes.h"
|
|
|
|
|
|
|
|
#include "common.h"
|
|
|
|
#include "eapol_supp/eapol_supp_sm.h"
|
2009-11-29 17:28:08 +01:00
|
|
|
#include "rsn_supp/wpa.h"
|
2008-02-28 02:34:43 +01:00
|
|
|
#include "eloop.h"
|
|
|
|
#include "config.h"
|
|
|
|
#include "l2_packet/l2_packet.h"
|
|
|
|
#include "wpa_supplicant_i.h"
|
2009-03-26 19:37:05 +01:00
|
|
|
#include "driver_i.h"
|
2008-02-28 02:34:43 +01:00
|
|
|
#include "pcsc_funcs.h"
|
2009-11-29 17:28:08 +01:00
|
|
|
#include "rsn_supp/preauth.h"
|
|
|
|
#include "rsn_supp/pmksa_cache.h"
|
2009-11-29 16:51:55 +01:00
|
|
|
#include "common/wpa_ctrl.h"
|
2008-02-28 02:34:43 +01:00
|
|
|
#include "eap_peer/eap.h"
|
2010-01-03 17:22:22 +01:00
|
|
|
#include "ap/hostapd.h"
|
2010-10-19 11:47:33 +02:00
|
|
|
#include "p2p/p2p.h"
|
2014-11-16 16:28:53 +01:00
|
|
|
#include "fst/fst.h"
|
2012-02-26 16:27:19 +01:00
|
|
|
#include "wnm_sta.h"
|
2009-09-13 19:53:32 +02:00
|
|
|
#include "notify.h"
|
2009-11-29 16:51:55 +01:00
|
|
|
#include "common/ieee802_11_defs.h"
|
2010-05-26 16:16:14 +02:00
|
|
|
#include "common/ieee802_11_common.h"
|
2017-06-15 20:18:15 +02:00
|
|
|
#include "common/gas_server.h"
|
2019-03-17 22:51:53 +01:00
|
|
|
#include "common/dpp.h"
|
2020-12-16 12:00:27 +01:00
|
|
|
#include "common/ptksa_cache.h"
|
Maintain internal entropy pool for augmenting random number generation
By default, make hostapd and wpa_supplicant maintain an internal
entropy pool that is fed with following information:
hostapd:
- Probe Request frames (timing, RSSI)
- Association events (timing)
- SNonce from Supplicants
wpa_supplicant:
- Scan results (timing, signal/noise)
- Association events (timing)
The internal pool is used to augment the random numbers generated
with the OS mechanism (os_get_random()). While the internal
implementation is not expected to be very strong due to limited
amount of generic (non-platform specific) information to feed the
pool, this may strengthen key derivation on some devices that are
not configured to provide strong random numbers through
os_get_random() (e.g., /dev/urandom on Linux/BSD).
This new mechanism is not supposed to replace proper OS provided
random number generation mechanism. The OS mechanism needs to be
initialized properly (e.g., hw random number generator,
maintaining entropy pool over reboots, etc.) for any of the
security assumptions to hold.
If the os_get_random() is known to provide strong ramdom data (e.g., on
Linux/BSD, the board in question is known to have reliable source of
random data from /dev/urandom), the internal hostapd random pool can be
disabled. This will save some in binary size and CPU use. However, this
should only be considered for builds that are known to be used on
devices that meet the requirements described above. The internal pool
is disabled by adding CONFIG_NO_RANDOM_POOL=y to the .config file.
2010-11-24 00:29:40 +01:00
|
|
|
#include "crypto/random.h"
|
2008-02-28 02:34:43 +01:00
|
|
|
#include "blacklist.h"
|
|
|
|
#include "wpas_glue.h"
|
2008-11-29 21:06:34 +01:00
|
|
|
#include "wps_supplicant.h"
|
2009-01-15 00:21:55 +01:00
|
|
|
#include "ibss_rsn.h"
|
2009-03-20 21:26:41 +01:00
|
|
|
#include "sme.h"
|
2011-09-28 18:44:25 +02:00
|
|
|
#include "gas_query.h"
|
2010-07-18 23:30:25 +02:00
|
|
|
#include "p2p_supplicant.h"
|
2009-09-14 23:08:24 +02:00
|
|
|
#include "bgscan.h"
|
2012-06-26 17:55:41 +02:00
|
|
|
#include "autoscan.h"
|
2009-12-13 22:05:39 +01:00
|
|
|
#include "ap.h"
|
2010-01-02 15:16:02 +01:00
|
|
|
#include "bss.h"
|
2010-01-03 17:48:11 +01:00
|
|
|
#include "scan.h"
|
2011-09-29 18:22:08 +02:00
|
|
|
#include "offchannel.h"
|
2012-08-28 15:14:13 +02:00
|
|
|
#include "interworking.h"
|
2014-09-01 06:23:21 +02:00
|
|
|
#include "mesh.h"
|
2014-03-11 05:07:01 +01:00
|
|
|
#include "mesh_mpm.h"
|
2014-10-22 14:03:54 +02:00
|
|
|
#include "wmm_ac.h"
|
2017-06-15 20:18:12 +02:00
|
|
|
#include "dpp_supplicant.h"
|
2008-02-28 02:34:43 +01:00
|
|
|
|
|
|
|
|
2018-09-06 19:27:29 +02:00
|
|
|
#define MAX_OWE_TRANSITION_BSS_SELECT_COUNT 5
|
|
|
|
|
|
|
|
|
2013-06-07 19:04:56 +02:00
|
|
|
#ifndef CONFIG_NO_SCAN_PROCESSING
|
2013-04-23 17:24:00 +02:00
|
|
|
static int wpas_select_network_from_last_scan(struct wpa_supplicant *wpa_s,
|
2013-11-17 11:23:09 +01:00
|
|
|
int new_scan, int own_request);
|
2013-06-07 19:04:56 +02:00
|
|
|
#endif /* CONFIG_NO_SCAN_PROCESSING */
|
2013-02-03 20:13:07 +01:00
|
|
|
|
|
|
|
|
2017-03-28 14:26:38 +02:00
|
|
|
int wpas_temp_disabled(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
|
2012-08-26 22:01:26 +02:00
|
|
|
{
|
2013-12-16 21:08:41 +01:00
|
|
|
struct os_reltime now;
|
2012-08-26 22:01:26 +02:00
|
|
|
|
|
|
|
if (ssid == NULL || ssid->disabled_until.sec == 0)
|
|
|
|
return 0;
|
|
|
|
|
2013-12-16 21:08:41 +01:00
|
|
|
os_get_reltime(&now);
|
2012-08-26 22:01:26 +02:00
|
|
|
if (ssid->disabled_until.sec > now.sec)
|
|
|
|
return ssid->disabled_until.sec - now.sec;
|
|
|
|
|
|
|
|
wpas_clear_temp_disabled(wpa_s, ssid, 0);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-11-23 22:33:55 +01:00
|
|
|
#ifndef CONFIG_NO_SCAN_PROCESSING
|
2015-03-16 06:20:02 +01:00
|
|
|
/**
|
|
|
|
* wpas_reenabled_network_time - Time until first network is re-enabled
|
|
|
|
* @wpa_s: Pointer to wpa_supplicant data
|
|
|
|
* Returns: If all enabled networks are temporarily disabled, returns the time
|
|
|
|
* (in sec) until the first network is re-enabled. Otherwise returns 0.
|
|
|
|
*
|
|
|
|
* This function is used in case all enabled networks are temporarily disabled,
|
|
|
|
* in which case it returns the time (in sec) that the first network will be
|
|
|
|
* re-enabled. The function assumes that at least one network is enabled.
|
|
|
|
*/
|
|
|
|
static int wpas_reenabled_network_time(struct wpa_supplicant *wpa_s)
|
|
|
|
{
|
|
|
|
struct wpa_ssid *ssid;
|
|
|
|
int disabled_for, res = 0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_INTERWORKING
|
|
|
|
if (wpa_s->conf->auto_interworking && wpa_s->conf->interworking &&
|
|
|
|
wpa_s->conf->cred)
|
|
|
|
return 0;
|
|
|
|
#endif /* CONFIG_INTERWORKING */
|
|
|
|
|
|
|
|
for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
|
|
|
|
if (ssid->disabled)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
disabled_for = wpas_temp_disabled(wpa_s, ssid);
|
|
|
|
if (!disabled_for)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!res || disabled_for < res)
|
|
|
|
res = disabled_for;
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
2015-11-23 22:33:55 +01:00
|
|
|
#endif /* CONFIG_NO_SCAN_PROCESSING */
|
2015-03-16 06:20:02 +01:00
|
|
|
|
|
|
|
|
|
|
|
void wpas_network_reenabled(void *eloop_ctx, void *timeout_ctx)
|
|
|
|
{
|
|
|
|
struct wpa_supplicant *wpa_s = eloop_ctx;
|
|
|
|
|
|
|
|
if (wpa_s->disconnected || wpa_s->wpa_state != WPA_SCANNING)
|
|
|
|
return;
|
|
|
|
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"Try to associate due to network getting re-enabled");
|
|
|
|
if (wpa_supplicant_fast_associate(wpa_s) != 1) {
|
|
|
|
wpa_supplicant_cancel_sched_scan(wpa_s);
|
|
|
|
wpa_supplicant_req_scan(wpa_s, 0, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-09-09 02:15:42 +02:00
|
|
|
static struct wpa_bss * wpa_supplicant_get_new_bss(
|
|
|
|
struct wpa_supplicant *wpa_s, const u8 *bssid)
|
|
|
|
{
|
|
|
|
struct wpa_bss *bss = NULL;
|
|
|
|
struct wpa_ssid *ssid = wpa_s->current_ssid;
|
|
|
|
|
|
|
|
if (ssid->ssid_len > 0)
|
|
|
|
bss = wpa_bss_get(wpa_s, bssid, ssid->ssid, ssid->ssid_len);
|
|
|
|
if (!bss)
|
|
|
|
bss = wpa_bss_get_bssid(wpa_s, bssid);
|
|
|
|
|
|
|
|
return bss;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-08-18 20:04:56 +02:00
|
|
|
static void wpa_supplicant_update_current_bss(struct wpa_supplicant *wpa_s)
|
|
|
|
{
|
|
|
|
struct wpa_bss *bss = wpa_supplicant_get_new_bss(wpa_s, wpa_s->bssid);
|
|
|
|
|
|
|
|
if (!bss) {
|
|
|
|
wpa_supplicant_update_scan_results(wpa_s);
|
|
|
|
|
|
|
|
/* Get the BSS from the new scan results */
|
|
|
|
bss = wpa_supplicant_get_new_bss(wpa_s, wpa_s->bssid);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bss)
|
|
|
|
wpa_s->current_bss = bss;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
static int wpa_supplicant_select_config(struct wpa_supplicant *wpa_s)
|
|
|
|
{
|
2009-09-13 19:53:32 +02:00
|
|
|
struct wpa_ssid *ssid, *old_ssid;
|
2015-04-07 11:44:39 +02:00
|
|
|
u8 drv_ssid[SSID_MAX_LEN];
|
2015-03-13 13:29:20 +01:00
|
|
|
size_t drv_ssid_len;
|
2012-08-26 22:01:26 +02:00
|
|
|
int res;
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2014-08-18 20:04:56 +02:00
|
|
|
if (wpa_s->conf->ap_scan == 1 && wpa_s->current_ssid) {
|
|
|
|
wpa_supplicant_update_current_bss(wpa_s);
|
2015-03-13 13:29:20 +01:00
|
|
|
|
|
|
|
if (wpa_s->current_ssid->ssid_len == 0)
|
|
|
|
return 0; /* current profile still in use */
|
|
|
|
res = wpa_drv_get_ssid(wpa_s, drv_ssid);
|
|
|
|
if (res < 0) {
|
|
|
|
wpa_msg(wpa_s, MSG_INFO,
|
|
|
|
"Failed to read SSID from driver");
|
|
|
|
return 0; /* try to use current profile */
|
|
|
|
}
|
|
|
|
drv_ssid_len = res;
|
|
|
|
|
|
|
|
if (drv_ssid_len == wpa_s->current_ssid->ssid_len &&
|
|
|
|
os_memcmp(drv_ssid, wpa_s->current_ssid->ssid,
|
|
|
|
drv_ssid_len) == 0)
|
|
|
|
return 0; /* current profile still in use */
|
|
|
|
|
2020-03-07 17:03:32 +01:00
|
|
|
#ifdef CONFIG_OWE
|
|
|
|
if ((wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_OWE) &&
|
|
|
|
wpa_s->current_bss &&
|
|
|
|
(wpa_s->current_bss->flags & WPA_BSS_OWE_TRANSITION) &&
|
|
|
|
drv_ssid_len == wpa_s->current_bss->ssid_len &&
|
|
|
|
os_memcmp(drv_ssid, wpa_s->current_bss->ssid,
|
|
|
|
drv_ssid_len) == 0)
|
|
|
|
return 0; /* current profile still in use */
|
|
|
|
#endif /* CONFIG_OWE */
|
|
|
|
|
2015-03-13 13:29:20 +01:00
|
|
|
wpa_msg(wpa_s, MSG_DEBUG,
|
|
|
|
"Driver-initiated BSS selection changed the SSID to %s",
|
|
|
|
wpa_ssid_txt(drv_ssid, drv_ssid_len));
|
|
|
|
/* continue selecting a new network profile */
|
2014-08-18 20:04:56 +02:00
|
|
|
}
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Select network based on association "
|
|
|
|
"information");
|
2008-02-28 02:34:43 +01:00
|
|
|
ssid = wpa_supplicant_get_ssid(wpa_s);
|
|
|
|
if (ssid == NULL) {
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_msg(wpa_s, MSG_INFO,
|
|
|
|
"No network configuration found for the current AP");
|
2008-02-28 02:34:43 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-05-10 13:34:46 +02:00
|
|
|
if (wpas_network_disabled(wpa_s, ssid)) {
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Selected network is disabled");
|
2008-02-28 02:34:43 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-09-27 16:36:59 +02:00
|
|
|
if (disallowed_bssid(wpa_s, wpa_s->bssid) ||
|
|
|
|
disallowed_ssid(wpa_s, ssid->ssid, ssid->ssid_len)) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Selected BSS is disallowed");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2012-08-26 22:01:26 +02:00
|
|
|
res = wpas_temp_disabled(wpa_s, ssid);
|
|
|
|
if (res > 0) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Selected network is temporarily "
|
|
|
|
"disabled for %d second(s)", res);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Network configuration found for the "
|
|
|
|
"current AP");
|
2011-11-24 21:46:14 +01:00
|
|
|
if (wpa_key_mgmt_wpa_any(ssid->key_mgmt)) {
|
2008-02-28 02:34:43 +01:00
|
|
|
u8 wpa_ie[80];
|
|
|
|
size_t wpa_ie_len = sizeof(wpa_ie);
|
2013-01-01 19:31:35 +01:00
|
|
|
if (wpa_supplicant_set_suites(wpa_s, NULL, ssid,
|
|
|
|
wpa_ie, &wpa_ie_len) < 0)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Could not set WPA suites");
|
2008-02-28 02:34:43 +01:00
|
|
|
} else {
|
|
|
|
wpa_supplicant_set_non_wpa_policy(wpa_s, ssid);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wpa_s->current_ssid && wpa_s->current_ssid != ssid)
|
|
|
|
eapol_sm_invalidate_cached_session(wpa_s->eapol);
|
2009-09-13 19:53:32 +02:00
|
|
|
old_ssid = wpa_s->current_ssid;
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_s->current_ssid = ssid;
|
2013-09-09 02:15:42 +02:00
|
|
|
|
2014-08-18 20:04:56 +02:00
|
|
|
wpa_supplicant_update_current_bss(wpa_s);
|
2013-09-09 02:15:42 +02:00
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_supplicant_rsn_supp_set_config(wpa_s, wpa_s->current_ssid);
|
|
|
|
wpa_supplicant_initiate_eapol(wpa_s);
|
2009-09-13 19:53:32 +02:00
|
|
|
if (old_ssid != wpa_s->current_ssid)
|
|
|
|
wpas_notify_network_changed(wpa_s);
|
2008-02-28 02:34:43 +01:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-10-30 11:43:30 +01:00
|
|
|
void wpa_supplicant_stop_countermeasures(void *eloop_ctx, void *sock_ctx)
|
2008-02-28 02:34:43 +01:00
|
|
|
{
|
|
|
|
struct wpa_supplicant *wpa_s = eloop_ctx;
|
|
|
|
|
|
|
|
if (wpa_s->countermeasures) {
|
|
|
|
wpa_s->countermeasures = 0;
|
|
|
|
wpa_drv_set_countermeasures(wpa_s, 0);
|
|
|
|
wpa_msg(wpa_s, MSG_INFO, "WPA: TKIP countermeasures stopped");
|
2015-02-18 03:35:14 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* It is possible that the device is sched scanning, which means
|
|
|
|
* that a connection attempt will be done only when we receive
|
|
|
|
* scan results. However, in this case, it would be preferable
|
|
|
|
* to scan and connect immediately, so cancel the sched_scan and
|
|
|
|
* issue a regular scan flow.
|
|
|
|
*/
|
|
|
|
wpa_supplicant_cancel_sched_scan(wpa_s);
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_supplicant_req_scan(wpa_s, 0, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void wpa_supplicant_mark_disassoc(struct wpa_supplicant *wpa_s)
|
|
|
|
{
|
2009-09-13 19:53:32 +02:00
|
|
|
int bssid_changed;
|
|
|
|
|
2012-05-28 02:35:00 +02:00
|
|
|
wnm_bss_keep_alive_deinit(wpa_s);
|
|
|
|
|
2011-03-23 20:15:46 +01:00
|
|
|
#ifdef CONFIG_IBSS_RSN
|
|
|
|
ibss_rsn_deinit(wpa_s->ibss_rsn);
|
|
|
|
wpa_s->ibss_rsn = NULL;
|
|
|
|
#endif /* CONFIG_IBSS_RSN */
|
|
|
|
|
2011-07-05 15:38:30 +02:00
|
|
|
#ifdef CONFIG_AP
|
|
|
|
wpa_supplicant_ap_deinit(wpa_s);
|
|
|
|
#endif /* CONFIG_AP */
|
|
|
|
|
2016-04-06 16:14:41 +02:00
|
|
|
#ifdef CONFIG_HS20
|
|
|
|
/* Clear possibly configured frame filters */
|
|
|
|
wpa_drv_configure_frame_filters(wpa_s, 0);
|
|
|
|
#endif /* CONFIG_HS20 */
|
|
|
|
|
2010-05-23 09:27:32 +02:00
|
|
|
if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
|
|
|
|
return;
|
|
|
|
|
2018-06-21 01:42:45 +02:00
|
|
|
if (os_reltime_initialized(&wpa_s->session_start)) {
|
|
|
|
os_reltime_age(&wpa_s->session_start, &wpa_s->session_length);
|
|
|
|
wpa_s->session_start.sec = 0;
|
|
|
|
wpa_s->session_start.usec = 0;
|
|
|
|
wpas_notify_session_length(wpa_s);
|
|
|
|
}
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
|
2009-09-13 19:53:32 +02:00
|
|
|
bssid_changed = !is_zero_ether_addr(wpa_s->bssid);
|
2008-02-28 02:34:43 +01:00
|
|
|
os_memset(wpa_s->bssid, 0, ETH_ALEN);
|
|
|
|
os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
|
2014-12-29 17:40:10 +01:00
|
|
|
sme_clear_on_disassoc(wpa_s);
|
2010-02-27 17:40:25 +01:00
|
|
|
wpa_s->current_bss = NULL;
|
2010-11-25 15:04:07 +01:00
|
|
|
wpa_s->assoc_freq = 0;
|
2011-07-05 20:17:31 +02:00
|
|
|
|
2009-09-13 19:53:32 +02:00
|
|
|
if (bssid_changed)
|
|
|
|
wpas_notify_bssid_changed(wpa_s);
|
|
|
|
|
2020-04-23 23:51:11 +02:00
|
|
|
eapol_sm_notify_portEnabled(wpa_s->eapol, false);
|
|
|
|
eapol_sm_notify_portValid(wpa_s->eapol, false);
|
2017-03-11 23:32:23 +01:00
|
|
|
if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
|
2017-06-17 22:48:52 +02:00
|
|
|
wpa_s->key_mgmt == WPA_KEY_MGMT_OWE ||
|
2019-08-07 10:51:44 +02:00
|
|
|
wpa_s->key_mgmt == WPA_KEY_MGMT_DPP || wpa_s->drv_authorized_port)
|
2020-04-23 23:51:11 +02:00
|
|
|
eapol_sm_notify_eap_success(wpa_s->eapol, false);
|
2019-08-07 10:51:44 +02:00
|
|
|
wpa_s->drv_authorized_port = 0;
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_s->ap_ies_from_associnfo = 0;
|
2012-08-26 22:20:41 +02:00
|
|
|
wpa_s->current_ssid = NULL;
|
2013-08-25 18:46:57 +02:00
|
|
|
eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
|
2012-08-26 22:20:41 +02:00
|
|
|
wpa_s->key_mgmt = 0;
|
2014-11-05 09:42:48 +01:00
|
|
|
|
|
|
|
wpas_rrm_reset(wpa_s);
|
2015-10-25 22:02:14 +01:00
|
|
|
wpa_s->wnmsleep_used = 0;
|
2018-10-30 13:00:00 +01:00
|
|
|
wnm_clear_coloc_intf_reporting(wpa_s);
|
2019-09-11 12:35:22 +02:00
|
|
|
wpa_s->disable_mbo_oce = 0;
|
2017-10-14 12:41:08 +02:00
|
|
|
|
|
|
|
#ifdef CONFIG_TESTING_OPTIONS
|
|
|
|
wpa_s->last_tk_alg = WPA_ALG_NONE;
|
|
|
|
os_memset(wpa_s->last_tk, 0, sizeof(wpa_s->last_tk));
|
|
|
|
#endif /* CONFIG_TESTING_OPTIONS */
|
2018-04-24 09:54:20 +02:00
|
|
|
wpa_s->ieee80211ac = 0;
|
2018-12-05 11:23:53 +01:00
|
|
|
|
|
|
|
if (wpa_s->enabled_4addr_mode && wpa_drv_set_4addr_mode(wpa_s, 0) == 0)
|
|
|
|
wpa_s->enabled_4addr_mode = 0;
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void wpa_find_assoc_pmkid(struct wpa_supplicant *wpa_s)
|
|
|
|
{
|
|
|
|
struct wpa_ie_data ie;
|
|
|
|
int pmksa_set = -1;
|
|
|
|
size_t i;
|
|
|
|
|
2020-05-25 15:25:50 +02:00
|
|
|
/* Start with assumption of no PMKSA cache entry match */
|
|
|
|
pmksa_cache_clear_current(wpa_s->wpa);
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
if (wpa_sm_parse_own_wpa_ie(wpa_s->wpa, &ie) < 0 ||
|
|
|
|
ie.pmkid == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < ie.num_pmkid; i++) {
|
|
|
|
pmksa_set = pmksa_cache_set_current(wpa_s->wpa,
|
|
|
|
ie.pmkid + i * PMKID_LEN,
|
2018-04-08 19:06:40 +02:00
|
|
|
NULL, NULL, 0, NULL, 0);
|
2008-02-28 02:34:43 +01:00
|
|
|
if (pmksa_set == 0) {
|
2015-01-28 00:26:14 +01:00
|
|
|
eapol_sm_notify_pmkid_attempt(wpa_s->eapol);
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "RSN: PMKID from assoc IE %sfound from "
|
|
|
|
"PMKSA cache", pmksa_set == 0 ? "" : "not ");
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void wpa_supplicant_event_pmkid_candidate(struct wpa_supplicant *wpa_s,
|
|
|
|
union wpa_event_data *data)
|
|
|
|
{
|
|
|
|
if (data == NULL) {
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "RSN: No data in PMKID candidate "
|
|
|
|
"event");
|
2008-02-28 02:34:43 +01:00
|
|
|
return;
|
|
|
|
}
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "RSN: PMKID candidate event - bssid=" MACSTR
|
|
|
|
" index=%d preauth=%d",
|
|
|
|
MAC2STR(data->pmkid_candidate.bssid),
|
|
|
|
data->pmkid_candidate.index,
|
|
|
|
data->pmkid_candidate.preauth);
|
2008-02-28 02:34:43 +01:00
|
|
|
|
|
|
|
pmksa_candidate_add(wpa_s->wpa, data->pmkid_candidate.bssid,
|
|
|
|
data->pmkid_candidate.index,
|
|
|
|
data->pmkid_candidate.preauth);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int wpa_supplicant_dynamic_keys(struct wpa_supplicant *wpa_s)
|
|
|
|
{
|
|
|
|
if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
|
|
|
|
wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
#ifdef IEEE8021X_EAPOL
|
|
|
|
if (wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA &&
|
|
|
|
wpa_s->current_ssid &&
|
|
|
|
!(wpa_s->current_ssid->eapol_flags &
|
|
|
|
(EAPOL_FLAG_REQUIRE_KEY_UNICAST |
|
|
|
|
EAPOL_FLAG_REQUIRE_KEY_BROADCAST))) {
|
|
|
|
/* IEEE 802.1X, but not using dynamic WEP keys (i.e., either
|
|
|
|
* plaintext or static WEP keys). */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif /* IEEE8021X_EAPOL */
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* wpa_supplicant_scard_init - Initialize SIM/USIM access with PC/SC
|
|
|
|
* @wpa_s: pointer to wpa_supplicant data
|
|
|
|
* @ssid: Configuration data for the network
|
|
|
|
* Returns: 0 on success, -1 on failure
|
|
|
|
*
|
|
|
|
* This function is called when starting authentication with a network that is
|
|
|
|
* configured to use PC/SC for SIM/USIM access (EAP-SIM or EAP-AKA).
|
|
|
|
*/
|
|
|
|
int wpa_supplicant_scard_init(struct wpa_supplicant *wpa_s,
|
|
|
|
struct wpa_ssid *ssid)
|
|
|
|
{
|
|
|
|
#ifdef IEEE8021X_EAPOL
|
2011-10-23 11:24:36 +02:00
|
|
|
#ifdef PCSC_FUNCS
|
2013-08-31 15:11:48 +02:00
|
|
|
int aka = 0, sim = 0;
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2014-03-28 14:41:36 +01:00
|
|
|
if ((ssid != NULL && ssid->eap.pcsc == NULL) ||
|
|
|
|
wpa_s->scard != NULL || wpa_s->conf->external_sim)
|
2008-02-28 02:34:43 +01:00
|
|
|
return 0;
|
|
|
|
|
2014-03-28 14:41:36 +01:00
|
|
|
if (ssid == NULL || ssid->eap.eap_methods == NULL) {
|
2008-02-28 02:34:43 +01:00
|
|
|
sim = 1;
|
|
|
|
aka = 1;
|
|
|
|
} else {
|
|
|
|
struct eap_method_type *eap = ssid->eap.eap_methods;
|
|
|
|
while (eap->vendor != EAP_VENDOR_IETF ||
|
|
|
|
eap->method != EAP_TYPE_NONE) {
|
|
|
|
if (eap->vendor == EAP_VENDOR_IETF) {
|
|
|
|
if (eap->method == EAP_TYPE_SIM)
|
|
|
|
sim = 1;
|
2012-05-05 13:19:13 +02:00
|
|
|
else if (eap->method == EAP_TYPE_AKA ||
|
|
|
|
eap->method == EAP_TYPE_AKA_PRIME)
|
2008-02-28 02:34:43 +01:00
|
|
|
aka = 1;
|
|
|
|
}
|
|
|
|
eap++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (eap_peer_get_eap_method(EAP_VENDOR_IETF, EAP_TYPE_SIM) == NULL)
|
|
|
|
sim = 0;
|
2012-05-05 13:19:13 +02:00
|
|
|
if (eap_peer_get_eap_method(EAP_VENDOR_IETF, EAP_TYPE_AKA) == NULL &&
|
|
|
|
eap_peer_get_eap_method(EAP_VENDOR_IETF, EAP_TYPE_AKA_PRIME) ==
|
|
|
|
NULL)
|
2008-02-28 02:34:43 +01:00
|
|
|
aka = 0;
|
|
|
|
|
|
|
|
if (!sim && !aka) {
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Selected network is configured to "
|
|
|
|
"use SIM, but neither EAP-SIM nor EAP-AKA are "
|
|
|
|
"enabled");
|
2008-02-28 02:34:43 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Selected network is configured to use SIM "
|
|
|
|
"(sim=%d aka=%d) - initialize PCSC", sim, aka);
|
2013-08-31 15:11:48 +02:00
|
|
|
|
2014-06-21 21:45:31 +02:00
|
|
|
wpa_s->scard = scard_init(wpa_s->conf->pcsc_reader);
|
2008-02-28 02:34:43 +01:00
|
|
|
if (wpa_s->scard == NULL) {
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_msg(wpa_s, MSG_WARNING, "Failed to initialize SIM "
|
|
|
|
"(pcsc-lite)");
|
2008-02-28 02:34:43 +01:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
wpa_sm_set_scard_ctx(wpa_s->wpa, wpa_s->scard);
|
|
|
|
eapol_sm_register_scard_ctx(wpa_s->eapol, wpa_s->scard);
|
2011-10-23 11:24:36 +02:00
|
|
|
#endif /* PCSC_FUNCS */
|
2008-02-28 02:34:43 +01:00
|
|
|
#endif /* IEEE8021X_EAPOL */
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef CONFIG_NO_SCAN_PROCESSING
|
2013-08-23 18:27:25 +02:00
|
|
|
|
2020-02-29 15:52:39 +01:00
|
|
|
#ifdef CONFIG_WEP
|
2013-08-23 18:27:25 +02:00
|
|
|
static int has_wep_key(struct wpa_ssid *ssid)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < NUM_WEP_KEYS; i++) {
|
|
|
|
if (ssid->wep_key_len[i])
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2020-02-29 15:52:39 +01:00
|
|
|
#endif /* CONFIG_WEP */
|
2013-08-23 18:27:25 +02:00
|
|
|
|
|
|
|
|
2012-09-02 18:56:57 +02:00
|
|
|
static int wpa_supplicant_match_privacy(struct wpa_bss *bss,
|
2008-02-28 02:34:43 +01:00
|
|
|
struct wpa_ssid *ssid)
|
|
|
|
{
|
2013-08-23 18:27:25 +02:00
|
|
|
int privacy = 0;
|
2008-02-28 02:34:43 +01:00
|
|
|
|
|
|
|
if (ssid->mixed_cell)
|
|
|
|
return 1;
|
|
|
|
|
2009-02-17 09:17:24 +01:00
|
|
|
#ifdef CONFIG_WPS
|
|
|
|
if (ssid->key_mgmt & WPA_KEY_MGMT_WPS)
|
|
|
|
return 1;
|
|
|
|
#endif /* CONFIG_WPS */
|
|
|
|
|
2018-01-13 02:56:26 +01:00
|
|
|
#ifdef CONFIG_OWE
|
|
|
|
if ((ssid->key_mgmt & WPA_KEY_MGMT_OWE) && !ssid->owe_only)
|
|
|
|
return 1;
|
|
|
|
#endif /* CONFIG_OWE */
|
|
|
|
|
2020-02-29 15:52:39 +01:00
|
|
|
#ifdef CONFIG_WEP
|
2013-08-23 18:27:25 +02:00
|
|
|
if (has_wep_key(ssid))
|
|
|
|
privacy = 1;
|
2020-02-29 15:52:39 +01:00
|
|
|
#endif /* CONFIG_WEP */
|
2013-08-23 18:27:25 +02:00
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
#ifdef IEEE8021X_EAPOL
|
|
|
|
if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) &&
|
|
|
|
ssid->eapol_flags & (EAPOL_FLAG_REQUIRE_KEY_UNICAST |
|
|
|
|
EAPOL_FLAG_REQUIRE_KEY_BROADCAST))
|
|
|
|
privacy = 1;
|
|
|
|
#endif /* IEEE8021X_EAPOL */
|
|
|
|
|
2011-06-23 14:39:00 +02:00
|
|
|
if (wpa_key_mgmt_wpa(ssid->key_mgmt))
|
|
|
|
privacy = 1;
|
|
|
|
|
2013-07-23 20:24:05 +02:00
|
|
|
if (ssid->key_mgmt & WPA_KEY_MGMT_OSEN)
|
|
|
|
privacy = 1;
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
if (bss->caps & IEEE80211_CAP_PRIVACY)
|
|
|
|
return privacy;
|
|
|
|
return !privacy;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-01-23 12:10:58 +01:00
|
|
|
static int wpa_supplicant_ssid_bss_match(struct wpa_supplicant *wpa_s,
|
|
|
|
struct wpa_ssid *ssid,
|
2016-11-13 17:22:38 +01:00
|
|
|
struct wpa_bss *bss, int debug_print)
|
2008-02-28 02:34:43 +01:00
|
|
|
{
|
|
|
|
struct wpa_ie_data ie;
|
|
|
|
int proto_match = 0;
|
|
|
|
const u8 *rsn_ie, *wpa_ie;
|
2008-11-29 21:06:34 +01:00
|
|
|
int ret;
|
2020-02-29 15:52:39 +01:00
|
|
|
#ifdef CONFIG_WEP
|
2010-11-08 20:14:32 +01:00
|
|
|
int wep_ok;
|
2020-02-29 15:52:39 +01:00
|
|
|
#endif /* CONFIG_WEP */
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2009-01-23 12:10:58 +01:00
|
|
|
ret = wpas_wps_ssid_bss_match(wpa_s, ssid, bss);
|
2008-11-29 21:06:34 +01:00
|
|
|
if (ret >= 0)
|
|
|
|
return ret;
|
2008-11-23 18:34:26 +01:00
|
|
|
|
2020-02-29 15:52:39 +01:00
|
|
|
#ifdef CONFIG_WEP
|
2010-11-08 20:14:32 +01:00
|
|
|
/* Allow TSN if local configuration accepts WEP use without WPA/WPA2 */
|
|
|
|
wep_ok = !wpa_key_mgmt_wpa(ssid->key_mgmt) &&
|
|
|
|
(((ssid->key_mgmt & WPA_KEY_MGMT_NONE) &&
|
|
|
|
ssid->wep_key_len[ssid->wep_tx_keyidx] > 0) ||
|
|
|
|
(ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA));
|
2020-02-29 15:52:39 +01:00
|
|
|
#endif /* CONFIG_WEP */
|
2010-11-08 20:14:32 +01:00
|
|
|
|
2012-09-02 18:56:57 +02:00
|
|
|
rsn_ie = wpa_bss_get_ie(bss, WLAN_EID_RSN);
|
2018-05-29 19:09:53 +02:00
|
|
|
while ((ssid->proto & (WPA_PROTO_RSN | WPA_PROTO_OSEN)) && rsn_ie) {
|
2008-02-28 02:34:43 +01:00
|
|
|
proto_match++;
|
|
|
|
|
|
|
|
if (wpa_parse_wpa_ie(rsn_ie, 2 + rsn_ie[1], &ie)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip RSN IE - parse failed");
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
}
|
2019-02-06 11:33:35 +01:00
|
|
|
if (!ie.has_pairwise)
|
|
|
|
ie.pairwise_cipher = wpa_default_rsn_cipher(bss->freq);
|
|
|
|
if (!ie.has_group)
|
|
|
|
ie.group_cipher = wpa_default_rsn_cipher(bss->freq);
|
2010-11-08 20:14:32 +01:00
|
|
|
|
2020-02-29 15:52:39 +01:00
|
|
|
#ifdef CONFIG_WEP
|
2010-11-08 20:14:32 +01:00
|
|
|
if (wep_ok &&
|
|
|
|
(ie.group_cipher & (WPA_CIPHER_WEP40 | WPA_CIPHER_WEP104)))
|
|
|
|
{
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" selected based on TSN in RSN IE");
|
2010-11-08 20:14:32 +01:00
|
|
|
return 1;
|
|
|
|
}
|
2020-02-29 15:52:39 +01:00
|
|
|
#endif /* CONFIG_WEP */
|
2010-11-08 20:14:32 +01:00
|
|
|
|
2018-05-29 19:09:53 +02:00
|
|
|
if (!(ie.proto & ssid->proto) &&
|
|
|
|
!(ssid->proto & WPA_PROTO_OSEN)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip RSN IE - proto mismatch");
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(ie.pairwise_cipher & ssid->pairwise_cipher)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip RSN IE - PTK cipher mismatch");
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(ie.group_cipher & ssid->group_cipher)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip RSN IE - GTK cipher mismatch");
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2017-09-26 16:36:33 +02:00
|
|
|
if (ssid->group_mgmt_cipher &&
|
|
|
|
!(ie.mgmt_group_cipher & ssid->group_mgmt_cipher)) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip RSN IE - group mgmt cipher mismatch");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
if (!(ie.key_mgmt & ssid->key_mgmt)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip RSN IE - key mgmt mismatch");
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-08-30 13:59:39 +02:00
|
|
|
if (!(ie.capabilities & WPA_CAPABILITY_MFPC) &&
|
2015-01-26 16:40:22 +01:00
|
|
|
wpas_get_ssid_pmf(wpa_s, ssid) ==
|
2012-11-24 21:21:29 +01:00
|
|
|
MGMT_FRAME_PROTECTION_REQUIRED) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip RSN IE - no mgmt frame protection");
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
}
|
2015-10-25 14:12:58 +01:00
|
|
|
if ((ie.capabilities & WPA_CAPABILITY_MFPR) &&
|
|
|
|
wpas_get_ssid_pmf(wpa_s, ssid) ==
|
|
|
|
NO_MGMT_FRAME_PROTECTION) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip RSN IE - no mgmt frame protection enabled but AP requires it");
|
2015-10-25 14:12:58 +01:00
|
|
|
break;
|
|
|
|
}
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" selected based on RSN IE");
|
2008-02-28 02:34:43 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2018-01-13 02:56:26 +01:00
|
|
|
if (wpas_get_ssid_pmf(wpa_s, ssid) == MGMT_FRAME_PROTECTION_REQUIRED &&
|
|
|
|
(!(ssid->key_mgmt & WPA_KEY_MGMT_OWE) || ssid->owe_only)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - MFP Required but network not MFP Capable");
|
2016-04-30 11:52:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-09-02 18:56:57 +02:00
|
|
|
wpa_ie = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
|
2008-02-28 02:34:43 +01:00
|
|
|
while ((ssid->proto & WPA_PROTO_WPA) && wpa_ie) {
|
|
|
|
proto_match++;
|
|
|
|
|
|
|
|
if (wpa_parse_wpa_ie(wpa_ie, 2 + wpa_ie[1], &ie)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip WPA IE - parse failed");
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
}
|
2010-11-08 20:14:32 +01:00
|
|
|
|
2020-02-29 15:52:39 +01:00
|
|
|
#ifdef CONFIG_WEP
|
2010-11-08 20:14:32 +01:00
|
|
|
if (wep_ok &&
|
|
|
|
(ie.group_cipher & (WPA_CIPHER_WEP40 | WPA_CIPHER_WEP104)))
|
|
|
|
{
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" selected based on TSN in WPA IE");
|
2010-11-08 20:14:32 +01:00
|
|
|
return 1;
|
|
|
|
}
|
2020-02-29 15:52:39 +01:00
|
|
|
#endif /* CONFIG_WEP */
|
2010-11-08 20:14:32 +01:00
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
if (!(ie.proto & ssid->proto)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip WPA IE - proto mismatch");
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(ie.pairwise_cipher & ssid->pairwise_cipher)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip WPA IE - PTK cipher mismatch");
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(ie.group_cipher & ssid->group_cipher)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip WPA IE - GTK cipher mismatch");
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(ie.key_mgmt & ssid->key_mgmt)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip WPA IE - key mgmt mismatch");
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" selected based on WPA IE");
|
2008-02-28 02:34:43 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2012-08-15 18:34:04 +02:00
|
|
|
if ((ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA) && !wpa_ie &&
|
|
|
|
!rsn_ie) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" allow for non-WPA IEEE 802.1X");
|
2012-08-15 18:34:04 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2018-01-13 02:56:26 +01:00
|
|
|
#ifdef CONFIG_OWE
|
|
|
|
if ((ssid->key_mgmt & WPA_KEY_MGMT_OWE) && !ssid->owe_only &&
|
|
|
|
!wpa_ie && !rsn_ie) {
|
2018-09-06 19:27:29 +02:00
|
|
|
if (wpa_s->owe_transition_select &&
|
|
|
|
wpa_bss_get_vendor_ie(bss, OWE_IE_VENDOR_TYPE) &&
|
|
|
|
ssid->owe_transition_bss_select_count + 1 <=
|
|
|
|
MAX_OWE_TRANSITION_BSS_SELECT_COUNT) {
|
|
|
|
ssid->owe_transition_bss_select_count++;
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip OWE transition BSS (selection count %d does not exceed %d)",
|
|
|
|
ssid->owe_transition_bss_select_count,
|
|
|
|
MAX_OWE_TRANSITION_BSS_SELECT_COUNT);
|
2018-10-12 18:33:51 +02:00
|
|
|
wpa_s->owe_transition_search = 1;
|
2018-09-06 19:27:29 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2018-01-13 02:56:26 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" allow in OWE transition mode");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_OWE */
|
|
|
|
|
2010-12-28 07:56:23 +01:00
|
|
|
if ((ssid->proto & (WPA_PROTO_WPA | WPA_PROTO_RSN)) &&
|
2010-12-30 17:27:33 +01:00
|
|
|
wpa_key_mgmt_wpa(ssid->key_mgmt) && proto_match == 0) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - no WPA/RSN proto match");
|
2010-12-28 07:56:23 +01:00
|
|
|
return 0;
|
|
|
|
}
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2013-07-23 20:24:05 +02:00
|
|
|
if ((ssid->key_mgmt & WPA_KEY_MGMT_OSEN) &&
|
|
|
|
wpa_bss_get_vendor_ie(bss, OSEN_IE_VENDOR_TYPE)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, " allow in OSEN");
|
2013-07-23 20:24:05 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2011-04-08 18:13:58 +02:00
|
|
|
if (!wpa_key_mgmt_wpa(ssid->key_mgmt)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, " allow in non-WPA/WPA2");
|
2011-04-08 18:13:58 +02:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" reject due to mismatch with WPA/WPA2");
|
2011-04-08 18:13:58 +02:00
|
|
|
|
|
|
|
return 0;
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-03-27 06:45:50 +01:00
|
|
|
static int freq_allowed(int *freqs, int freq)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (freqs == NULL)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
for (i = 0; freqs[i]; i++)
|
|
|
|
if (freqs[i] == freq)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-01-20 19:23:48 +01:00
|
|
|
static int rate_match(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
|
|
|
|
struct wpa_bss *bss, int debug_print)
|
2011-10-23 10:58:54 +02:00
|
|
|
{
|
|
|
|
const struct hostapd_hw_modes *mode = NULL, *modes;
|
|
|
|
const u8 scan_ie[2] = { WLAN_EID_SUPP_RATES, WLAN_EID_EXT_SUPP_RATES };
|
|
|
|
const u8 *rate_ie;
|
|
|
|
int i, j, k;
|
|
|
|
|
2011-10-30 10:41:22 +01:00
|
|
|
if (bss->freq == 0)
|
|
|
|
return 1; /* Cannot do matching without knowing band */
|
|
|
|
|
2011-10-23 10:58:54 +02:00
|
|
|
modes = wpa_s->hw.modes;
|
|
|
|
if (modes == NULL) {
|
|
|
|
/*
|
|
|
|
* The driver does not provide any additional information
|
|
|
|
* about the utilized hardware, so allow the connection attempt
|
|
|
|
* to continue.
|
|
|
|
*/
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < wpa_s->hw.num_modes; i++) {
|
|
|
|
for (j = 0; j < modes[i].num_channels; j++) {
|
|
|
|
int freq = modes[i].channels[j].freq;
|
|
|
|
if (freq == bss->freq) {
|
|
|
|
if (mode &&
|
|
|
|
mode->mode == HOSTAPD_MODE_IEEE80211G)
|
|
|
|
break; /* do not allow 802.11b replace
|
|
|
|
* 802.11g */
|
|
|
|
mode = &modes[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mode == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for (i = 0; i < (int) sizeof(scan_ie); i++) {
|
2012-09-02 18:56:57 +02:00
|
|
|
rate_ie = wpa_bss_get_ie(bss, scan_ie[i]);
|
2011-10-23 10:58:54 +02:00
|
|
|
if (rate_ie == NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (j = 2; j < rate_ie[1] + 2; j++) {
|
|
|
|
int flagged = !!(rate_ie[j] & 0x80);
|
|
|
|
int r = (rate_ie[j] & 0x7f) * 5;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* IEEE Std 802.11n-2009 7.3.2.2:
|
|
|
|
* The new BSS Membership selector value is encoded
|
|
|
|
* like a legacy basic rate, but it is not a rate and
|
|
|
|
* only indicates if the BSS members are required to
|
|
|
|
* support the mandatory features of Clause 20 [HT PHY]
|
|
|
|
* in order to join the BSS.
|
|
|
|
*/
|
|
|
|
if (flagged && ((rate_ie[j] & 0x7f) ==
|
|
|
|
BSS_MEMBERSHIP_SELECTOR_HT_PHY)) {
|
|
|
|
if (!ht_supported(mode)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" hardware does not support HT PHY");
|
2011-10-23 10:58:54 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2013-07-20 16:28:42 +02:00
|
|
|
/* There's also a VHT selector for 802.11ac */
|
|
|
|
if (flagged && ((rate_ie[j] & 0x7f) ==
|
|
|
|
BSS_MEMBERSHIP_SELECTOR_VHT_PHY)) {
|
|
|
|
if (!vht_supported(mode)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" hardware does not support VHT PHY");
|
2013-07-20 16:28:42 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2019-09-07 14:24:24 +02:00
|
|
|
#ifdef CONFIG_SAE
|
|
|
|
if (flagged && ((rate_ie[j] & 0x7f) ==
|
|
|
|
BSS_MEMBERSHIP_SELECTOR_SAE_H2E_ONLY)) {
|
2020-01-20 19:23:48 +01:00
|
|
|
if (wpa_s->conf->sae_pwe == 0 &&
|
2020-01-20 20:15:04 +01:00
|
|
|
!ssid->sae_password_id &&
|
2020-01-20 19:23:48 +01:00
|
|
|
wpa_key_mgmt_sae(ssid->key_mgmt)) {
|
2019-09-07 14:24:24 +02:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" SAE H2E disabled");
|
2019-12-06 16:13:59 +01:00
|
|
|
#ifdef CONFIG_TESTING_OPTIONS
|
|
|
|
if (wpa_s->ignore_sae_h2e_only) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"TESTING: Ignore SAE H2E requirement mismatch");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_TESTING_OPTIONS */
|
2019-09-07 14:24:24 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SAE */
|
|
|
|
|
2011-10-23 10:58:54 +02:00
|
|
|
if (!flagged)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* check for legacy basic rates */
|
|
|
|
for (k = 0; k < mode->num_rates; k++) {
|
|
|
|
if (mode->rates[k] == r)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (k == mode->num_rates) {
|
|
|
|
/*
|
|
|
|
* IEEE Std 802.11-2007 7.3.2.2 demands that in
|
|
|
|
* order to join a BSS all required rates
|
|
|
|
* have to be supported by the hardware.
|
|
|
|
*/
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" hardware does not support required rate %d.%d Mbps (freq=%d mode==%d num_rates=%d)",
|
|
|
|
r / 10, r % 10,
|
|
|
|
bss->freq, mode->mode, mode->num_rates);
|
2011-10-23 10:58:54 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-02-07 15:20:18 +01:00
|
|
|
/*
|
|
|
|
* Test whether BSS is in an ESS.
|
|
|
|
* This is done differently in DMG (60 GHz) and non-DMG bands
|
|
|
|
*/
|
|
|
|
static int bss_is_ess(struct wpa_bss *bss)
|
|
|
|
{
|
|
|
|
if (bss_is_dmg(bss)) {
|
|
|
|
return (bss->caps & IEEE80211_CAP_DMG_MASK) ==
|
|
|
|
IEEE80211_CAP_DMG_AP;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ((bss->caps & (IEEE80211_CAP_ESS | IEEE80211_CAP_IBSS)) ==
|
|
|
|
IEEE80211_CAP_ESS);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-01-05 21:10:16 +01:00
|
|
|
static int match_mac_mask(const u8 *addr_a, const u8 *addr_b, const u8 *mask)
|
|
|
|
{
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
for (i = 0; i < ETH_ALEN; i++) {
|
|
|
|
if ((addr_a[i] & mask[i]) != (addr_b[i] & mask[i]))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-01-05 21:08:49 +01:00
|
|
|
static int addr_in_list(const u8 *addr, const u8 *list, size_t num)
|
|
|
|
{
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
for (i = 0; i < num; i++) {
|
2015-01-05 21:10:16 +01:00
|
|
|
const u8 *a = list + i * ETH_ALEN * 2;
|
|
|
|
const u8 *m = a + ETH_ALEN;
|
2015-01-05 21:08:49 +01:00
|
|
|
|
2015-01-05 21:10:16 +01:00
|
|
|
if (match_mac_mask(a, addr, m))
|
2015-01-05 21:08:49 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-10-08 11:32:02 +02:00
|
|
|
static void owe_trans_ssid(struct wpa_supplicant *wpa_s, struct wpa_bss *bss,
|
|
|
|
const u8 **ret_ssid, size_t *ret_ssid_len)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_OWE
|
|
|
|
const u8 *owe, *pos, *end, *bssid;
|
|
|
|
u8 ssid_len;
|
|
|
|
struct wpa_bss *open_bss;
|
|
|
|
|
|
|
|
owe = wpa_bss_get_vendor_ie(bss, OWE_IE_VENDOR_TYPE);
|
|
|
|
if (!owe || !wpa_bss_get_ie(bss, WLAN_EID_RSN))
|
|
|
|
return;
|
|
|
|
|
|
|
|
pos = owe + 6;
|
|
|
|
end = owe + 2 + owe[1];
|
|
|
|
|
|
|
|
if (end - pos < ETH_ALEN + 1)
|
|
|
|
return;
|
|
|
|
bssid = pos;
|
|
|
|
pos += ETH_ALEN;
|
|
|
|
ssid_len = *pos++;
|
|
|
|
if (end - pos < ssid_len || ssid_len > SSID_MAX_LEN)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Match the profile SSID against the OWE transition mode SSID on the
|
|
|
|
* open network. */
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "OWE: transition mode BSSID: " MACSTR
|
|
|
|
" SSID: %s", MAC2STR(bssid), wpa_ssid_txt(pos, ssid_len));
|
|
|
|
*ret_ssid = pos;
|
|
|
|
*ret_ssid_len = ssid_len;
|
|
|
|
|
2020-03-08 15:13:35 +01:00
|
|
|
if (!(bss->flags & WPA_BSS_OWE_TRANSITION)) {
|
|
|
|
struct wpa_ssid *ssid;
|
|
|
|
|
|
|
|
for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
|
|
|
|
if (wpas_network_disabled(wpa_s, ssid))
|
|
|
|
continue;
|
|
|
|
if (ssid->ssid_len == ssid_len &&
|
|
|
|
os_memcmp(ssid->ssid, pos, ssid_len) == 0) {
|
|
|
|
/* OWE BSS in transition mode for a currently
|
|
|
|
* enabled OWE network. */
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"OWE: transition mode OWE SSID for active OWE profile");
|
|
|
|
bss->flags |= WPA_BSS_OWE_TRANSITION;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-10-08 11:32:02 +02:00
|
|
|
if (bss->ssid_len > 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
open_bss = wpa_bss_get_bssid_latest(wpa_s, bssid);
|
|
|
|
if (!open_bss)
|
|
|
|
return;
|
|
|
|
if (ssid_len != open_bss->ssid_len ||
|
|
|
|
os_memcmp(pos, open_bss->ssid, ssid_len) != 0) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"OWE: transition mode SSID mismatch: %s",
|
|
|
|
wpa_ssid_txt(open_bss->ssid, open_bss->ssid_len));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
owe = wpa_bss_get_vendor_ie(open_bss, OWE_IE_VENDOR_TYPE);
|
|
|
|
if (!owe || wpa_bss_get_ie(open_bss, WLAN_EID_RSN)) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"OWE: transition mode open BSS unexpected info");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
pos = owe + 6;
|
|
|
|
end = owe + 2 + owe[1];
|
|
|
|
|
|
|
|
if (end - pos < ETH_ALEN + 1)
|
|
|
|
return;
|
|
|
|
if (os_memcmp(pos, bss->bssid, ETH_ALEN) != 0) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"OWE: transition mode BSSID mismatch: " MACSTR,
|
|
|
|
MAC2STR(pos));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
pos += ETH_ALEN;
|
|
|
|
ssid_len = *pos++;
|
|
|
|
if (end - pos < ssid_len || ssid_len > SSID_MAX_LEN)
|
|
|
|
return;
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "OWE: learned transition mode OWE SSID: %s",
|
|
|
|
wpa_ssid_txt(pos, ssid_len));
|
|
|
|
os_memcpy(bss->ssid, pos, ssid_len);
|
|
|
|
bss->ssid_len = ssid_len;
|
2020-03-07 17:03:32 +01:00
|
|
|
bss->flags |= WPA_BSS_OWE_TRANSITION;
|
2017-10-08 11:32:02 +02:00
|
|
|
#endif /* CONFIG_OWE */
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-12-11 13:57:47 +01:00
|
|
|
static int disabled_freq(struct wpa_supplicant *wpa_s, int freq)
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
if (!wpa_s->hw.modes || !wpa_s->hw.num_modes)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
for (j = 0; j < wpa_s->hw.num_modes; j++) {
|
|
|
|
struct hostapd_hw_modes *mode = &wpa_s->hw.modes[j];
|
|
|
|
|
|
|
|
for (i = 0; i < mode->num_channels; i++) {
|
|
|
|
struct hostapd_channel_data *chan = &mode->channels[i];
|
|
|
|
|
|
|
|
if (chan->freq == freq)
|
|
|
|
return !!(chan->flag & HOSTAPD_CHAN_DISABLED);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-06-07 15:49:07 +02:00
|
|
|
static bool wpa_scan_res_ok(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
|
|
|
|
const u8 *match_ssid, size_t match_ssid_len,
|
2021-02-07 16:02:37 +01:00
|
|
|
struct wpa_bss *bss, int bssid_ignore_count,
|
2020-06-07 15:49:07 +02:00
|
|
|
bool debug_print);
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SAE_PK
|
|
|
|
static bool sae_pk_acceptable_bss_with_pk(struct wpa_supplicant *wpa_s,
|
|
|
|
struct wpa_bss *orig_bss,
|
|
|
|
struct wpa_ssid *ssid,
|
|
|
|
const u8 *match_ssid,
|
|
|
|
size_t match_ssid_len)
|
|
|
|
{
|
|
|
|
struct wpa_bss *bss;
|
|
|
|
|
|
|
|
dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
|
wpa_supplicant: Implement time-based blacklisting
wpa_supplicant keeps a blacklist of BSSs in order to prevent repeated
associations to problematic APs*. Currently, this blacklist is
completely cleared whenever we successfully connect to any AP. This
causes problematic behavior when in the presence of both a bad AP and
a good AP. The device can repeatedly attempt to roam to the bad AP
because it is clearing the blacklist every time it connects to the good
AP. This results in the connection constantly ping-ponging between the
APs, leaving the user stuck without connection.
Instead of clearing the blacklist, implement timeout functionality which
allows association attempts to blacklisted APs after some time has
passed. Each time a BSS would be added to the blacklist, increase the
duration of this timeout exponentially, up to a cap of 1800 seconds.
This means that the device will no longer be able to immediately attempt
to roam back to a bad AP whenever it successfully connects to any other
AP.
Other details:
The algorithm for building up the blacklist count and timeout duration
on a given AP has been designed to be minimally obtrusive. Starting with
a fresh blacklist, the device may attempt to connect to a problematic AP
no more than 6 times in any ~45 minute period. Once an AP has reached a
blacklist count >= 6, the device may attempt to connect to it no more
than once every 30 minutes. The goal of these limits is to find an
ideal balance between minimizing connection attempts to bad APs while
still trying them out occasionally to see if the problems have stopped.
The only exception to the above limits is that the blacklist is still
completely cleared whenever there are no APs available in a scan. This
means that if all nearby APs have been blacklisted, all APs will be
completely exonerated regardless of their blacklist counts or how close
their blacklist entries are to expiring. When all nearby APs have been
blacklisted we know that every nearby AP is in some way problematic.
Once we know that every AP is causing problems, it doesn't really make
sense to sort them beyond that because the blacklist count and timeout
duration don't necessarily reflect the degree to which an AP is
problematic (i.e. they can be manipulated by external factors such as
the user physically moving around). Instead, its best to restart the
blacklist and let the normal roaming algorithm take over to maximize
our chance of getting the best possible connection quality.
As stated above, the time-based blacklisting algorithm is designed to
be minimally obtrusive to user experience, so occasionally restarting
the process is not too impactful on the user.
*problematic AP: rejects new clients, frequently de-auths clients, very
poor connection quality, etc.
Signed-off-by: Kevin Lund <kglund@google.com>
Signed-off-by: Brian Norris <briannorris@chromium.org>
2020-06-11 23:11:16 +02:00
|
|
|
int count;
|
2020-06-07 15:49:07 +02:00
|
|
|
const u8 *ie;
|
|
|
|
u8 rsnxe_capa = 0;
|
|
|
|
|
|
|
|
if (bss == orig_bss)
|
|
|
|
continue;
|
|
|
|
ie = wpa_bss_get_ie(bss, WLAN_EID_RSNX);
|
|
|
|
if (ie && ie[1] >= 1)
|
|
|
|
rsnxe_capa = ie[2];
|
|
|
|
if (!(rsnxe_capa & BIT(WLAN_RSNX_CAPAB_SAE_PK)))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* TODO: Could be more thorough in checking what kind of
|
|
|
|
* signal strength or throughput estimate would be acceptable
|
|
|
|
* compared to the originally selected BSS. */
|
|
|
|
if (bss->est_throughput < 2000)
|
|
|
|
return false;
|
|
|
|
|
2021-02-07 16:02:37 +01:00
|
|
|
count = wpa_bssid_ignore_is_listed(wpa_s, bss->bssid);
|
2020-06-07 15:49:07 +02:00
|
|
|
if (wpa_scan_res_ok(wpa_s, ssid, match_ssid, match_ssid_len,
|
wpa_supplicant: Implement time-based blacklisting
wpa_supplicant keeps a blacklist of BSSs in order to prevent repeated
associations to problematic APs*. Currently, this blacklist is
completely cleared whenever we successfully connect to any AP. This
causes problematic behavior when in the presence of both a bad AP and
a good AP. The device can repeatedly attempt to roam to the bad AP
because it is clearing the blacklist every time it connects to the good
AP. This results in the connection constantly ping-ponging between the
APs, leaving the user stuck without connection.
Instead of clearing the blacklist, implement timeout functionality which
allows association attempts to blacklisted APs after some time has
passed. Each time a BSS would be added to the blacklist, increase the
duration of this timeout exponentially, up to a cap of 1800 seconds.
This means that the device will no longer be able to immediately attempt
to roam back to a bad AP whenever it successfully connects to any other
AP.
Other details:
The algorithm for building up the blacklist count and timeout duration
on a given AP has been designed to be minimally obtrusive. Starting with
a fresh blacklist, the device may attempt to connect to a problematic AP
no more than 6 times in any ~45 minute period. Once an AP has reached a
blacklist count >= 6, the device may attempt to connect to it no more
than once every 30 minutes. The goal of these limits is to find an
ideal balance between minimizing connection attempts to bad APs while
still trying them out occasionally to see if the problems have stopped.
The only exception to the above limits is that the blacklist is still
completely cleared whenever there are no APs available in a scan. This
means that if all nearby APs have been blacklisted, all APs will be
completely exonerated regardless of their blacklist counts or how close
their blacklist entries are to expiring. When all nearby APs have been
blacklisted we know that every nearby AP is in some way problematic.
Once we know that every AP is causing problems, it doesn't really make
sense to sort them beyond that because the blacklist count and timeout
duration don't necessarily reflect the degree to which an AP is
problematic (i.e. they can be manipulated by external factors such as
the user physically moving around). Instead, its best to restart the
blacklist and let the normal roaming algorithm take over to maximize
our chance of getting the best possible connection quality.
As stated above, the time-based blacklisting algorithm is designed to
be minimally obtrusive to user experience, so occasionally restarting
the process is not too impactful on the user.
*problematic AP: rejects new clients, frequently de-auths clients, very
poor connection quality, etc.
Signed-off-by: Kevin Lund <kglund@google.com>
Signed-off-by: Brian Norris <briannorris@chromium.org>
2020-06-11 23:11:16 +02:00
|
|
|
bss, count, 0))
|
2020-06-07 15:49:07 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SAE_PK */
|
|
|
|
|
|
|
|
|
2020-06-07 15:30:32 +02:00
|
|
|
static bool wpa_scan_res_ok(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid,
|
|
|
|
const u8 *match_ssid, size_t match_ssid_len,
|
2021-02-07 16:02:37 +01:00
|
|
|
struct wpa_bss *bss, int bssid_ignore_count,
|
2020-06-07 15:30:32 +02:00
|
|
|
bool debug_print)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
bool wpa, check_ssid, osen, rsn_osen = false;
|
|
|
|
struct wpa_ie_data data;
|
|
|
|
#ifdef CONFIG_MBO
|
|
|
|
const u8 *assoc_disallow;
|
|
|
|
#endif /* CONFIG_MBO */
|
|
|
|
#ifdef CONFIG_SAE
|
|
|
|
u8 rsnxe_capa = 0;
|
|
|
|
#endif /* CONFIG_SAE */
|
|
|
|
const u8 *ie;
|
|
|
|
|
|
|
|
ie = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
|
|
|
|
wpa = ie && ie[1];
|
|
|
|
ie = wpa_bss_get_ie(bss, WLAN_EID_RSN);
|
|
|
|
wpa |= ie && ie[1];
|
|
|
|
if (ie && wpa_parse_wpa_ie_rsn(ie, 2 + ie[1], &data) == 0 &&
|
|
|
|
(data.key_mgmt & WPA_KEY_MGMT_OSEN))
|
|
|
|
rsn_osen = true;
|
|
|
|
ie = wpa_bss_get_vendor_ie(bss, OSEN_IE_VENDOR_TYPE);
|
|
|
|
osen = ie != NULL;
|
|
|
|
|
|
|
|
#ifdef CONFIG_SAE
|
|
|
|
ie = wpa_bss_get_ie(bss, WLAN_EID_RSNX);
|
|
|
|
if (ie && ie[1] >= 1)
|
|
|
|
rsnxe_capa = ie[2];
|
|
|
|
#endif /* CONFIG_SAE */
|
|
|
|
|
|
|
|
check_ssid = wpa || ssid->ssid_len > 0;
|
|
|
|
|
|
|
|
if (wpas_network_disabled(wpa_s, ssid)) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, " skip - disabled");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
res = wpas_temp_disabled(wpa_s, ssid);
|
|
|
|
if (res > 0) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - disabled temporarily for %d second(s)",
|
|
|
|
res);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_WPS
|
2021-02-07 16:02:37 +01:00
|
|
|
if ((ssid->key_mgmt & WPA_KEY_MGMT_WPS) && bssid_ignore_count) {
|
2020-06-07 15:30:32 +02:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
2021-02-07 16:02:37 +01:00
|
|
|
" skip - BSSID ignored (WPS)");
|
2020-06-07 15:30:32 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wpa && ssid->ssid_len == 0 &&
|
|
|
|
wpas_wps_ssid_wildcard_ok(wpa_s, ssid, bss))
|
|
|
|
check_ssid = false;
|
|
|
|
|
|
|
|
if (!wpa && (ssid->key_mgmt & WPA_KEY_MGMT_WPS)) {
|
|
|
|
/* Only allow wildcard SSID match if an AP advertises active
|
|
|
|
* WPS operation that matches our mode. */
|
|
|
|
check_ssid = ssid->ssid_len > 0 ||
|
|
|
|
!wpas_wps_ssid_wildcard_ok(wpa_s, ssid, bss);
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_WPS */
|
|
|
|
|
|
|
|
if (ssid->bssid_set && ssid->ssid_len == 0 &&
|
|
|
|
os_memcmp(bss->bssid, ssid->bssid, ETH_ALEN) == 0)
|
|
|
|
check_ssid = false;
|
|
|
|
|
|
|
|
if (check_ssid &&
|
|
|
|
(match_ssid_len != ssid->ssid_len ||
|
|
|
|
os_memcmp(match_ssid, ssid->ssid, match_ssid_len) != 0)) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, " skip - SSID mismatch");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ssid->bssid_set &&
|
|
|
|
os_memcmp(bss->bssid, ssid->bssid, ETH_ALEN) != 0) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, " skip - BSSID mismatch");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2021-02-07 15:10:18 +01:00
|
|
|
/* check the list of BSSIDs to ignore */
|
|
|
|
if (ssid->num_bssid_ignore &&
|
|
|
|
addr_in_list(bss->bssid, ssid->bssid_ignore,
|
|
|
|
ssid->num_bssid_ignore)) {
|
2020-06-07 15:30:32 +02:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
2021-02-07 15:10:18 +01:00
|
|
|
" skip - BSSID configured to be ignored");
|
2020-06-07 15:30:32 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2021-02-07 15:10:18 +01:00
|
|
|
/* if there is a list of accepted BSSIDs, only accept those APs */
|
|
|
|
if (ssid->num_bssid_accept &&
|
|
|
|
!addr_in_list(bss->bssid, ssid->bssid_accept,
|
|
|
|
ssid->num_bssid_accept)) {
|
2020-06-07 15:30:32 +02:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
2021-02-07 15:10:18 +01:00
|
|
|
" skip - BSSID not in list of accepted values");
|
2020-06-07 15:30:32 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!wpa_supplicant_ssid_bss_match(wpa_s, ssid, bss, debug_print))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (!osen && !wpa &&
|
|
|
|
!(ssid->key_mgmt & WPA_KEY_MGMT_NONE) &&
|
|
|
|
!(ssid->key_mgmt & WPA_KEY_MGMT_WPS) &&
|
|
|
|
!(ssid->key_mgmt & WPA_KEY_MGMT_OWE) &&
|
|
|
|
!(ssid->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - non-WPA network not allowed");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_WEP
|
|
|
|
if (wpa && !wpa_key_mgmt_wpa(ssid->key_mgmt) && has_wep_key(ssid)) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - ignore WPA/WPA2 AP for WEP network block");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_WEP */
|
|
|
|
|
|
|
|
if ((ssid->key_mgmt & WPA_KEY_MGMT_OSEN) && !osen && !rsn_osen) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - non-OSEN network not allowed");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!wpa_supplicant_match_privacy(bss, ssid)) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, " skip - privacy mismatch");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ssid->mode != WPAS_MODE_MESH && !bss_is_ess(bss) &&
|
|
|
|
!bss_is_pbss(bss)) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - not ESS, PBSS, or MBSS");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ssid->pbss != 2 && ssid->pbss != bss_is_pbss(bss)) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - PBSS mismatch (ssid %d bss %d)",
|
|
|
|
ssid->pbss, bss_is_pbss(bss));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!freq_allowed(ssid->freq_list, bss->freq)) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - frequency not allowed");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_MESH
|
|
|
|
if (ssid->mode == WPAS_MODE_MESH && ssid->frequency > 0 &&
|
|
|
|
ssid->frequency != bss->freq) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - frequency not allowed (mesh)");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_MESH */
|
|
|
|
|
|
|
|
if (!rate_match(wpa_s, ssid, bss, debug_print)) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - rate sets do not match");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_SAE
|
|
|
|
if ((wpa_s->conf->sae_pwe == 1 || ssid->sae_password_id) &&
|
|
|
|
wpa_s->conf->sae_pwe != 3 && wpa_key_mgmt_sae(ssid->key_mgmt) &&
|
|
|
|
!(rsnxe_capa & BIT(WLAN_RSNX_CAPAB_SAE_H2E))) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - SAE H2E required, but not supported by the AP");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SAE */
|
|
|
|
|
|
|
|
#ifdef CONFIG_SAE_PK
|
|
|
|
if (ssid->sae_pk == SAE_PK_MODE_ONLY &&
|
|
|
|
!(rsnxe_capa & BIT(WLAN_RSNX_CAPAB_SAE_PK))) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - SAE-PK required, but not supported by the AP");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SAE_PK */
|
|
|
|
|
|
|
|
#ifndef CONFIG_IBSS_RSN
|
|
|
|
if (ssid->mode == WPAS_MODE_IBSS &&
|
|
|
|
!(ssid->key_mgmt & (WPA_KEY_MGMT_NONE | WPA_KEY_MGMT_WPA_NONE))) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - IBSS RSN not supported in the build");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif /* !CONFIG_IBSS_RSN */
|
|
|
|
|
|
|
|
#ifdef CONFIG_P2P
|
|
|
|
if (ssid->p2p_group &&
|
|
|
|
!wpa_bss_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE) &&
|
|
|
|
!wpa_bss_get_vendor_ie_beacon(bss, P2P_IE_VENDOR_TYPE)) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, " skip - no P2P IE seen");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!is_zero_ether_addr(ssid->go_p2p_dev_addr)) {
|
|
|
|
struct wpabuf *p2p_ie;
|
|
|
|
u8 dev_addr[ETH_ALEN];
|
|
|
|
|
|
|
|
ie = wpa_bss_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE);
|
|
|
|
if (!ie) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - no P2P element");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
p2p_ie = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
|
|
|
|
if (!p2p_ie) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - could not fetch P2P element");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (p2p_parse_dev_addr_in_p2p_ie(p2p_ie, dev_addr) < 0 ||
|
|
|
|
os_memcmp(dev_addr, ssid->go_p2p_dev_addr, ETH_ALEN) != 0) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - no matching GO P2P Device Address in P2P element");
|
|
|
|
wpabuf_free(p2p_ie);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
wpabuf_free(p2p_ie);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TODO: skip the AP if its P2P IE has Group Formation bit set in the
|
|
|
|
* P2P Group Capability Bitmap and we are not in Group Formation with
|
|
|
|
* that device.
|
|
|
|
*/
|
|
|
|
#endif /* CONFIG_P2P */
|
|
|
|
|
|
|
|
if (os_reltime_before(&bss->last_update, &wpa_s->scan_min_time)) {
|
|
|
|
struct os_reltime diff;
|
|
|
|
|
|
|
|
os_reltime_sub(&wpa_s->scan_min_time, &bss->last_update, &diff);
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - scan result not recent enough (%u.%06u seconds too old)",
|
|
|
|
(unsigned int) diff.sec,
|
|
|
|
(unsigned int) diff.usec);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#ifdef CONFIG_MBO
|
|
|
|
#ifdef CONFIG_TESTING_OPTIONS
|
|
|
|
if (wpa_s->ignore_assoc_disallow)
|
|
|
|
goto skip_assoc_disallow;
|
|
|
|
#endif /* CONFIG_TESTING_OPTIONS */
|
|
|
|
assoc_disallow = wpas_mbo_get_bss_attr(bss, MBO_ATTR_ID_ASSOC_DISALLOW);
|
|
|
|
if (assoc_disallow && assoc_disallow[1] >= 1) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - MBO association disallowed (reason %u)",
|
|
|
|
assoc_disallow[2]);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wpa_is_bss_tmp_disallowed(wpa_s, bss)) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - AP temporarily disallowed");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#ifdef CONFIG_TESTING_OPTIONS
|
|
|
|
skip_assoc_disallow:
|
|
|
|
#endif /* CONFIG_TESTING_OPTIONS */
|
|
|
|
#endif /* CONFIG_MBO */
|
|
|
|
|
|
|
|
#ifdef CONFIG_DPP
|
|
|
|
if ((ssid->key_mgmt & WPA_KEY_MGMT_DPP) &&
|
|
|
|
!wpa_sm_pmksa_exists(wpa_s->wpa, bss->bssid, ssid) &&
|
|
|
|
(!ssid->dpp_connector || !ssid->dpp_netaccesskey ||
|
|
|
|
!ssid->dpp_csign)) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - no PMKSA entry for DPP");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_DPP */
|
|
|
|
|
2020-06-07 15:49:07 +02:00
|
|
|
#ifdef CONFIG_SAE_PK
|
|
|
|
if (ssid->sae_pk == SAE_PK_MODE_AUTOMATIC &&
|
|
|
|
wpa_key_mgmt_sae(ssid->key_mgmt) &&
|
2020-08-09 21:31:28 +02:00
|
|
|
((ssid->sae_password &&
|
|
|
|
sae_pk_valid_password(ssid->sae_password)) ||
|
|
|
|
(!ssid->sae_password && ssid->passphrase &&
|
|
|
|
sae_pk_valid_password(ssid->passphrase))) &&
|
2020-06-07 15:49:07 +02:00
|
|
|
!(rsnxe_capa & BIT(WLAN_RSNX_CAPAB_SAE_PK)) &&
|
|
|
|
sae_pk_acceptable_bss_with_pk(wpa_s, bss, ssid, match_ssid,
|
|
|
|
match_ssid_len)) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - another acceptable BSS with SAE-PK in the same ESS");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SAE_PK */
|
|
|
|
|
2020-06-08 20:40:56 +02:00
|
|
|
if (bss->ssid_len == 0) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
" skip - no SSID known for the BSS");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-06-07 15:30:32 +02:00
|
|
|
/* Matching configuration found */
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-02-15 15:53:41 +01:00
|
|
|
struct wpa_ssid * wpa_scan_res_match(struct wpa_supplicant *wpa_s,
|
|
|
|
int i, struct wpa_bss *bss,
|
|
|
|
struct wpa_ssid *group,
|
2016-11-13 17:22:38 +01:00
|
|
|
int only_first_ssid, int debug_print)
|
2008-02-28 02:34:43 +01:00
|
|
|
{
|
2012-09-02 18:56:57 +02:00
|
|
|
u8 wpa_ie_len, rsn_ie_len;
|
2008-02-28 02:34:43 +01:00
|
|
|
const u8 *ie;
|
2010-08-27 19:05:49 +02:00
|
|
|
struct wpa_ssid *ssid;
|
2020-06-07 15:30:32 +02:00
|
|
|
int osen;
|
2017-10-08 11:32:02 +02:00
|
|
|
const u8 *match_ssid;
|
|
|
|
size_t match_ssid_len;
|
2021-02-07 16:02:37 +01:00
|
|
|
int bssid_ignore_count;
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2012-09-02 18:56:57 +02:00
|
|
|
ie = wpa_bss_get_vendor_ie(bss, WPA_IE_VENDOR_TYPE);
|
2010-08-27 19:05:49 +02:00
|
|
|
wpa_ie_len = ie ? ie[1] : 0;
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2012-09-02 18:56:57 +02:00
|
|
|
ie = wpa_bss_get_ie(bss, WLAN_EID_RSN);
|
2010-08-27 19:05:49 +02:00
|
|
|
rsn_ie_len = ie ? ie[1] : 0;
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2013-07-23 20:24:05 +02:00
|
|
|
ie = wpa_bss_get_vendor_ie(bss, OSEN_IE_VENDOR_TYPE);
|
|
|
|
osen = ie != NULL;
|
|
|
|
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "%d: " MACSTR
|
|
|
|
" ssid='%s' wpa_ie_len=%u rsn_ie_len=%u caps=0x%x level=%d freq=%d %s%s%s",
|
|
|
|
i, MAC2STR(bss->bssid),
|
|
|
|
wpa_ssid_txt(bss->ssid, bss->ssid_len),
|
|
|
|
wpa_ie_len, rsn_ie_len, bss->caps, bss->level,
|
|
|
|
bss->freq,
|
|
|
|
wpa_bss_get_vendor_ie(bss, WPS_IE_VENDOR_TYPE) ?
|
|
|
|
" wps" : "",
|
|
|
|
(wpa_bss_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE) ||
|
|
|
|
wpa_bss_get_vendor_ie_beacon(bss, P2P_IE_VENDOR_TYPE))
|
|
|
|
? " p2p" : "",
|
|
|
|
osen ? " osen=1" : "");
|
|
|
|
}
|
2008-09-26 16:24:40 +02:00
|
|
|
|
2021-02-07 16:02:37 +01:00
|
|
|
bssid_ignore_count = wpa_bssid_ignore_is_listed(wpa_s, bss->bssid);
|
|
|
|
if (bssid_ignore_count) {
|
2010-11-26 10:23:50 +01:00
|
|
|
int limit = 1;
|
2012-05-10 13:34:46 +02:00
|
|
|
if (wpa_supplicant_enabled_networks(wpa_s) == 1) {
|
2010-11-26 10:23:50 +01:00
|
|
|
/*
|
|
|
|
* When only a single network is enabled, we can
|
2021-02-07 16:02:37 +01:00
|
|
|
* trigger BSSID ignoring on the first failure. This
|
2010-11-26 10:23:50 +01:00
|
|
|
* should not be done with multiple enabled networks to
|
|
|
|
* avoid getting forced to move into a worse ESS on
|
|
|
|
* single error if there are no other BSSes of the
|
|
|
|
* current ESS.
|
|
|
|
*/
|
|
|
|
limit = 0;
|
|
|
|
}
|
2021-02-07 16:02:37 +01:00
|
|
|
if (bssid_ignore_count > limit) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
2021-02-07 16:02:37 +01:00
|
|
|
" skip - BSSID ignored (count=%d limit=%d)",
|
|
|
|
bssid_ignore_count, limit);
|
2016-11-13 17:22:38 +01:00
|
|
|
}
|
2011-04-08 18:16:20 +02:00
|
|
|
return NULL;
|
2010-11-26 10:23:50 +01:00
|
|
|
}
|
2010-08-27 19:05:49 +02:00
|
|
|
}
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2017-10-08 11:32:02 +02:00
|
|
|
match_ssid = bss->ssid;
|
|
|
|
match_ssid_len = bss->ssid_len;
|
|
|
|
owe_trans_ssid(wpa_s, bss, &match_ssid, &match_ssid_len);
|
|
|
|
|
|
|
|
if (match_ssid_len == 0) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, " skip - SSID not known");
|
2011-04-08 18:16:20 +02:00
|
|
|
return NULL;
|
2010-08-27 19:05:49 +02:00
|
|
|
}
|
2009-10-15 20:58:58 +02:00
|
|
|
|
2012-09-27 16:36:59 +02:00
|
|
|
if (disallowed_bssid(wpa_s, bss->bssid)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, " skip - BSSID disallowed");
|
2012-09-27 16:36:59 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-10-08 11:32:02 +02:00
|
|
|
if (disallowed_ssid(wpa_s, match_ssid, match_ssid_len)) {
|
2016-11-13 17:22:38 +01:00
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, " skip - SSID disallowed");
|
2012-09-27 16:36:59 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2019-12-11 13:57:47 +01:00
|
|
|
if (disabled_freq(wpa_s, bss->freq)) {
|
|
|
|
if (debug_print)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, " skip - channel disabled");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-02-25 21:37:57 +01:00
|
|
|
for (ssid = group; ssid; ssid = only_first_ssid ? NULL : ssid->pnext) {
|
2020-06-07 15:30:32 +02:00
|
|
|
if (wpa_scan_res_ok(wpa_s, ssid, match_ssid, match_ssid_len,
|
2021-02-07 16:02:37 +01:00
|
|
|
bss, bssid_ignore_count, debug_print))
|
2020-06-07 15:30:32 +02:00
|
|
|
return ssid;
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
|
|
|
|
2010-08-27 19:05:49 +02:00
|
|
|
/* No matching configuration found */
|
2011-04-08 18:16:20 +02:00
|
|
|
return NULL;
|
2008-09-26 16:24:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-01-02 15:16:02 +01:00
|
|
|
static struct wpa_bss *
|
2010-01-02 15:41:38 +01:00
|
|
|
wpa_supplicant_select_bss(struct wpa_supplicant *wpa_s,
|
|
|
|
struct wpa_ssid *group,
|
2014-02-25 21:37:57 +01:00
|
|
|
struct wpa_ssid **selected_ssid,
|
|
|
|
int only_first_ssid)
|
2008-09-26 16:24:40 +02:00
|
|
|
{
|
2012-09-02 18:56:57 +02:00
|
|
|
unsigned int i;
|
2008-09-26 16:24:40 +02:00
|
|
|
|
2016-11-13 17:22:38 +01:00
|
|
|
if (wpa_s->current_ssid) {
|
|
|
|
struct wpa_ssid *ssid;
|
|
|
|
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"Scan results matching the currently selected network");
|
|
|
|
for (i = 0; i < wpa_s->last_scan_res_used; i++) {
|
|
|
|
struct wpa_bss *bss = wpa_s->last_scan_res[i];
|
|
|
|
|
|
|
|
ssid = wpa_scan_res_match(wpa_s, i, bss, group,
|
|
|
|
only_first_ssid, 0);
|
|
|
|
if (ssid != wpa_s->current_ssid)
|
|
|
|
continue;
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "%u: " MACSTR
|
|
|
|
" freq=%d level=%d snr=%d est_throughput=%u",
|
|
|
|
i, MAC2STR(bss->bssid), bss->freq, bss->level,
|
|
|
|
bss->snr, bss->est_throughput);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-25 21:37:57 +01:00
|
|
|
if (only_first_ssid)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Try to find BSS matching pre-selected network id=%d",
|
|
|
|
group->id);
|
|
|
|
else
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Selecting BSS from priority group %d",
|
|
|
|
group->priority);
|
2008-09-26 16:24:40 +02:00
|
|
|
|
2012-09-02 18:56:57 +02:00
|
|
|
for (i = 0; i < wpa_s->last_scan_res_used; i++) {
|
|
|
|
struct wpa_bss *bss = wpa_s->last_scan_res[i];
|
2018-09-06 19:27:29 +02:00
|
|
|
|
|
|
|
wpa_s->owe_transition_select = 1;
|
2014-02-25 21:37:57 +01:00
|
|
|
*selected_ssid = wpa_scan_res_match(wpa_s, i, bss, group,
|
2016-11-13 17:22:38 +01:00
|
|
|
only_first_ssid, 1);
|
2018-09-06 19:27:29 +02:00
|
|
|
wpa_s->owe_transition_select = 0;
|
2010-08-27 19:05:49 +02:00
|
|
|
if (!*selected_ssid)
|
|
|
|
continue;
|
2020-01-01 16:55:00 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, " selected %sBSS " MACSTR
|
2011-02-10 19:14:46 +01:00
|
|
|
" ssid='%s'",
|
2020-01-01 16:55:00 +01:00
|
|
|
bss == wpa_s->current_bss ? "current ": "",
|
2012-09-02 18:56:57 +02:00
|
|
|
MAC2STR(bss->bssid),
|
|
|
|
wpa_ssid_txt(bss->ssid, bss->ssid_len));
|
|
|
|
return bss;
|
2010-08-27 19:05:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-03-31 19:06:42 +02:00
|
|
|
struct wpa_bss * wpa_supplicant_pick_network(struct wpa_supplicant *wpa_s,
|
|
|
|
struct wpa_ssid **selected_ssid)
|
2008-02-28 02:34:43 +01:00
|
|
|
{
|
2010-01-02 15:16:02 +01:00
|
|
|
struct wpa_bss *selected = NULL;
|
2020-03-22 16:46:45 +01:00
|
|
|
size_t prio;
|
2014-02-27 12:47:23 +01:00
|
|
|
struct wpa_ssid *next_ssid = NULL;
|
2015-03-28 10:05:13 +01:00
|
|
|
struct wpa_ssid *ssid;
|
2009-09-29 13:30:11 +02:00
|
|
|
|
2012-09-02 18:56:57 +02:00
|
|
|
if (wpa_s->last_scan_res == NULL ||
|
|
|
|
wpa_s->last_scan_res_used == 0)
|
|
|
|
return NULL; /* no scan results from last update */
|
|
|
|
|
2014-02-27 12:47:23 +01:00
|
|
|
if (wpa_s->next_ssid) {
|
|
|
|
/* check that next_ssid is still valid */
|
|
|
|
for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
|
|
|
|
if (ssid == wpa_s->next_ssid)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
next_ssid = ssid;
|
|
|
|
wpa_s->next_ssid = NULL;
|
|
|
|
}
|
2014-02-25 21:37:57 +01:00
|
|
|
|
2014-02-27 12:47:23 +01:00
|
|
|
while (selected == NULL) {
|
|
|
|
for (prio = 0; prio < wpa_s->conf->num_prio; prio++) {
|
|
|
|
if (next_ssid && next_ssid->priority ==
|
|
|
|
wpa_s->conf->pssid[prio]->priority) {
|
2014-02-25 21:37:57 +01:00
|
|
|
selected = wpa_supplicant_select_bss(
|
2014-02-27 12:47:23 +01:00
|
|
|
wpa_s, next_ssid, selected_ssid, 1);
|
2014-02-25 21:37:57 +01:00
|
|
|
if (selected)
|
|
|
|
break;
|
|
|
|
}
|
2009-09-29 13:30:11 +02:00
|
|
|
selected = wpa_supplicant_select_bss(
|
2012-09-02 18:56:57 +02:00
|
|
|
wpa_s, wpa_s->conf->pssid[prio],
|
2014-02-25 21:37:57 +01:00
|
|
|
selected_ssid, 0);
|
2009-09-29 13:30:11 +02:00
|
|
|
if (selected)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2021-02-07 16:02:37 +01:00
|
|
|
if (selected == NULL && wpa_s->bssid_ignore &&
|
2011-12-25 20:09:17 +01:00
|
|
|
!wpa_s->countermeasures) {
|
2021-02-07 16:02:37 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"No APs found - clear BSSID ignore list and try again");
|
|
|
|
wpa_bssid_ignore_clear(wpa_s);
|
|
|
|
wpa_s->bssid_ignore_cleared = true;
|
2009-09-29 13:30:11 +02:00
|
|
|
} else if (selected == NULL)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-03-28 10:05:13 +01:00
|
|
|
ssid = *selected_ssid;
|
|
|
|
if (selected && ssid && ssid->mem_only_psk && !ssid->psk_set &&
|
|
|
|
!ssid->passphrase && !ssid->ext_psk) {
|
|
|
|
const char *field_name, *txt = NULL;
|
|
|
|
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"PSK/passphrase not yet available for the selected network");
|
|
|
|
|
|
|
|
wpas_notify_network_request(wpa_s, ssid,
|
|
|
|
WPA_CTRL_REQ_PSK_PASSPHRASE, NULL);
|
|
|
|
|
|
|
|
field_name = wpa_supplicant_ctrl_req_to_string(
|
|
|
|
WPA_CTRL_REQ_PSK_PASSPHRASE, NULL, &txt);
|
|
|
|
if (field_name == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
wpas_send_ctrl_req(wpa_s, ssid, field_name, txt);
|
|
|
|
|
|
|
|
selected = NULL;
|
|
|
|
}
|
|
|
|
|
2009-09-29 13:30:11 +02:00
|
|
|
return selected;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void wpa_supplicant_req_new_scan(struct wpa_supplicant *wpa_s,
|
2010-04-11 18:10:01 +02:00
|
|
|
int timeout_sec, int timeout_usec)
|
2009-09-29 13:30:11 +02:00
|
|
|
{
|
2012-05-10 13:34:46 +02:00
|
|
|
if (!wpa_supplicant_enabled_networks(wpa_s)) {
|
2009-10-14 21:05:58 +02:00
|
|
|
/*
|
|
|
|
* No networks are enabled; short-circuit request so
|
|
|
|
* we don't wait timeout seconds before transitioning
|
|
|
|
* to INACTIVE state.
|
|
|
|
*/
|
2012-09-24 00:05:51 +02:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Short-circuit new scan request "
|
|
|
|
"since there are no enabled networks");
|
2009-10-14 21:05:58 +02:00
|
|
|
wpa_supplicant_set_state(wpa_s, WPA_INACTIVE);
|
|
|
|
return;
|
2009-09-29 13:30:11 +02:00
|
|
|
}
|
2012-11-25 11:47:43 +01:00
|
|
|
|
|
|
|
wpa_s->scan_for_connection = 1;
|
2010-04-11 18:10:01 +02:00
|
|
|
wpa_supplicant_req_scan(wpa_s, timeout_sec, timeout_usec);
|
2009-09-29 13:30:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-10-24 22:37:39 +02:00
|
|
|
int wpa_supplicant_connect(struct wpa_supplicant *wpa_s,
|
|
|
|
struct wpa_bss *selected,
|
|
|
|
struct wpa_ssid *ssid)
|
2009-09-29 13:30:11 +02:00
|
|
|
{
|
|
|
|
if (wpas_wps_scan_pbc_overlap(wpa_s, selected, ssid)) {
|
|
|
|
wpa_msg(wpa_s, MSG_INFO, WPS_EVENT_OVERLAP
|
|
|
|
"PBC session overlap");
|
2015-06-05 14:46:51 +02:00
|
|
|
wpas_notify_wps_event_pbc_overlap(wpa_s);
|
2010-09-07 12:42:55 +02:00
|
|
|
#ifdef CONFIG_P2P
|
2014-03-27 07:58:30 +01:00
|
|
|
if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT ||
|
|
|
|
wpa_s->p2p_in_provisioning) {
|
|
|
|
eloop_register_timeout(0, 0, wpas_p2p_pbc_overlap_cb,
|
|
|
|
wpa_s, NULL);
|
2011-10-24 22:37:39 +02:00
|
|
|
return -1;
|
2014-03-27 07:58:30 +01:00
|
|
|
}
|
2010-09-07 12:42:55 +02:00
|
|
|
#endif /* CONFIG_P2P */
|
2010-10-07 09:41:58 +02:00
|
|
|
|
|
|
|
#ifdef CONFIG_WPS
|
2015-05-28 05:53:07 +02:00
|
|
|
wpas_wps_pbc_overlap(wpa_s);
|
2010-09-20 02:04:04 +02:00
|
|
|
wpas_wps_cancel(wpa_s);
|
2010-10-07 09:41:58 +02:00
|
|
|
#endif /* CONFIG_WPS */
|
2011-10-24 22:37:39 +02:00
|
|
|
return -1;
|
2009-09-29 13:30:11 +02:00
|
|
|
}
|
|
|
|
|
2013-05-21 18:34:00 +02:00
|
|
|
wpa_msg(wpa_s, MSG_DEBUG,
|
|
|
|
"Considering connect request: reassociate: %d selected: "
|
|
|
|
MACSTR " bssid: " MACSTR " pending: " MACSTR
|
|
|
|
" wpa_state: %s ssid=%p current_ssid=%p",
|
|
|
|
wpa_s->reassociate, MAC2STR(selected->bssid),
|
|
|
|
MAC2STR(wpa_s->bssid), MAC2STR(wpa_s->pending_bssid),
|
|
|
|
wpa_supplicant_state_txt(wpa_s->wpa_state),
|
|
|
|
ssid, wpa_s->current_ssid);
|
|
|
|
|
2009-09-29 13:30:11 +02:00
|
|
|
/*
|
|
|
|
* Do not trigger new association unless the BSSID has changed or if
|
|
|
|
* reassociation is requested. If we are in process of associating with
|
|
|
|
* the selected BSSID, do not trigger new attempt.
|
|
|
|
*/
|
|
|
|
if (wpa_s->reassociate ||
|
|
|
|
(os_memcmp(selected->bssid, wpa_s->bssid, ETH_ALEN) != 0 &&
|
2011-02-24 15:59:46 +01:00
|
|
|
((wpa_s->wpa_state != WPA_ASSOCIATING &&
|
|
|
|
wpa_s->wpa_state != WPA_AUTHENTICATING) ||
|
2013-05-21 18:34:00 +02:00
|
|
|
(!is_zero_ether_addr(wpa_s->pending_bssid) &&
|
|
|
|
os_memcmp(selected->bssid, wpa_s->pending_bssid, ETH_ALEN) !=
|
|
|
|
0) ||
|
|
|
|
(is_zero_ether_addr(wpa_s->pending_bssid) &&
|
|
|
|
ssid != wpa_s->current_ssid)))) {
|
2009-09-29 13:30:11 +02:00
|
|
|
if (wpa_supplicant_scard_init(wpa_s, ssid)) {
|
2010-04-11 18:10:01 +02:00
|
|
|
wpa_supplicant_req_new_scan(wpa_s, 10, 0);
|
2011-10-24 22:37:39 +02:00
|
|
|
return 0;
|
2009-09-29 13:30:11 +02:00
|
|
|
}
|
2013-05-21 18:34:00 +02:00
|
|
|
wpa_msg(wpa_s, MSG_DEBUG, "Request association with " MACSTR,
|
|
|
|
MAC2STR(selected->bssid));
|
2009-09-29 13:30:11 +02:00
|
|
|
wpa_supplicant_associate(wpa_s, selected, ssid);
|
|
|
|
} else {
|
2013-05-21 18:34:00 +02:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Already associated or trying to "
|
|
|
|
"connect with the selected AP");
|
2009-09-29 13:30:11 +02:00
|
|
|
}
|
2011-10-24 22:37:39 +02:00
|
|
|
|
|
|
|
return 0;
|
2009-09-29 13:30:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-09-29 16:11:36 +02:00
|
|
|
static struct wpa_ssid *
|
|
|
|
wpa_supplicant_pick_new_network(struct wpa_supplicant *wpa_s)
|
|
|
|
{
|
2020-03-22 16:46:45 +01:00
|
|
|
size_t prio;
|
2009-09-29 16:11:36 +02:00
|
|
|
struct wpa_ssid *ssid;
|
|
|
|
|
|
|
|
for (prio = 0; prio < wpa_s->conf->num_prio; prio++) {
|
|
|
|
for (ssid = wpa_s->conf->pssid[prio]; ssid; ssid = ssid->pnext)
|
|
|
|
{
|
2012-05-10 13:34:46 +02:00
|
|
|
if (wpas_network_disabled(wpa_s, ssid))
|
2009-09-29 16:11:36 +02:00
|
|
|
continue;
|
2016-10-28 18:33:20 +02:00
|
|
|
#ifndef CONFIG_IBSS_RSN
|
|
|
|
if (ssid->mode == WPAS_MODE_IBSS &&
|
|
|
|
!(ssid->key_mgmt & (WPA_KEY_MGMT_NONE |
|
|
|
|
WPA_KEY_MGMT_WPA_NONE))) {
|
|
|
|
wpa_msg(wpa_s, MSG_INFO,
|
|
|
|
"IBSS RSN not supported in the build - cannot use the profile for SSID '%s'",
|
|
|
|
wpa_ssid_txt(ssid->ssid,
|
|
|
|
ssid->ssid_len));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
#endif /* !CONFIG_IBSS_RSN */
|
2019-06-14 16:49:19 +02:00
|
|
|
if (ssid->mode == WPAS_MODE_IBSS ||
|
|
|
|
ssid->mode == WPAS_MODE_AP ||
|
|
|
|
ssid->mode == WPAS_MODE_MESH)
|
2009-09-29 16:11:36 +02:00
|
|
|
return ssid;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-01-02 15:41:38 +01:00
|
|
|
/* TODO: move the rsn_preauth_scan_result*() to be called from notify.c based
|
|
|
|
* on BSS added and BSS changed events */
|
2009-11-29 16:06:03 +01:00
|
|
|
static void wpa_supplicant_rsn_preauth_scan_results(
|
2011-05-19 16:52:46 +02:00
|
|
|
struct wpa_supplicant *wpa_s)
|
2009-11-29 16:06:03 +01:00
|
|
|
{
|
2011-05-19 16:52:46 +02:00
|
|
|
struct wpa_bss *bss;
|
2009-11-29 16:06:03 +01:00
|
|
|
|
|
|
|
if (rsn_preauth_scan_results(wpa_s->wpa) < 0)
|
|
|
|
return;
|
|
|
|
|
2011-05-19 16:52:46 +02:00
|
|
|
dl_list_for_each(bss, &wpa_s->bss, struct wpa_bss, list) {
|
2009-11-29 16:06:03 +01:00
|
|
|
const u8 *ssid, *rsn;
|
|
|
|
|
2011-05-19 16:52:46 +02:00
|
|
|
ssid = wpa_bss_get_ie(bss, WLAN_EID_SSID);
|
2009-11-29 16:06:03 +01:00
|
|
|
if (ssid == NULL)
|
|
|
|
continue;
|
|
|
|
|
2011-05-19 16:52:46 +02:00
|
|
|
rsn = wpa_bss_get_ie(bss, WLAN_EID_RSN);
|
2009-11-29 16:06:03 +01:00
|
|
|
if (rsn == NULL)
|
|
|
|
continue;
|
|
|
|
|
2011-05-19 16:52:46 +02:00
|
|
|
rsn_preauth_scan_result(wpa_s->wpa, bss->bssid, ssid, rsn);
|
2009-11-29 16:06:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-01-09 11:40:17 +01:00
|
|
|
#ifndef CONFIG_NO_ROAMING
|
|
|
|
|
2020-01-01 12:38:11 +01:00
|
|
|
static int wpas_get_snr_signal_info(u32 frequency, int avg_signal, int noise)
|
2019-12-06 23:27:47 +01:00
|
|
|
{
|
2020-01-01 12:38:11 +01:00
|
|
|
if (noise == WPA_INVALID_NOISE)
|
|
|
|
noise = IS_5GHZ(frequency) ? DEFAULT_NOISE_FLOOR_5GHZ :
|
|
|
|
DEFAULT_NOISE_FLOOR_2GHZ;
|
2019-12-06 23:27:48 +01:00
|
|
|
return avg_signal - noise;
|
2019-12-06 23:27:47 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static unsigned int
|
|
|
|
wpas_get_est_throughput_from_bss_snr(const struct wpa_supplicant *wpa_s,
|
|
|
|
const struct wpa_bss *bss, int snr)
|
|
|
|
{
|
|
|
|
int rate = wpa_bss_get_max_rate(bss);
|
2020-11-16 15:21:56 +01:00
|
|
|
const u8 *ies = wpa_bss_ie_ptr(bss);
|
2019-12-06 23:27:47 +01:00
|
|
|
size_t ie_len = bss->ie_len ? bss->ie_len : bss->beacon_ie_len;
|
|
|
|
|
|
|
|
return wpas_get_est_tpt(wpa_s, ies, ie_len, rate, snr);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-06-02 02:10:15 +02:00
|
|
|
int wpa_supplicant_need_to_roam_within_ess(struct wpa_supplicant *wpa_s,
|
|
|
|
struct wpa_bss *current_bss,
|
|
|
|
struct wpa_bss *selected)
|
2010-01-25 03:19:50 +01:00
|
|
|
{
|
2016-11-13 16:46:00 +01:00
|
|
|
int min_diff, diff;
|
2016-03-25 10:53:59 +01:00
|
|
|
int to_5ghz;
|
2019-12-06 23:27:47 +01:00
|
|
|
int cur_level;
|
|
|
|
unsigned int cur_est, sel_est;
|
2019-12-06 23:27:47 +01:00
|
|
|
struct wpa_signal_info si;
|
2020-01-01 15:56:40 +01:00
|
|
|
int cur_snr = 0;
|
2020-06-02 02:10:18 +02:00
|
|
|
int ret = 0;
|
2011-09-26 13:57:23 +02:00
|
|
|
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Considering within-ESS reassociation");
|
2015-02-22 10:28:27 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Current BSS: " MACSTR
|
2016-11-13 16:46:00 +01:00
|
|
|
" freq=%d level=%d snr=%d est_throughput=%u",
|
|
|
|
MAC2STR(current_bss->bssid),
|
|
|
|
current_bss->freq, current_bss->level,
|
2015-02-22 10:28:27 +01:00
|
|
|
current_bss->snr, current_bss->est_throughput);
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Selected BSS: " MACSTR
|
2016-11-13 16:46:00 +01:00
|
|
|
" freq=%d level=%d snr=%d est_throughput=%u",
|
|
|
|
MAC2STR(selected->bssid), selected->freq, selected->level,
|
2015-02-22 10:28:27 +01:00
|
|
|
selected->snr, selected->est_throughput);
|
2010-01-25 03:19:50 +01:00
|
|
|
|
2010-02-28 10:09:58 +01:00
|
|
|
if (wpa_s->current_ssid->bssid_set &&
|
|
|
|
os_memcmp(selected->bssid, wpa_s->current_ssid->bssid, ETH_ALEN) ==
|
|
|
|
0) {
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Allow reassociation - selected BSS "
|
|
|
|
"has preferred BSSID");
|
2010-02-28 10:09:58 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2019-12-06 23:27:47 +01:00
|
|
|
cur_level = current_bss->level;
|
|
|
|
cur_est = current_bss->est_throughput;
|
2020-01-01 16:37:58 +01:00
|
|
|
sel_est = selected->est_throughput;
|
2019-12-06 23:27:47 +01:00
|
|
|
|
2019-12-06 23:27:47 +01:00
|
|
|
/*
|
|
|
|
* Try to poll the signal from the driver since this will allow to get
|
|
|
|
* more accurate values. In some cases, there can be big differences
|
|
|
|
* between the RSSI of the Probe Response frames of the AP we are
|
|
|
|
* associated with and the Beacon frames we hear from the same AP after
|
|
|
|
* association. This can happen, e.g., when there are two antennas that
|
|
|
|
* hear the AP very differently. If the driver chooses to hear the
|
|
|
|
* Probe Response frames during the scan on the "bad" antenna because
|
|
|
|
* it wants to save power, but knows to choose the other antenna after
|
|
|
|
* association, we will hear our AP with a low RSSI as part of the
|
|
|
|
* scan even when we can hear it decently on the other antenna. To cope
|
|
|
|
* with this, ask the driver to teach us how it hears the AP. Also, the
|
|
|
|
* scan results may be a bit old, since we can very quickly get fresh
|
|
|
|
* information about our currently associated AP.
|
|
|
|
*/
|
|
|
|
if (wpa_drv_signal_poll(wpa_s, &si) == 0 &&
|
2019-12-06 23:27:48 +01:00
|
|
|
(si.avg_beacon_signal || si.avg_signal)) {
|
|
|
|
cur_level = si.avg_beacon_signal ? si.avg_beacon_signal :
|
|
|
|
si.avg_signal;
|
2020-01-01 15:56:40 +01:00
|
|
|
cur_snr = wpas_get_snr_signal_info(si.frequency, cur_level,
|
|
|
|
si.current_noise);
|
2019-12-06 23:27:47 +01:00
|
|
|
|
|
|
|
cur_est = wpas_get_est_throughput_from_bss_snr(wpa_s,
|
|
|
|
current_bss,
|
2020-01-01 15:56:40 +01:00
|
|
|
cur_snr);
|
2019-12-06 23:27:47 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"Using signal poll values for the current BSS: level=%d snr=%d est_throughput=%u",
|
2020-01-01 15:56:40 +01:00
|
|
|
cur_level, cur_snr, cur_est);
|
2019-12-06 23:27:47 +01:00
|
|
|
}
|
|
|
|
|
2020-01-01 16:37:58 +01:00
|
|
|
if (sel_est > cur_est + 5000) {
|
2015-02-22 10:28:27 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"Allow reassociation - selected BSS has better estimated throughput");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2016-03-25 10:53:59 +01:00
|
|
|
to_5ghz = selected->freq > 4000 && current_bss->freq < 4000;
|
|
|
|
|
2020-01-01 16:09:18 +01:00
|
|
|
if (cur_level < 0 && cur_level > selected->level + to_5ghz * 2 &&
|
2020-01-01 16:37:58 +01:00
|
|
|
sel_est < cur_est * 1.2) {
|
2012-11-24 16:17:50 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Skip roam - Current BSS has better "
|
|
|
|
"signal level");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-01-01 16:37:58 +01:00
|
|
|
if (cur_est > sel_est + 5000) {
|
2016-11-13 16:46:00 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"Skip roam - Current BSS has better estimated throughput");
|
2017-02-05 20:52:26 +01:00
|
|
|
return 0;
|
2016-11-13 16:46:00 +01:00
|
|
|
}
|
|
|
|
|
2020-01-01 15:56:40 +01:00
|
|
|
if (cur_snr > GREAT_SNR) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"Skip roam - Current BSS has good SNR (%u > %u)",
|
|
|
|
cur_snr, GREAT_SNR);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-01-01 16:46:03 +01:00
|
|
|
if (cur_level < -85) /* ..-86 dBm */
|
|
|
|
min_diff = 1;
|
|
|
|
else if (cur_level < -80) /* -85..-81 dBm */
|
|
|
|
min_diff = 2;
|
|
|
|
else if (cur_level < -75) /* -80..-76 dBm */
|
|
|
|
min_diff = 3;
|
|
|
|
else if (cur_level < -70) /* -75..-71 dBm */
|
|
|
|
min_diff = 4;
|
|
|
|
else if (cur_level < 0) /* -70..-1 dBm */
|
|
|
|
min_diff = 5;
|
|
|
|
else /* unspecified units (not in dBm) */
|
|
|
|
min_diff = 2;
|
Improve roaming logic
Currently, wpa_supplicant may roam too aggressively; the need_to_roam()
function will return early with a roaming decision if the difference in
signal level or throughput between the current and selected APs is
"sufficiently large." In particular, if the selected AP's estimated
throughput is more than 5k greater than the current AP's estimated
throughput, wpa_supplicant will decide to roam. Otherwise, if the
selected AP's signal level is less than the current AP's signal level,
or the selected AP's estimated throughput is at least 5k less than the
current AP's estimated throughput, wpa_supplicant will skip the roam.
These decisions are based only on one factor and can lead to poor
roaming choices (e.g., a roam should not happen if the selected AP's
estimated throughput meets the threshold but the current signal and
throughput are already good, whereas a roam should happen if the signal
is slightly worse but the estimated throughput is significantly better).
This change standardizes the roaming heuristic for signal strength
difference requirements and will hopefully improve user experience. The
change can be summarized as follows: based on the current signal level,
a certain roaming difficulty is assigned. Based on the selected AP's
estimated throughput relative to the current AP's estimated throughput,
the difficulty is adjusted up or down. If the difference in signal level
meets the threshold, a roam happens.
The hard-coded values were selected purely based on the previous version
of this function. They may eventually need to be fine-tuned for optimal
performance.
Signed-off-by: Matthew Wang <matthewmwang@chromium.org>
2018-07-17 19:56:21 +02:00
|
|
|
|
|
|
|
if (cur_est > sel_est * 1.5)
|
|
|
|
min_diff += 10;
|
|
|
|
else if (cur_est > sel_est * 1.2)
|
|
|
|
min_diff += 5;
|
|
|
|
else if (cur_est > sel_est * 1.1)
|
|
|
|
min_diff += 2;
|
|
|
|
else if (cur_est > sel_est)
|
|
|
|
min_diff++;
|
|
|
|
else if (sel_est > cur_est * 1.5)
|
|
|
|
min_diff -= 10;
|
|
|
|
else if (sel_est > cur_est * 1.2)
|
|
|
|
min_diff -= 5;
|
|
|
|
else if (sel_est > cur_est * 1.1)
|
|
|
|
min_diff -= 2;
|
|
|
|
else if (sel_est > cur_est)
|
|
|
|
min_diff--;
|
|
|
|
|
|
|
|
if (to_5ghz)
|
|
|
|
min_diff -= 2;
|
2020-01-02 19:33:01 +01:00
|
|
|
diff = selected->level - cur_level;
|
2016-11-13 16:46:00 +01:00
|
|
|
if (diff < min_diff) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"Skip roam - too small difference in signal level (%d < %d)",
|
|
|
|
diff, min_diff);
|
2020-06-02 02:10:18 +02:00
|
|
|
ret = 0;
|
|
|
|
} else {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"Allow reassociation due to difference in signal level (%d >= %d)",
|
|
|
|
diff, min_diff);
|
|
|
|
ret = 1;
|
|
|
|
}
|
|
|
|
wpa_msg_ctrl(wpa_s, MSG_INFO, "%scur_bssid=" MACSTR
|
|
|
|
" cur_freq=%d cur_level=%d cur_est=%d sel_bssid=" MACSTR
|
|
|
|
" sel_freq=%d sel_level=%d sel_est=%d",
|
|
|
|
ret ? WPA_EVENT_DO_ROAM : WPA_EVENT_SKIP_ROAM,
|
|
|
|
MAC2STR(current_bss->bssid),
|
|
|
|
current_bss->freq, cur_level, cur_est,
|
|
|
|
MAC2STR(selected->bssid),
|
|
|
|
selected->freq, selected->level, sel_est);
|
|
|
|
return ret;
|
2020-06-02 02:10:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_NO_ROAMING */
|
|
|
|
|
|
|
|
|
|
|
|
static int wpa_supplicant_need_to_roam(struct wpa_supplicant *wpa_s,
|
|
|
|
struct wpa_bss *selected,
|
|
|
|
struct wpa_ssid *ssid)
|
|
|
|
{
|
|
|
|
struct wpa_bss *current_bss = NULL;
|
|
|
|
|
|
|
|
if (wpa_s->reassociate)
|
|
|
|
return 1; /* explicit request to reassociate */
|
|
|
|
if (wpa_s->wpa_state < WPA_ASSOCIATED)
|
|
|
|
return 1; /* we are not associated; continue */
|
|
|
|
if (wpa_s->current_ssid == NULL)
|
|
|
|
return 1; /* unknown current SSID */
|
|
|
|
if (wpa_s->current_ssid != ssid)
|
|
|
|
return 1; /* different network block */
|
|
|
|
|
|
|
|
if (wpas_driver_bss_selection(wpa_s))
|
|
|
|
return 0; /* Driver-based roaming */
|
|
|
|
|
|
|
|
if (wpa_s->current_ssid->ssid)
|
|
|
|
current_bss = wpa_bss_get(wpa_s, wpa_s->bssid,
|
|
|
|
wpa_s->current_ssid->ssid,
|
|
|
|
wpa_s->current_ssid->ssid_len);
|
|
|
|
if (!current_bss)
|
|
|
|
current_bss = wpa_bss_get_bssid(wpa_s, wpa_s->bssid);
|
|
|
|
|
|
|
|
if (!current_bss)
|
|
|
|
return 1; /* current BSS not seen in scan results */
|
|
|
|
|
|
|
|
if (current_bss == selected)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (selected->last_update_idx > current_bss->last_update_idx)
|
|
|
|
return 1; /* current BSS not seen in the last scan */
|
|
|
|
|
|
|
|
#ifndef CONFIG_NO_ROAMING
|
|
|
|
return wpa_supplicant_need_to_roam_within_ess(wpa_s, current_bss,
|
|
|
|
selected);
|
2011-08-16 20:55:46 +02:00
|
|
|
#else /* CONFIG_NO_ROAMING */
|
|
|
|
return 0;
|
|
|
|
#endif /* CONFIG_NO_ROAMING */
|
2010-01-25 03:19:50 +01:00
|
|
|
}
|
|
|
|
|
2012-01-23 16:34:39 +01:00
|
|
|
|
2016-10-10 17:22:09 +02:00
|
|
|
/*
|
|
|
|
* Return a negative value if no scan results could be fetched or if scan
|
|
|
|
* results should not be shared with other virtual interfaces.
|
|
|
|
* Return 0 if scan results were fetched and may be shared with other
|
|
|
|
* interfaces.
|
|
|
|
* Return 1 if scan results may be shared with other virtual interfaces but may
|
|
|
|
* not trigger any operations.
|
|
|
|
* Return 2 if the interface was removed and cannot be used.
|
|
|
|
*/
|
2011-02-16 17:55:37 +01:00
|
|
|
static int _wpa_supplicant_event_scan_results(struct wpa_supplicant *wpa_s,
|
2013-03-18 16:07:09 +01:00
|
|
|
union wpa_event_data *data,
|
2016-10-10 17:22:09 +02:00
|
|
|
int own_request, int update_only)
|
2009-09-29 13:30:11 +02:00
|
|
|
{
|
2013-11-24 21:07:05 +01:00
|
|
|
struct wpa_scan_results *scan_res = NULL;
|
|
|
|
int ret = 0;
|
2010-07-18 05:32:25 +02:00
|
|
|
int ap = 0;
|
2012-08-29 23:37:59 +02:00
|
|
|
#ifndef CONFIG_NO_RANDOM_POOL
|
|
|
|
size_t i, num;
|
|
|
|
#endif /* CONFIG_NO_RANDOM_POOL */
|
2010-07-18 05:32:25 +02:00
|
|
|
|
|
|
|
#ifdef CONFIG_AP
|
|
|
|
if (wpa_s->ap_iface)
|
|
|
|
ap = 1;
|
|
|
|
#endif /* CONFIG_AP */
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2009-05-27 20:06:40 +02:00
|
|
|
wpa_supplicant_notify_scanning(wpa_s, 0);
|
|
|
|
|
2010-01-02 15:41:38 +01:00
|
|
|
scan_res = wpa_supplicant_get_scan_results(wpa_s,
|
|
|
|
data ? &data->scan_info :
|
|
|
|
NULL, 1);
|
|
|
|
if (scan_res == NULL) {
|
2013-02-07 17:06:51 +01:00
|
|
|
if (wpa_s->conf->ap_scan == 2 || ap ||
|
|
|
|
wpa_s->scan_res_handler == scan_only_handler)
|
2011-02-16 17:55:37 +01:00
|
|
|
return -1;
|
2013-03-18 16:07:09 +01:00
|
|
|
if (!own_request)
|
|
|
|
return -1;
|
2015-09-16 14:15:05 +02:00
|
|
|
if (data && data->scan_info.external_scan)
|
|
|
|
return -1;
|
2020-12-08 07:18:13 +01:00
|
|
|
if (wpa_s->scan_res_fail_handler) {
|
|
|
|
void (*handler)(struct wpa_supplicant *wpa_s);
|
|
|
|
|
|
|
|
handler = wpa_s->scan_res_fail_handler;
|
|
|
|
wpa_s->scan_res_fail_handler = NULL;
|
|
|
|
handler(wpa_s);
|
|
|
|
} else {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"Failed to get scan results - try scanning again");
|
|
|
|
wpa_supplicant_req_new_scan(wpa_s, 1, 0);
|
|
|
|
}
|
|
|
|
|
2013-11-24 21:07:05 +01:00
|
|
|
ret = -1;
|
|
|
|
goto scan_work_done;
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
|
|
|
|
Maintain internal entropy pool for augmenting random number generation
By default, make hostapd and wpa_supplicant maintain an internal
entropy pool that is fed with following information:
hostapd:
- Probe Request frames (timing, RSSI)
- Association events (timing)
- SNonce from Supplicants
wpa_supplicant:
- Scan results (timing, signal/noise)
- Association events (timing)
The internal pool is used to augment the random numbers generated
with the OS mechanism (os_get_random()). While the internal
implementation is not expected to be very strong due to limited
amount of generic (non-platform specific) information to feed the
pool, this may strengthen key derivation on some devices that are
not configured to provide strong random numbers through
os_get_random() (e.g., /dev/urandom on Linux/BSD).
This new mechanism is not supposed to replace proper OS provided
random number generation mechanism. The OS mechanism needs to be
initialized properly (e.g., hw random number generator,
maintaining entropy pool over reboots, etc.) for any of the
security assumptions to hold.
If the os_get_random() is known to provide strong ramdom data (e.g., on
Linux/BSD, the board in question is known to have reliable source of
random data from /dev/urandom), the internal hostapd random pool can be
disabled. This will save some in binary size and CPU use. However, this
should only be considered for builds that are known to be used on
devices that meet the requirements described above. The internal pool
is disabled by adding CONFIG_NO_RANDOM_POOL=y to the .config file.
2010-11-24 00:29:40 +01:00
|
|
|
#ifndef CONFIG_NO_RANDOM_POOL
|
|
|
|
num = scan_res->num;
|
|
|
|
if (num > 10)
|
|
|
|
num = 10;
|
|
|
|
for (i = 0; i < num; i++) {
|
|
|
|
u8 buf[5];
|
|
|
|
struct wpa_scan_res *res = scan_res->res[i];
|
|
|
|
buf[0] = res->bssid[5];
|
|
|
|
buf[1] = res->qual & 0xff;
|
|
|
|
buf[2] = res->noise & 0xff;
|
|
|
|
buf[3] = res->level & 0xff;
|
|
|
|
buf[4] = res->tsf & 0xff;
|
|
|
|
random_add_randomness(buf, sizeof(buf));
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_NO_RANDOM_POOL */
|
|
|
|
|
2016-10-10 17:22:09 +02:00
|
|
|
if (update_only) {
|
|
|
|
ret = 1;
|
|
|
|
goto scan_work_done;
|
|
|
|
}
|
|
|
|
|
2014-01-03 11:00:13 +01:00
|
|
|
if (own_request && wpa_s->scan_res_handler &&
|
2015-09-16 14:15:05 +02:00
|
|
|
!(data && data->scan_info.external_scan)) {
|
2010-12-17 14:31:05 +01:00
|
|
|
void (*scan_res_handler)(struct wpa_supplicant *wpa_s,
|
|
|
|
struct wpa_scan_results *scan_res);
|
|
|
|
|
|
|
|
scan_res_handler = wpa_s->scan_res_handler;
|
2010-04-11 18:53:31 +02:00
|
|
|
wpa_s->scan_res_handler = NULL;
|
2010-12-17 14:31:05 +01:00
|
|
|
scan_res_handler(wpa_s, scan_res);
|
2016-10-10 17:22:09 +02:00
|
|
|
ret = 1;
|
2013-11-24 21:07:05 +01:00
|
|
|
goto scan_work_done;
|
2010-04-11 18:53:31 +02:00
|
|
|
}
|
|
|
|
|
2013-12-26 16:33:26 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "New scan results available (own=%u ext=%u)",
|
2015-09-16 14:15:05 +02:00
|
|
|
wpa_s->own_scan_running,
|
|
|
|
data ? data->scan_info.external_scan : 0);
|
2013-12-26 16:35:48 +01:00
|
|
|
if (wpa_s->last_scan_req == MANUAL_SCAN_REQ &&
|
2015-09-16 14:15:05 +02:00
|
|
|
wpa_s->manual_scan_use_id && wpa_s->own_scan_running &&
|
|
|
|
own_request && !(data && data->scan_info.external_scan)) {
|
2013-12-26 16:35:48 +01:00
|
|
|
wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_SCAN_RESULTS "id=%u",
|
|
|
|
wpa_s->manual_scan_id);
|
|
|
|
wpa_s->manual_scan_use_id = 0;
|
|
|
|
} else {
|
|
|
|
wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_SCAN_RESULTS);
|
|
|
|
}
|
2010-07-07 05:31:10 +02:00
|
|
|
wpas_notify_scan_results(wpa_s);
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2009-09-13 19:53:32 +02:00
|
|
|
wpas_notify_scan_done(wpa_s, 1);
|
|
|
|
|
2020-03-15 20:18:16 +01:00
|
|
|
if (ap) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Ignore scan results in AP mode");
|
|
|
|
#ifdef CONFIG_AP
|
|
|
|
if (wpa_s->ap_iface->scan_cb)
|
|
|
|
wpa_s->ap_iface->scan_cb(wpa_s->ap_iface);
|
|
|
|
#endif /* CONFIG_AP */
|
|
|
|
goto scan_work_done;
|
|
|
|
}
|
|
|
|
|
2015-09-16 14:15:05 +02:00
|
|
|
if (data && data->scan_info.external_scan) {
|
2013-12-26 18:00:48 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Do not use results from externally requested scan operation for network selection");
|
|
|
|
wpa_scan_results_free(scan_res);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-11-22 19:12:12 +01:00
|
|
|
if (wnm_scan_process(wpa_s, 1) > 0)
|
2014-11-22 17:04:21 +01:00
|
|
|
goto scan_work_done;
|
|
|
|
|
2019-03-19 13:35:56 +01:00
|
|
|
if (sme_proc_obss_scan(wpa_s, scan_res) > 0)
|
2013-11-24 21:07:05 +01:00
|
|
|
goto scan_work_done;
|
2012-05-03 11:13:43 +02:00
|
|
|
|
2019-02-23 11:59:10 +01:00
|
|
|
if (own_request && data &&
|
2016-12-28 14:06:47 +01:00
|
|
|
wpas_beacon_rep_scan_process(wpa_s, scan_res, &data->scan_info) > 0)
|
|
|
|
goto scan_work_done;
|
|
|
|
|
2013-11-24 21:07:05 +01:00
|
|
|
if ((wpa_s->conf->ap_scan == 2 && !wpas_wps_searching(wpa_s)))
|
|
|
|
goto scan_work_done;
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2013-11-24 21:07:05 +01:00
|
|
|
if (autoscan_notify_scan(wpa_s, scan_res))
|
|
|
|
goto scan_work_done;
|
2012-06-26 17:55:41 +02:00
|
|
|
|
2009-09-14 16:25:03 +02:00
|
|
|
if (wpa_s->disconnected) {
|
|
|
|
wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
|
2013-11-24 21:07:05 +01:00
|
|
|
goto scan_work_done;
|
2009-09-14 16:25:03 +02:00
|
|
|
}
|
|
|
|
|
2011-09-26 13:57:23 +02:00
|
|
|
if (!wpas_driver_bss_selection(wpa_s) &&
|
2013-11-24 21:07:05 +01:00
|
|
|
bgscan_notify_scan(wpa_s, scan_res) == 1)
|
|
|
|
goto scan_work_done;
|
2010-01-02 15:41:38 +01:00
|
|
|
|
2012-08-27 12:48:11 +02:00
|
|
|
wpas_wps_update_ap_info(wpa_s, scan_res);
|
|
|
|
|
2015-12-10 11:56:04 +01:00
|
|
|
if (wpa_s->wpa_state >= WPA_AUTHENTICATING &&
|
|
|
|
wpa_s->wpa_state < WPA_COMPLETED)
|
|
|
|
goto scan_work_done;
|
|
|
|
|
2012-09-02 16:39:35 +02:00
|
|
|
wpa_scan_results_free(scan_res);
|
|
|
|
|
2015-09-16 14:15:05 +02:00
|
|
|
if (own_request && wpa_s->scan_work) {
|
2013-11-24 21:07:05 +01:00
|
|
|
struct wpa_radio_work *work = wpa_s->scan_work;
|
|
|
|
wpa_s->scan_work = NULL;
|
|
|
|
radio_work_done(work);
|
|
|
|
}
|
|
|
|
|
2019-09-15 15:19:45 +02:00
|
|
|
os_free(wpa_s->last_scan_freqs);
|
|
|
|
wpa_s->last_scan_freqs = NULL;
|
|
|
|
wpa_s->num_last_scan_freqs = 0;
|
|
|
|
if (own_request && data &&
|
|
|
|
data->scan_info.freqs && data->scan_info.num_freqs) {
|
|
|
|
wpa_s->last_scan_freqs = os_malloc(sizeof(int) *
|
|
|
|
data->scan_info.num_freqs);
|
|
|
|
if (wpa_s->last_scan_freqs) {
|
|
|
|
os_memcpy(wpa_s->last_scan_freqs,
|
|
|
|
data->scan_info.freqs,
|
|
|
|
sizeof(int) * data->scan_info.num_freqs);
|
|
|
|
wpa_s->num_last_scan_freqs = data->scan_info.num_freqs;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-11-17 11:23:09 +01:00
|
|
|
return wpas_select_network_from_last_scan(wpa_s, 1, own_request);
|
2013-11-24 21:07:05 +01:00
|
|
|
|
|
|
|
scan_work_done:
|
|
|
|
wpa_scan_results_free(scan_res);
|
2015-09-16 14:15:05 +02:00
|
|
|
if (own_request && wpa_s->scan_work) {
|
2013-11-24 21:07:05 +01:00
|
|
|
struct wpa_radio_work *work = wpa_s->scan_work;
|
|
|
|
wpa_s->scan_work = NULL;
|
|
|
|
radio_work_done(work);
|
|
|
|
}
|
|
|
|
return ret;
|
2012-09-02 19:18:48 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-04-23 17:24:00 +02:00
|
|
|
static int wpas_select_network_from_last_scan(struct wpa_supplicant *wpa_s,
|
2013-11-17 11:23:09 +01:00
|
|
|
int new_scan, int own_request)
|
2012-09-02 19:18:48 +02:00
|
|
|
{
|
|
|
|
struct wpa_bss *selected;
|
|
|
|
struct wpa_ssid *ssid = NULL;
|
2015-03-16 06:20:02 +01:00
|
|
|
int time_to_reenable = wpas_reenabled_network_time(wpa_s);
|
|
|
|
|
|
|
|
if (time_to_reenable > 0) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"Postpone network selection by %d seconds since all networks are disabled",
|
|
|
|
time_to_reenable);
|
|
|
|
eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
|
|
|
|
eloop_register_timeout(time_to_reenable, 0,
|
|
|
|
wpas_network_reenabled, wpa_s, NULL);
|
|
|
|
return 0;
|
|
|
|
}
|
2012-09-02 19:18:48 +02:00
|
|
|
|
2015-03-01 10:23:09 +01:00
|
|
|
if (wpa_s->p2p_mgmt)
|
|
|
|
return 0; /* no normal connection on p2p_mgmt interface */
|
|
|
|
|
2018-10-12 18:33:51 +02:00
|
|
|
wpa_s->owe_transition_search = 0;
|
2012-09-02 18:56:57 +02:00
|
|
|
selected = wpa_supplicant_pick_network(wpa_s, &ssid);
|
|
|
|
|
2016-07-08 04:39:12 +02:00
|
|
|
#ifdef CONFIG_MESH
|
|
|
|
if (wpa_s->ifmsh) {
|
|
|
|
wpa_msg(wpa_s, MSG_INFO,
|
|
|
|
"Avoiding join because we already joined a mesh group");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_MESH */
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
if (selected) {
|
2010-01-25 03:19:50 +01:00
|
|
|
int skip;
|
2012-09-02 16:39:35 +02:00
|
|
|
skip = !wpa_supplicant_need_to_roam(wpa_s, selected, ssid);
|
2011-10-30 21:37:12 +01:00
|
|
|
if (skip) {
|
2013-04-23 17:24:00 +02:00
|
|
|
if (new_scan)
|
|
|
|
wpa_supplicant_rsn_preauth_scan_results(wpa_s);
|
2011-02-16 17:55:37 +01:00
|
|
|
return 0;
|
2011-10-30 21:37:12 +01:00
|
|
|
}
|
2011-10-24 22:37:39 +02:00
|
|
|
|
2019-09-15 15:19:45 +02:00
|
|
|
wpa_s->suitable_network++;
|
|
|
|
|
2015-12-10 11:56:05 +01:00
|
|
|
if (ssid != wpa_s->current_ssid &&
|
|
|
|
wpa_s->wpa_state >= WPA_AUTHENTICATING) {
|
|
|
|
wpa_s->own_disconnect_req = 1;
|
|
|
|
wpa_supplicant_deauthenticate(
|
|
|
|
wpa_s, WLAN_REASON_DEAUTH_LEAVING);
|
|
|
|
}
|
|
|
|
|
2011-10-24 22:37:39 +02:00
|
|
|
if (wpa_supplicant_connect(wpa_s, selected, ssid) < 0) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Connect failed");
|
|
|
|
return -1;
|
|
|
|
}
|
2013-04-23 17:24:00 +02:00
|
|
|
if (new_scan)
|
|
|
|
wpa_supplicant_rsn_preauth_scan_results(wpa_s);
|
2012-09-14 03:07:02 +02:00
|
|
|
/*
|
2016-10-10 17:22:09 +02:00
|
|
|
* Do not allow other virtual radios to trigger operations based
|
|
|
|
* on these scan results since we do not want them to start
|
|
|
|
* other associations at the same time.
|
2012-09-14 03:07:02 +02:00
|
|
|
*/
|
|
|
|
return 1;
|
2008-02-28 02:34:43 +01:00
|
|
|
} else {
|
2019-09-15 15:19:45 +02:00
|
|
|
wpa_s->no_suitable_network++;
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "No suitable network found");
|
2009-09-29 16:11:36 +02:00
|
|
|
ssid = wpa_supplicant_pick_new_network(wpa_s);
|
|
|
|
if (ssid) {
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Setup a new network");
|
2009-09-29 16:11:36 +02:00
|
|
|
wpa_supplicant_associate(wpa_s, NULL, ssid);
|
2013-04-23 17:24:00 +02:00
|
|
|
if (new_scan)
|
|
|
|
wpa_supplicant_rsn_preauth_scan_results(wpa_s);
|
2013-11-17 11:23:09 +01:00
|
|
|
} else if (own_request) {
|
|
|
|
/*
|
|
|
|
* No SSID found. If SCAN results are as a result of
|
|
|
|
* own scan request and not due to a scan request on
|
|
|
|
* another shared interface, try another scan.
|
|
|
|
*/
|
2011-04-11 22:14:38 +02:00
|
|
|
int timeout_sec = wpa_s->scan_interval;
|
2010-04-11 18:10:01 +02:00
|
|
|
int timeout_usec = 0;
|
2010-07-18 23:30:25 +02:00
|
|
|
#ifdef CONFIG_P2P
|
2015-02-08 10:38:56 +01:00
|
|
|
int res;
|
|
|
|
|
|
|
|
res = wpas_p2p_scan_no_go_seen(wpa_s);
|
|
|
|
if (res == 2)
|
|
|
|
return 2;
|
|
|
|
if (res == 1)
|
2012-05-08 16:13:56 +02:00
|
|
|
return 0;
|
|
|
|
|
2013-11-12 15:17:35 +01:00
|
|
|
if (wpa_s->p2p_in_provisioning ||
|
2014-03-21 13:56:02 +01:00
|
|
|
wpa_s->show_group_started ||
|
|
|
|
wpa_s->p2p_in_invitation) {
|
2010-07-18 23:30:25 +02:00
|
|
|
/*
|
|
|
|
* Use shorter wait during P2P Provisioning
|
2013-11-12 15:17:35 +01:00
|
|
|
* state and during P2P join-a-group operation
|
|
|
|
* to speed up group formation.
|
2010-07-18 23:30:25 +02:00
|
|
|
*/
|
|
|
|
timeout_sec = 0;
|
|
|
|
timeout_usec = 250000;
|
2011-09-27 21:21:31 +02:00
|
|
|
wpa_supplicant_req_new_scan(wpa_s, timeout_sec,
|
|
|
|
timeout_usec);
|
|
|
|
return 0;
|
2010-07-18 23:30:25 +02:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_P2P */
|
2012-08-28 15:14:13 +02:00
|
|
|
#ifdef CONFIG_INTERWORKING
|
|
|
|
if (wpa_s->conf->auto_interworking &&
|
|
|
|
wpa_s->conf->interworking &&
|
|
|
|
wpa_s->conf->cred) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Interworking: "
|
|
|
|
"start ANQP fetch since no matching "
|
|
|
|
"networks found");
|
|
|
|
wpa_s->network_select = 1;
|
|
|
|
wpa_s->auto_network_select = 1;
|
|
|
|
interworking_start_fetch_anqp(wpa_s);
|
2012-09-14 03:07:02 +02:00
|
|
|
return 1;
|
2012-08-28 15:14:13 +02:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_INTERWORKING */
|
2013-11-28 11:56:21 +01:00
|
|
|
#ifdef CONFIG_WPS
|
2013-12-29 17:02:05 +01:00
|
|
|
if (wpa_s->after_wps > 0 || wpas_wps_searching(wpa_s)) {
|
2013-11-28 11:56:21 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Use shorter wait during WPS processing");
|
|
|
|
timeout_sec = 0;
|
|
|
|
timeout_usec = 500000;
|
|
|
|
wpa_supplicant_req_new_scan(wpa_s, timeout_sec,
|
|
|
|
timeout_usec);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_WPS */
|
2018-10-12 18:33:51 +02:00
|
|
|
#ifdef CONFIG_OWE
|
|
|
|
if (wpa_s->owe_transition_search) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"OWE: Use shorter wait during transition mode search");
|
|
|
|
timeout_sec = 0;
|
|
|
|
timeout_usec = 500000;
|
|
|
|
wpa_supplicant_req_new_scan(wpa_s, timeout_sec,
|
|
|
|
timeout_usec);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_OWE */
|
2011-09-27 21:21:31 +02:00
|
|
|
if (wpa_supplicant_req_sched_scan(wpa_s))
|
|
|
|
wpa_supplicant_req_new_scan(wpa_s, timeout_sec,
|
|
|
|
timeout_usec);
|
2015-06-19 19:33:50 +02:00
|
|
|
|
|
|
|
wpa_msg_ctrl(wpa_s, MSG_INFO,
|
|
|
|
WPA_EVENT_NETWORK_NOT_FOUND);
|
2010-04-11 18:10:01 +02:00
|
|
|
}
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
2011-02-16 17:55:37 +01:00
|
|
|
return 0;
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
2010-11-26 20:46:30 +01:00
|
|
|
|
|
|
|
|
2015-02-08 10:38:56 +01:00
|
|
|
static int wpa_supplicant_event_scan_results(struct wpa_supplicant *wpa_s,
|
|
|
|
union wpa_event_data *data)
|
2010-11-26 20:46:30 +01:00
|
|
|
{
|
|
|
|
struct wpa_supplicant *ifs;
|
2015-02-08 10:38:56 +01:00
|
|
|
int res;
|
2010-11-26 20:46:30 +01:00
|
|
|
|
2016-10-10 17:22:09 +02:00
|
|
|
res = _wpa_supplicant_event_scan_results(wpa_s, data, 1, 0);
|
2015-02-08 10:38:56 +01:00
|
|
|
if (res == 2) {
|
|
|
|
/*
|
|
|
|
* Interface may have been removed, so must not dereference
|
|
|
|
* wpa_s after this.
|
|
|
|
*/
|
|
|
|
return 1;
|
|
|
|
}
|
2016-10-10 17:22:09 +02:00
|
|
|
|
|
|
|
if (res < 0) {
|
2011-02-16 17:55:37 +01:00
|
|
|
/*
|
|
|
|
* If no scan results could be fetched, then no need to
|
|
|
|
* notify those interfaces that did not actually request
|
2012-09-14 03:07:02 +02:00
|
|
|
* this scan. Similarly, if scan results started a new operation on this
|
|
|
|
* interface, do not notify other interfaces to avoid concurrent
|
|
|
|
* operations during a connection attempt.
|
2011-02-16 17:55:37 +01:00
|
|
|
*/
|
2015-02-08 10:38:56 +01:00
|
|
|
return 0;
|
2011-02-16 17:55:37 +01:00
|
|
|
}
|
2010-11-26 20:46:30 +01:00
|
|
|
|
|
|
|
/*
|
2013-11-24 18:57:43 +01:00
|
|
|
* Check other interfaces to see if they share the same radio. If
|
2010-11-26 20:46:30 +01:00
|
|
|
* so, they get updated with this same scan info.
|
|
|
|
*/
|
2013-11-24 18:57:43 +01:00
|
|
|
dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
|
|
|
|
radio_list) {
|
|
|
|
if (ifs != wpa_s) {
|
2010-11-26 20:46:30 +01:00
|
|
|
wpa_printf(MSG_DEBUG, "%s: Updating scan results from "
|
|
|
|
"sibling", ifs->ifname);
|
2016-10-10 17:22:09 +02:00
|
|
|
res = _wpa_supplicant_event_scan_results(ifs, data, 0,
|
|
|
|
res > 0);
|
|
|
|
if (res < 0)
|
|
|
|
return 0;
|
2010-11-26 20:46:30 +01:00
|
|
|
}
|
|
|
|
}
|
2015-02-08 10:38:56 +01:00
|
|
|
|
|
|
|
return 0;
|
2010-11-26 20:46:30 +01:00
|
|
|
}
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
#endif /* CONFIG_NO_SCAN_PROCESSING */
|
|
|
|
|
|
|
|
|
2013-02-03 20:08:31 +01:00
|
|
|
int wpa_supplicant_fast_associate(struct wpa_supplicant *wpa_s)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_NO_SCAN_PROCESSING
|
|
|
|
return -1;
|
|
|
|
#else /* CONFIG_NO_SCAN_PROCESSING */
|
2013-12-16 21:08:44 +01:00
|
|
|
struct os_reltime now;
|
2013-02-03 20:08:31 +01:00
|
|
|
|
2016-12-10 18:00:47 +01:00
|
|
|
wpa_s->ignore_post_flush_scan_res = 0;
|
|
|
|
|
2015-06-23 20:12:29 +02:00
|
|
|
if (wpa_s->last_scan_res_used == 0)
|
2013-02-03 20:08:31 +01:00
|
|
|
return -1;
|
|
|
|
|
2013-12-16 21:08:44 +01:00
|
|
|
os_get_reltime(&now);
|
2020-01-02 10:51:04 +01:00
|
|
|
if (os_reltime_expired(&now, &wpa_s->last_scan,
|
2020-11-04 10:30:27 +01:00
|
|
|
wpa_s->conf->scan_res_valid_for_connect)) {
|
2013-02-03 20:08:31 +01:00
|
|
|
wpa_printf(MSG_DEBUG, "Fast associate: Old scan results");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-11-17 11:23:09 +01:00
|
|
|
return wpas_select_network_from_last_scan(wpa_s, 0, 1);
|
2013-02-03 20:08:31 +01:00
|
|
|
#endif /* CONFIG_NO_SCAN_PROCESSING */
|
|
|
|
}
|
|
|
|
|
2012-05-28 02:35:00 +02:00
|
|
|
#ifdef CONFIG_WNM
|
|
|
|
|
|
|
|
static void wnm_bss_keep_alive(void *eloop_ctx, void *sock_ctx)
|
|
|
|
{
|
|
|
|
struct wpa_supplicant *wpa_s = eloop_ctx;
|
|
|
|
|
|
|
|
if (wpa_s->wpa_state < WPA_ASSOCIATED)
|
|
|
|
return;
|
|
|
|
|
2012-12-18 15:57:52 +01:00
|
|
|
if (!wpa_s->no_keep_alive) {
|
|
|
|
wpa_printf(MSG_DEBUG, "WNM: Send keep-alive to AP " MACSTR,
|
|
|
|
MAC2STR(wpa_s->bssid));
|
|
|
|
/* TODO: could skip this if normal data traffic has been sent */
|
|
|
|
/* TODO: Consider using some more appropriate data frame for
|
|
|
|
* this */
|
|
|
|
if (wpa_s->l2)
|
|
|
|
l2_packet_send(wpa_s->l2, wpa_s->bssid, 0x0800,
|
|
|
|
(u8 *) "", 0);
|
|
|
|
}
|
2012-05-28 02:35:00 +02:00
|
|
|
|
2012-05-28 03:17:41 +02:00
|
|
|
#ifdef CONFIG_SME
|
2012-05-28 02:35:00 +02:00
|
|
|
if (wpa_s->sme.bss_max_idle_period) {
|
|
|
|
unsigned int msec;
|
|
|
|
msec = wpa_s->sme.bss_max_idle_period * 1024; /* times 1000 */
|
|
|
|
if (msec > 100)
|
|
|
|
msec -= 100;
|
|
|
|
eloop_register_timeout(msec / 1000, msec % 1000 * 1000,
|
|
|
|
wnm_bss_keep_alive, wpa_s, NULL);
|
|
|
|
}
|
2012-05-28 03:17:41 +02:00
|
|
|
#endif /* CONFIG_SME */
|
2012-05-28 02:35:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void wnm_process_assoc_resp(struct wpa_supplicant *wpa_s,
|
|
|
|
const u8 *ies, size_t ies_len)
|
|
|
|
{
|
|
|
|
struct ieee802_11_elems elems;
|
|
|
|
|
|
|
|
if (ies == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (ieee802_11_parse_elems(ies, ies_len, &elems, 1) == ParseFailed)
|
|
|
|
return;
|
|
|
|
|
|
|
|
#ifdef CONFIG_SME
|
|
|
|
if (elems.bss_max_idle_period) {
|
|
|
|
unsigned int msec;
|
|
|
|
wpa_s->sme.bss_max_idle_period =
|
|
|
|
WPA_GET_LE16(elems.bss_max_idle_period);
|
|
|
|
wpa_printf(MSG_DEBUG, "WNM: BSS Max Idle Period: %u (* 1000 "
|
|
|
|
"TU)%s", wpa_s->sme.bss_max_idle_period,
|
|
|
|
(elems.bss_max_idle_period[2] & 0x01) ?
|
|
|
|
" (protected keep-live required)" : "");
|
|
|
|
if (wpa_s->sme.bss_max_idle_period == 0)
|
|
|
|
wpa_s->sme.bss_max_idle_period = 1;
|
|
|
|
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) {
|
|
|
|
eloop_cancel_timeout(wnm_bss_keep_alive, wpa_s, NULL);
|
|
|
|
/* msec times 1000 */
|
|
|
|
msec = wpa_s->sme.bss_max_idle_period * 1024;
|
|
|
|
if (msec > 100)
|
|
|
|
msec -= 100;
|
|
|
|
eloop_register_timeout(msec / 1000, msec % 1000 * 1000,
|
|
|
|
wnm_bss_keep_alive, wpa_s,
|
|
|
|
NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SME */
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_WNM */
|
|
|
|
|
|
|
|
|
|
|
|
void wnm_bss_keep_alive_deinit(struct wpa_supplicant *wpa_s)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_WNM
|
|
|
|
eloop_cancel_timeout(wnm_bss_keep_alive, wpa_s, NULL);
|
|
|
|
#endif /* CONFIG_WNM */
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-07-24 12:17:56 +02:00
|
|
|
#ifdef CONFIG_INTERWORKING
|
|
|
|
|
|
|
|
static int wpas_qos_map_set(struct wpa_supplicant *wpa_s, const u8 *qos_map,
|
|
|
|
size_t len)
|
|
|
|
{
|
|
|
|
int res;
|
|
|
|
|
|
|
|
wpa_hexdump(MSG_DEBUG, "Interworking: QoS Map Set", qos_map, len);
|
|
|
|
res = wpa_drv_set_qos_map(wpa_s, qos_map, len);
|
|
|
|
if (res) {
|
|
|
|
wpa_printf(MSG_DEBUG, "Interworking: Failed to configure QoS Map Set to the driver");
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void interworking_process_assoc_resp(struct wpa_supplicant *wpa_s,
|
|
|
|
const u8 *ies, size_t ies_len)
|
|
|
|
{
|
|
|
|
struct ieee802_11_elems elems;
|
|
|
|
|
|
|
|
if (ies == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (ieee802_11_parse_elems(ies, ies_len, &elems, 1) == ParseFailed)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (elems.qos_map_set) {
|
|
|
|
wpas_qos_map_set(wpa_s, elems.qos_map_set,
|
|
|
|
elems.qos_map_set_len);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_INTERWORKING */
|
|
|
|
|
|
|
|
|
2018-12-05 11:23:53 +01:00
|
|
|
static void multi_ap_process_assoc_resp(struct wpa_supplicant *wpa_s,
|
|
|
|
const u8 *ies, size_t ies_len)
|
|
|
|
{
|
|
|
|
struct ieee802_11_elems elems;
|
|
|
|
const u8 *map_sub_elem, *pos;
|
|
|
|
size_t len;
|
|
|
|
|
2020-03-11 11:41:54 +01:00
|
|
|
wpa_s->multi_ap_ie = 0;
|
2018-12-05 11:23:53 +01:00
|
|
|
|
2020-03-11 11:41:54 +01:00
|
|
|
if (!ies ||
|
|
|
|
ieee802_11_parse_elems(ies, ies_len, &elems, 1) == ParseFailed ||
|
|
|
|
!elems.multi_ap || elems.multi_ap_len < 7)
|
|
|
|
return;
|
2018-12-05 11:23:53 +01:00
|
|
|
|
|
|
|
pos = elems.multi_ap + 4;
|
|
|
|
len = elems.multi_ap_len - 4;
|
|
|
|
|
|
|
|
map_sub_elem = get_ie(pos, len, MULTI_AP_SUB_ELEM_TYPE);
|
2020-03-11 11:41:54 +01:00
|
|
|
if (!map_sub_elem || map_sub_elem[1] < 1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
wpa_s->multi_ap_backhaul = !!(map_sub_elem[2] & MULTI_AP_BACKHAUL_BSS);
|
|
|
|
wpa_s->multi_ap_fronthaul = !!(map_sub_elem[2] &
|
|
|
|
MULTI_AP_FRONTHAUL_BSS);
|
|
|
|
wpa_s->multi_ap_ie = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void multi_ap_set_4addr_mode(struct wpa_supplicant *wpa_s)
|
|
|
|
{
|
|
|
|
if (!wpa_s->current_ssid ||
|
|
|
|
!wpa_s->current_ssid->multi_ap_backhaul_sta)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!wpa_s->multi_ap_ie) {
|
|
|
|
wpa_printf(MSG_INFO,
|
|
|
|
"AP does not include valid Multi-AP element");
|
2018-12-05 11:23:53 +01:00
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2020-03-11 11:41:54 +01:00
|
|
|
if (!wpa_s->multi_ap_backhaul) {
|
|
|
|
if (wpa_s->multi_ap_fronthaul &&
|
2019-02-12 15:35:25 +01:00
|
|
|
wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_WPS) {
|
|
|
|
wpa_printf(MSG_INFO,
|
|
|
|
"WPS active, accepting fronthaul-only BSS");
|
|
|
|
/* Don't set 4addr mode in this case, so just return */
|
|
|
|
return;
|
|
|
|
}
|
2018-12-05 11:23:53 +01:00
|
|
|
wpa_printf(MSG_INFO, "AP doesn't support backhaul BSS");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wpa_drv_set_4addr_mode(wpa_s, 1) < 0) {
|
|
|
|
wpa_printf(MSG_ERROR, "Failed to set 4addr mode");
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
wpa_s->enabled_4addr_mode = 1;
|
|
|
|
return;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_DEAUTH_LEAVING);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-11-22 13:46:54 +01:00
|
|
|
#ifdef CONFIG_FST
|
|
|
|
static int wpas_fst_update_mbie(struct wpa_supplicant *wpa_s,
|
|
|
|
const u8 *ie, size_t ie_len)
|
|
|
|
{
|
|
|
|
struct mb_ies_info mb_ies;
|
|
|
|
|
|
|
|
if (!ie || !ie_len || !wpa_s->fst)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
os_memset(&mb_ies, 0, sizeof(mb_ies));
|
|
|
|
|
|
|
|
while (ie_len >= 2 && mb_ies.nof_ies < MAX_NOF_MB_IES_SUPPORTED) {
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
len = 2 + ie[1];
|
|
|
|
if (len > ie_len) {
|
|
|
|
wpa_hexdump(MSG_DEBUG, "FST: Truncated IE found",
|
|
|
|
ie, ie_len);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ie[0] == WLAN_EID_MULTI_BAND) {
|
|
|
|
wpa_printf(MSG_DEBUG, "MB IE of %u bytes found",
|
|
|
|
(unsigned int) len);
|
|
|
|
mb_ies.ies[mb_ies.nof_ies].ie = ie + 2;
|
|
|
|
mb_ies.ies[mb_ies.nof_ies].ie_len = len - 2;
|
|
|
|
mb_ies.nof_ies++;
|
|
|
|
}
|
|
|
|
|
|
|
|
ie_len -= len;
|
|
|
|
ie += len;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mb_ies.nof_ies > 0) {
|
|
|
|
wpabuf_free(wpa_s->received_mb_ies);
|
|
|
|
wpa_s->received_mb_ies = mb_ies_by_info(&mb_ies);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_FST */
|
|
|
|
|
|
|
|
|
2010-04-09 15:59:27 +02:00
|
|
|
static int wpa_supplicant_event_associnfo(struct wpa_supplicant *wpa_s,
|
|
|
|
union wpa_event_data *data)
|
2008-02-28 02:34:43 +01:00
|
|
|
{
|
2019-10-17 15:54:05 +02:00
|
|
|
int l, len, found = 0, found_x = 0, wpa_found, rsn_found;
|
2009-03-20 21:26:41 +01:00
|
|
|
const u8 *p;
|
2013-03-12 19:08:53 +01:00
|
|
|
u8 bssid[ETH_ALEN];
|
2020-08-05 19:25:32 +02:00
|
|
|
bool bssid_known;
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Association info event");
|
2020-08-05 19:25:32 +02:00
|
|
|
bssid_known = wpa_drv_get_bssid(wpa_s, bssid) == 0;
|
2008-02-28 02:34:43 +01:00
|
|
|
if (data->assoc_info.req_ies)
|
|
|
|
wpa_hexdump(MSG_DEBUG, "req_ies", data->assoc_info.req_ies,
|
|
|
|
data->assoc_info.req_ies_len);
|
2011-01-28 18:27:28 +01:00
|
|
|
if (data->assoc_info.resp_ies) {
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_hexdump(MSG_DEBUG, "resp_ies", data->assoc_info.resp_ies,
|
|
|
|
data->assoc_info.resp_ies_len);
|
2011-01-28 18:27:28 +01:00
|
|
|
#ifdef CONFIG_TDLS
|
|
|
|
wpa_tdls_assoc_resp_ies(wpa_s->wpa, data->assoc_info.resp_ies,
|
|
|
|
data->assoc_info.resp_ies_len);
|
|
|
|
#endif /* CONFIG_TDLS */
|
2012-05-28 02:35:00 +02:00
|
|
|
#ifdef CONFIG_WNM
|
|
|
|
wnm_process_assoc_resp(wpa_s, data->assoc_info.resp_ies,
|
|
|
|
data->assoc_info.resp_ies_len);
|
|
|
|
#endif /* CONFIG_WNM */
|
2013-07-24 12:17:56 +02:00
|
|
|
#ifdef CONFIG_INTERWORKING
|
|
|
|
interworking_process_assoc_resp(wpa_s, data->assoc_info.resp_ies,
|
|
|
|
data->assoc_info.resp_ies_len);
|
|
|
|
#endif /* CONFIG_INTERWORKING */
|
2018-04-24 09:54:20 +02:00
|
|
|
if (wpa_s->hw_capab == CAPAB_VHT &&
|
|
|
|
get_ie(data->assoc_info.resp_ies,
|
|
|
|
data->assoc_info.resp_ies_len, WLAN_EID_VHT_CAP))
|
|
|
|
wpa_s->ieee80211ac = 1;
|
2018-12-05 11:23:53 +01:00
|
|
|
|
|
|
|
multi_ap_process_assoc_resp(wpa_s, data->assoc_info.resp_ies,
|
|
|
|
data->assoc_info.resp_ies_len);
|
2011-01-28 18:27:28 +01:00
|
|
|
}
|
2008-02-28 02:34:43 +01:00
|
|
|
if (data->assoc_info.beacon_ies)
|
|
|
|
wpa_hexdump(MSG_DEBUG, "beacon_ies",
|
|
|
|
data->assoc_info.beacon_ies,
|
|
|
|
data->assoc_info.beacon_ies_len);
|
2009-12-28 12:23:13 +01:00
|
|
|
if (data->assoc_info.freq)
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "freq=%u MHz",
|
|
|
|
data->assoc_info.freq);
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2019-02-14 21:24:16 +01:00
|
|
|
wpa_s->connection_set = 0;
|
|
|
|
if (data->assoc_info.req_ies && data->assoc_info.resp_ies) {
|
|
|
|
struct ieee802_11_elems req_elems, resp_elems;
|
|
|
|
|
|
|
|
if (ieee802_11_parse_elems(data->assoc_info.req_ies,
|
|
|
|
data->assoc_info.req_ies_len,
|
|
|
|
&req_elems, 0) != ParseFailed &&
|
|
|
|
ieee802_11_parse_elems(data->assoc_info.resp_ies,
|
|
|
|
data->assoc_info.resp_ies_len,
|
|
|
|
&resp_elems, 0) != ParseFailed) {
|
|
|
|
wpa_s->connection_set = 1;
|
|
|
|
wpa_s->connection_ht = req_elems.ht_capabilities &&
|
|
|
|
resp_elems.ht_capabilities;
|
2020-02-10 20:34:33 +01:00
|
|
|
/* Do not include subset of VHT on 2.4 GHz vendor
|
|
|
|
* extension in consideration for reporting VHT
|
|
|
|
* association. */
|
2019-02-14 21:24:16 +01:00
|
|
|
wpa_s->connection_vht = req_elems.vht_capabilities &&
|
2020-02-10 20:34:33 +01:00
|
|
|
resp_elems.vht_capabilities &&
|
|
|
|
(!data->assoc_info.freq ||
|
|
|
|
wpas_freq_to_band(data->assoc_info.freq) !=
|
|
|
|
BAND_2_4_GHZ);
|
2019-02-14 21:24:16 +01:00
|
|
|
wpa_s->connection_he = req_elems.he_capabilities &&
|
|
|
|
resp_elems.he_capabilities;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
p = data->assoc_info.req_ies;
|
|
|
|
l = data->assoc_info.req_ies_len;
|
|
|
|
|
|
|
|
/* Go through the IEs and make a copy of the WPA/RSN IE, if present. */
|
|
|
|
while (p && l >= 2) {
|
|
|
|
len = p[1] + 2;
|
|
|
|
if (len > l) {
|
|
|
|
wpa_hexdump(MSG_DEBUG, "Truncated IE in assoc_info",
|
|
|
|
p, l);
|
|
|
|
break;
|
|
|
|
}
|
2019-10-17 15:54:05 +02:00
|
|
|
if (!found &&
|
|
|
|
((p[0] == WLAN_EID_VENDOR_SPECIFIC && p[1] >= 6 &&
|
|
|
|
(os_memcmp(&p[2], "\x00\x50\xF2\x01\x01\x00", 6) == 0)) ||
|
|
|
|
(p[0] == WLAN_EID_VENDOR_SPECIFIC && p[1] >= 4 &&
|
|
|
|
(os_memcmp(&p[2], "\x50\x6F\x9A\x12", 4) == 0)) ||
|
|
|
|
(p[0] == WLAN_EID_RSN && p[1] >= 2))) {
|
2008-02-28 02:34:43 +01:00
|
|
|
if (wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, p, len))
|
|
|
|
break;
|
|
|
|
found = 1;
|
|
|
|
wpa_find_assoc_pmkid(wpa_s);
|
2019-10-17 15:54:05 +02:00
|
|
|
}
|
|
|
|
if (!found_x && p[0] == WLAN_EID_RSNX) {
|
|
|
|
if (wpa_sm_set_assoc_rsnxe(wpa_s->wpa, p, len))
|
|
|
|
break;
|
|
|
|
found_x = 1;
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
|
|
|
l -= len;
|
|
|
|
p += len;
|
|
|
|
}
|
|
|
|
if (!found && data->assoc_info.req_ies)
|
|
|
|
wpa_sm_set_assoc_wpa_ie(wpa_s->wpa, NULL, 0);
|
2019-10-17 15:54:05 +02:00
|
|
|
if (!found_x && data->assoc_info.req_ies)
|
|
|
|
wpa_sm_set_assoc_rsnxe(wpa_s->wpa, NULL, 0);
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2015-09-09 16:34:13 +02:00
|
|
|
#ifdef CONFIG_FILS
|
|
|
|
#ifdef CONFIG_SME
|
2017-03-12 21:45:35 +01:00
|
|
|
if ((wpa_s->sme.auth_alg == WPA_AUTH_ALG_FILS ||
|
|
|
|
wpa_s->sme.auth_alg == WPA_AUTH_ALG_FILS_SK_PFS) &&
|
2015-09-09 16:34:13 +02:00
|
|
|
(!data->assoc_info.resp_frame ||
|
|
|
|
fils_process_assoc_resp(wpa_s->wpa,
|
|
|
|
data->assoc_info.resp_frame,
|
|
|
|
data->assoc_info.resp_frame_len) < 0)) {
|
|
|
|
wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_UNSPECIFIED);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SME */
|
2017-03-22 11:40:05 +01:00
|
|
|
|
|
|
|
/* Additional processing for FILS when SME is in driver */
|
|
|
|
if (wpa_s->auth_alg == WPA_AUTH_ALG_FILS &&
|
|
|
|
!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME))
|
|
|
|
wpa_sm_set_reset_fils_completed(wpa_s->wpa, 1);
|
2015-09-09 16:34:13 +02:00
|
|
|
#endif /* CONFIG_FILS */
|
|
|
|
|
2017-03-12 10:53:21 +01:00
|
|
|
#ifdef CONFIG_OWE
|
|
|
|
if (wpa_s->key_mgmt == WPA_KEY_MGMT_OWE &&
|
2020-08-05 19:25:32 +02:00
|
|
|
(!bssid_known ||
|
2017-10-09 11:08:57 +02:00
|
|
|
owe_process_assoc_resp(wpa_s->wpa, bssid,
|
|
|
|
data->assoc_info.resp_ies,
|
|
|
|
data->assoc_info.resp_ies_len) < 0)) {
|
2017-03-12 10:53:21 +01:00
|
|
|
wpa_supplicant_deauthenticate(wpa_s, WLAN_REASON_UNSPECIFIED);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_OWE */
|
|
|
|
|
2019-03-17 22:51:53 +01:00
|
|
|
#ifdef CONFIG_DPP2
|
|
|
|
wpa_sm_set_dpp_z(wpa_s->wpa, NULL);
|
2020-05-01 20:07:42 +02:00
|
|
|
if (DPP_VERSION > 1 && wpa_s->key_mgmt == WPA_KEY_MGMT_DPP &&
|
|
|
|
wpa_s->dpp_pfs) {
|
2019-03-17 22:51:53 +01:00
|
|
|
struct ieee802_11_elems elems;
|
|
|
|
|
|
|
|
if (ieee802_11_parse_elems(data->assoc_info.resp_ies,
|
|
|
|
data->assoc_info.resp_ies_len,
|
|
|
|
&elems, 0) == ParseFailed ||
|
|
|
|
!elems.owe_dh)
|
|
|
|
goto no_pfs;
|
|
|
|
if (dpp_pfs_process(wpa_s->dpp_pfs, elems.owe_dh,
|
|
|
|
elems.owe_dh_len) < 0) {
|
|
|
|
wpa_supplicant_deauthenticate(wpa_s,
|
|
|
|
WLAN_REASON_UNSPECIFIED);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
wpa_sm_set_dpp_z(wpa_s->wpa, wpa_s->dpp_pfs->secret);
|
|
|
|
}
|
|
|
|
no_pfs:
|
|
|
|
#endif /* CONFIG_DPP2 */
|
|
|
|
|
2009-03-20 21:26:41 +01:00
|
|
|
#ifdef CONFIG_IEEE80211R
|
2010-03-13 20:13:18 +01:00
|
|
|
#ifdef CONFIG_SME
|
|
|
|
if (wpa_s->sme.auth_alg == WPA_AUTH_ALG_FT) {
|
2020-08-05 19:25:32 +02:00
|
|
|
if (!bssid_known ||
|
2010-03-13 20:13:18 +01:00
|
|
|
wpa_ft_validate_reassoc_resp(wpa_s->wpa,
|
|
|
|
data->assoc_info.resp_ies,
|
|
|
|
data->assoc_info.resp_ies_len,
|
|
|
|
bssid) < 0) {
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "FT: Validation of "
|
|
|
|
"Reassociation Response failed");
|
2010-04-09 15:59:27 +02:00
|
|
|
wpa_supplicant_deauthenticate(
|
|
|
|
wpa_s, WLAN_REASON_INVALID_IE);
|
|
|
|
return -1;
|
2010-03-13 20:13:18 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-20 21:26:41 +01:00
|
|
|
p = data->assoc_info.resp_ies;
|
|
|
|
l = data->assoc_info.resp_ies_len;
|
|
|
|
|
2010-05-26 16:16:14 +02:00
|
|
|
#ifdef CONFIG_WPS_STRICT
|
2011-04-14 01:55:38 +02:00
|
|
|
if (p && wpa_s->current_ssid &&
|
2010-05-26 16:16:14 +02:00
|
|
|
wpa_s->current_ssid->key_mgmt == WPA_KEY_MGMT_WPS) {
|
|
|
|
struct wpabuf *wps;
|
|
|
|
wps = ieee802_11_vendor_ie_concat(p, l, WPS_IE_VENDOR_TYPE);
|
|
|
|
if (wps == NULL) {
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_msg(wpa_s, MSG_INFO, "WPS-STRICT: AP did not "
|
|
|
|
"include WPS IE in (Re)Association Response");
|
2010-05-26 16:16:14 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wps_validate_assoc_resp(wps) < 0) {
|
|
|
|
wpabuf_free(wps);
|
|
|
|
wpa_supplicant_deauthenticate(
|
|
|
|
wpa_s, WLAN_REASON_INVALID_IE);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
wpabuf_free(wps);
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_WPS_STRICT */
|
|
|
|
|
2010-04-10 10:36:35 +02:00
|
|
|
/* Go through the IEs and make a copy of the MDIE, if present. */
|
2009-03-20 21:26:41 +01:00
|
|
|
while (p && l >= 2) {
|
|
|
|
len = p[1] + 2;
|
|
|
|
if (len > l) {
|
|
|
|
wpa_hexdump(MSG_DEBUG, "Truncated IE in assoc_info",
|
|
|
|
p, l);
|
|
|
|
break;
|
|
|
|
}
|
2010-04-10 10:36:35 +02:00
|
|
|
if (p[0] == WLAN_EID_MOBILITY_DOMAIN &&
|
|
|
|
p[1] >= MOBILITY_DOMAIN_ID_LEN) {
|
|
|
|
wpa_s->sme.ft_used = 1;
|
|
|
|
os_memcpy(wpa_s->sme.mobility_domain, p + 2,
|
|
|
|
MOBILITY_DOMAIN_ID_LEN);
|
|
|
|
break;
|
|
|
|
}
|
2009-03-20 21:26:41 +01:00
|
|
|
l -= len;
|
|
|
|
p += len;
|
|
|
|
}
|
2010-04-10 10:36:35 +02:00
|
|
|
#endif /* CONFIG_SME */
|
2009-03-20 21:26:41 +01:00
|
|
|
|
2013-03-12 19:08:53 +01:00
|
|
|
/* Process FT when SME is in the driver */
|
|
|
|
if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
|
|
|
|
wpa_ft_is_completed(wpa_s->wpa)) {
|
2020-08-05 19:25:32 +02:00
|
|
|
if (!bssid_known ||
|
2013-03-12 19:08:53 +01:00
|
|
|
wpa_ft_validate_reassoc_resp(wpa_s->wpa,
|
|
|
|
data->assoc_info.resp_ies,
|
|
|
|
data->assoc_info.resp_ies_len,
|
|
|
|
bssid) < 0) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "FT: Validation of "
|
|
|
|
"Reassociation Response failed");
|
|
|
|
wpa_supplicant_deauthenticate(
|
|
|
|
wpa_s, WLAN_REASON_INVALID_IE);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "FT: Reassociation Response done");
|
|
|
|
}
|
|
|
|
|
2010-04-10 10:36:35 +02:00
|
|
|
wpa_sm_set_ft_params(wpa_s->wpa, data->assoc_info.resp_ies,
|
|
|
|
data->assoc_info.resp_ies_len);
|
2009-03-20 21:26:41 +01:00
|
|
|
#endif /* CONFIG_IEEE80211R */
|
|
|
|
|
2020-08-05 19:25:32 +02:00
|
|
|
if (bssid_known)
|
|
|
|
wpas_handle_assoc_resp_mscs(wpa_s, bssid,
|
|
|
|
data->assoc_info.resp_ies,
|
|
|
|
data->assoc_info.resp_ies_len);
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
/* WPA/RSN IE from Beacon/ProbeResp */
|
|
|
|
p = data->assoc_info.beacon_ies;
|
|
|
|
l = data->assoc_info.beacon_ies_len;
|
|
|
|
|
|
|
|
/* Go through the IEs and make a copy of the WPA/RSN IEs, if present.
|
|
|
|
*/
|
|
|
|
wpa_found = rsn_found = 0;
|
|
|
|
while (p && l >= 2) {
|
|
|
|
len = p[1] + 2;
|
|
|
|
if (len > l) {
|
|
|
|
wpa_hexdump(MSG_DEBUG, "Truncated IE in beacon_ies",
|
|
|
|
p, l);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!wpa_found &&
|
|
|
|
p[0] == WLAN_EID_VENDOR_SPECIFIC && p[1] >= 6 &&
|
|
|
|
os_memcmp(&p[2], "\x00\x50\xF2\x01\x01\x00", 6) == 0) {
|
|
|
|
wpa_found = 1;
|
|
|
|
wpa_sm_set_ap_wpa_ie(wpa_s->wpa, p, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!rsn_found &&
|
|
|
|
p[0] == WLAN_EID_RSN && p[1] >= 2) {
|
|
|
|
rsn_found = 1;
|
|
|
|
wpa_sm_set_ap_rsn_ie(wpa_s->wpa, p, len);
|
|
|
|
}
|
|
|
|
|
2019-09-06 13:51:31 +02:00
|
|
|
if (p[0] == WLAN_EID_RSNX && p[1] >= 1)
|
|
|
|
wpa_sm_set_ap_rsnxe(wpa_s->wpa, p, len);
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
l -= len;
|
|
|
|
p += len;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!wpa_found && data->assoc_info.beacon_ies)
|
|
|
|
wpa_sm_set_ap_wpa_ie(wpa_s->wpa, NULL, 0);
|
2019-09-06 13:51:31 +02:00
|
|
|
if (!rsn_found && data->assoc_info.beacon_ies) {
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_sm_set_ap_rsn_ie(wpa_s->wpa, NULL, 0);
|
2019-09-06 13:51:31 +02:00
|
|
|
wpa_sm_set_ap_rsnxe(wpa_s->wpa, NULL, 0);
|
|
|
|
}
|
2008-02-28 02:34:43 +01:00
|
|
|
if (wpa_found || rsn_found)
|
|
|
|
wpa_s->ap_ies_from_associnfo = 1;
|
2009-12-28 12:23:13 +01:00
|
|
|
|
2011-05-16 18:19:30 +02:00
|
|
|
if (wpa_s->assoc_freq && data->assoc_info.freq &&
|
|
|
|
wpa_s->assoc_freq != data->assoc_info.freq) {
|
|
|
|
wpa_printf(MSG_DEBUG, "Operating frequency changed from "
|
|
|
|
"%u to %u MHz",
|
|
|
|
wpa_s->assoc_freq, data->assoc_info.freq);
|
|
|
|
wpa_supplicant_update_scan_results(wpa_s);
|
|
|
|
}
|
|
|
|
|
2009-12-28 12:23:13 +01:00
|
|
|
wpa_s->assoc_freq = data->assoc_info.freq;
|
2010-04-09 15:59:27 +02:00
|
|
|
|
|
|
|
return 0;
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-11 09:51:31 +01:00
|
|
|
static int wpa_supplicant_assoc_update_ie(struct wpa_supplicant *wpa_s)
|
|
|
|
{
|
2019-09-06 13:51:31 +02:00
|
|
|
const u8 *bss_wpa = NULL, *bss_rsn = NULL, *bss_rsnx = NULL;
|
2012-02-11 09:51:31 +01:00
|
|
|
|
|
|
|
if (!wpa_s->current_bss || !wpa_s->current_ssid)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (!wpa_key_mgmt_wpa_any(wpa_s->current_ssid->key_mgmt))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bss_wpa = wpa_bss_get_vendor_ie(wpa_s->current_bss,
|
|
|
|
WPA_IE_VENDOR_TYPE);
|
|
|
|
bss_rsn = wpa_bss_get_ie(wpa_s->current_bss, WLAN_EID_RSN);
|
2019-09-06 13:51:31 +02:00
|
|
|
bss_rsnx = wpa_bss_get_ie(wpa_s->current_bss, WLAN_EID_RSNX);
|
2012-02-11 09:51:31 +01:00
|
|
|
|
|
|
|
if (wpa_sm_set_ap_wpa_ie(wpa_s->wpa, bss_wpa,
|
|
|
|
bss_wpa ? 2 + bss_wpa[1] : 0) ||
|
|
|
|
wpa_sm_set_ap_rsn_ie(wpa_s->wpa, bss_rsn,
|
2019-09-06 13:51:31 +02:00
|
|
|
bss_rsn ? 2 + bss_rsn[1] : 0) ||
|
|
|
|
wpa_sm_set_ap_rsnxe(wpa_s->wpa, bss_rsnx,
|
|
|
|
bss_rsnx ? 2 + bss_rsnx[1] : 0))
|
2012-02-11 09:51:31 +01:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-11-22 13:46:54 +01:00
|
|
|
static void wpas_fst_update_mb_assoc(struct wpa_supplicant *wpa_s,
|
|
|
|
union wpa_event_data *data)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_FST
|
|
|
|
struct assoc_info *ai = data ? &data->assoc_info : NULL;
|
|
|
|
struct wpa_bss *bss = wpa_s->current_bss;
|
|
|
|
const u8 *ieprb, *iebcn;
|
|
|
|
|
|
|
|
wpabuf_free(wpa_s->received_mb_ies);
|
|
|
|
wpa_s->received_mb_ies = NULL;
|
|
|
|
|
|
|
|
if (ai &&
|
|
|
|
!wpas_fst_update_mbie(wpa_s, ai->resp_ies, ai->resp_ies_len)) {
|
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
"FST: MB IEs updated from Association Response frame");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ai &&
|
|
|
|
!wpas_fst_update_mbie(wpa_s, ai->beacon_ies, ai->beacon_ies_len)) {
|
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
"FST: MB IEs updated from association event Beacon IEs");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!bss)
|
|
|
|
return;
|
|
|
|
|
2020-11-16 15:21:56 +01:00
|
|
|
ieprb = wpa_bss_ie_ptr(bss);
|
2015-11-22 13:46:54 +01:00
|
|
|
iebcn = ieprb + bss->ie_len;
|
|
|
|
|
|
|
|
if (!wpas_fst_update_mbie(wpa_s, ieprb, bss->ie_len))
|
|
|
|
wpa_printf(MSG_DEBUG, "FST: MB IEs updated from bss IE");
|
|
|
|
else if (!wpas_fst_update_mbie(wpa_s, iebcn, bss->beacon_ie_len))
|
|
|
|
wpa_printf(MSG_DEBUG, "FST: MB IEs updated from bss beacon IE");
|
|
|
|
#endif /* CONFIG_FST */
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
static void wpa_supplicant_event_assoc(struct wpa_supplicant *wpa_s,
|
|
|
|
union wpa_event_data *data)
|
|
|
|
{
|
|
|
|
u8 bssid[ETH_ALEN];
|
2016-08-10 22:51:21 +02:00
|
|
|
int ft_completed, already_authorized;
|
2015-09-17 12:30:42 +02:00
|
|
|
int new_bss = 0;
|
2019-09-27 07:58:34 +02:00
|
|
|
#if defined(CONFIG_FILS) || defined(CONFIG_MBO)
|
|
|
|
struct wpa_bss *bss;
|
|
|
|
#endif /* CONFIG_FILS || CONFIG_MBO */
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2010-01-03 17:22:22 +01:00
|
|
|
#ifdef CONFIG_AP
|
|
|
|
if (wpa_s->ap_iface) {
|
2014-06-07 18:15:50 +02:00
|
|
|
if (!data)
|
|
|
|
return;
|
2010-01-03 17:22:22 +01:00
|
|
|
hostapd_notif_assoc(wpa_s->ap_iface->bss[0],
|
|
|
|
data->assoc_info.addr,
|
|
|
|
data->assoc_info.req_ies,
|
2010-10-25 12:50:34 +02:00
|
|
|
data->assoc_info.req_ies_len,
|
|
|
|
data->assoc_info.reassoc);
|
2010-01-03 17:22:22 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_AP */
|
|
|
|
|
2015-03-16 06:20:02 +01:00
|
|
|
eloop_cancel_timeout(wpas_network_reenabled, wpa_s, NULL);
|
2020-01-10 23:19:09 +01:00
|
|
|
wpa_s->own_reconnect_req = 0;
|
2015-03-16 06:20:02 +01:00
|
|
|
|
2010-01-03 17:22:22 +01:00
|
|
|
ft_completed = wpa_ft_is_completed(wpa_s->wpa);
|
2010-04-09 15:59:27 +02:00
|
|
|
if (data && wpa_supplicant_event_associnfo(wpa_s, data) < 0)
|
|
|
|
return;
|
2015-09-09 16:34:13 +02:00
|
|
|
/*
|
|
|
|
* FILS authentication can share the same mechanism to mark the
|
|
|
|
* connection fully authenticated, so set ft_completed also based on
|
|
|
|
* FILS result.
|
|
|
|
*/
|
|
|
|
if (!ft_completed)
|
|
|
|
ft_completed = wpa_fils_is_completed(wpa_s->wpa);
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2012-08-11 16:46:58 +02:00
|
|
|
if (wpa_drv_get_bssid(wpa_s, bssid) < 0) {
|
|
|
|
wpa_dbg(wpa_s, MSG_ERROR, "Failed to get BSSID");
|
2012-11-05 15:55:30 +01:00
|
|
|
wpa_supplicant_deauthenticate(
|
2012-08-11 16:46:58 +02:00
|
|
|
wpa_s, WLAN_REASON_DEAUTH_LEAVING);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_supplicant_set_state(wpa_s, WPA_ASSOCIATED);
|
2012-08-11 16:46:58 +02:00
|
|
|
if (os_memcmp(bssid, wpa_s->bssid, ETH_ALEN) != 0) {
|
2018-06-21 01:42:45 +02:00
|
|
|
if (os_reltime_initialized(&wpa_s->session_start)) {
|
|
|
|
os_reltime_age(&wpa_s->session_start,
|
|
|
|
&wpa_s->session_length);
|
|
|
|
wpa_s->session_start.sec = 0;
|
|
|
|
wpa_s->session_start.usec = 0;
|
|
|
|
wpas_notify_session_length(wpa_s);
|
|
|
|
} else {
|
|
|
|
wpas_notify_auth_changed(wpa_s);
|
|
|
|
os_get_reltime(&wpa_s->session_start);
|
|
|
|
}
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Associated to a new BSS: BSSID="
|
2008-02-28 02:34:43 +01:00
|
|
|
MACSTR, MAC2STR(bssid));
|
2015-09-17 12:30:42 +02:00
|
|
|
new_bss = 1;
|
Maintain internal entropy pool for augmenting random number generation
By default, make hostapd and wpa_supplicant maintain an internal
entropy pool that is fed with following information:
hostapd:
- Probe Request frames (timing, RSSI)
- Association events (timing)
- SNonce from Supplicants
wpa_supplicant:
- Scan results (timing, signal/noise)
- Association events (timing)
The internal pool is used to augment the random numbers generated
with the OS mechanism (os_get_random()). While the internal
implementation is not expected to be very strong due to limited
amount of generic (non-platform specific) information to feed the
pool, this may strengthen key derivation on some devices that are
not configured to provide strong random numbers through
os_get_random() (e.g., /dev/urandom on Linux/BSD).
This new mechanism is not supposed to replace proper OS provided
random number generation mechanism. The OS mechanism needs to be
initialized properly (e.g., hw random number generator,
maintaining entropy pool over reboots, etc.) for any of the
security assumptions to hold.
If the os_get_random() is known to provide strong ramdom data (e.g., on
Linux/BSD, the board in question is known to have reliable source of
random data from /dev/urandom), the internal hostapd random pool can be
disabled. This will save some in binary size and CPU use. However, this
should only be considered for builds that are known to be used on
devices that meet the requirements described above. The internal pool
is disabled by adding CONFIG_NO_RANDOM_POOL=y to the .config file.
2010-11-24 00:29:40 +01:00
|
|
|
random_add_randomness(bssid, ETH_ALEN);
|
2008-02-28 02:34:43 +01:00
|
|
|
os_memcpy(wpa_s->bssid, bssid, ETH_ALEN);
|
|
|
|
os_memset(wpa_s->pending_bssid, 0, ETH_ALEN);
|
2012-08-11 16:54:43 +02:00
|
|
|
wpas_notify_bssid_changed(wpa_s);
|
2009-09-13 19:53:32 +02:00
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
if (wpa_supplicant_dynamic_keys(wpa_s) && !ft_completed) {
|
|
|
|
wpa_clear_keys(wpa_s, bssid);
|
|
|
|
}
|
|
|
|
if (wpa_supplicant_select_config(wpa_s) < 0) {
|
2012-11-05 15:55:30 +01:00
|
|
|
wpa_supplicant_deauthenticate(
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_s, WLAN_REASON_DEAUTH_LEAVING);
|
|
|
|
return;
|
|
|
|
}
|
2015-09-17 12:30:42 +02:00
|
|
|
}
|
2012-01-23 16:34:39 +01:00
|
|
|
|
2020-03-11 11:41:54 +01:00
|
|
|
multi_ap_set_4addr_mode(wpa_s);
|
|
|
|
|
2015-09-17 12:30:42 +02:00
|
|
|
if (wpa_s->conf->ap_scan == 1 &&
|
|
|
|
wpa_s->drv_flags & WPA_DRIVER_FLAGS_BSS_SELECTION) {
|
|
|
|
if (wpa_supplicant_assoc_update_ie(wpa_s) < 0 && new_bss)
|
|
|
|
wpa_msg(wpa_s, MSG_WARNING,
|
|
|
|
"WPA/RSN IEs not updated");
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
|
|
|
|
2015-11-22 13:46:54 +01:00
|
|
|
wpas_fst_update_mb_assoc(wpa_s, data);
|
|
|
|
|
2009-11-17 18:25:05 +01:00
|
|
|
#ifdef CONFIG_SME
|
|
|
|
os_memcpy(wpa_s->sme.prev_bssid, bssid, ETH_ALEN);
|
|
|
|
wpa_s->sme.prev_bssid_set = 1;
|
2014-06-19 19:56:32 +02:00
|
|
|
wpa_s->sme.last_unprot_disconnect.sec = 0;
|
2009-11-17 18:25:05 +01:00
|
|
|
#endif /* CONFIG_SME */
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_msg(wpa_s, MSG_INFO, "Associated with " MACSTR, MAC2STR(bssid));
|
|
|
|
if (wpa_s->current_ssid) {
|
|
|
|
/* When using scanning (ap_scan=1), SIM PC/SC interface can be
|
|
|
|
* initialized before association, but for other modes,
|
|
|
|
* initialize PC/SC here, if the current configuration needs
|
|
|
|
* smartcard or SIM/USIM. */
|
|
|
|
wpa_supplicant_scard_init(wpa_s, wpa_s->current_ssid);
|
|
|
|
}
|
|
|
|
wpa_sm_notify_assoc(wpa_s->wpa, bssid);
|
2010-07-18 05:26:47 +02:00
|
|
|
if (wpa_s->l2)
|
|
|
|
l2_packet_notify_auth_start(wpa_s->l2);
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2016-08-10 22:51:21 +02:00
|
|
|
already_authorized = data && data->assoc_info.authorized;
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
/*
|
2020-04-23 23:51:11 +02:00
|
|
|
* Set portEnabled first to false in order to get EAP state machine out
|
2008-02-28 02:34:43 +01:00
|
|
|
* of the SUCCESS state and eapSuccess cleared. Without this, EAPOL PAE
|
|
|
|
* state machine may transit to AUTHENTICATING state based on obsolete
|
|
|
|
* eapSuccess and then trigger BE_AUTH to SUCCESS and PAE to
|
|
|
|
* AUTHENTICATED without ever giving chance to EAP state machine to
|
|
|
|
* reset the state.
|
|
|
|
*/
|
2016-08-10 22:51:21 +02:00
|
|
|
if (!ft_completed && !already_authorized) {
|
2020-04-23 23:51:11 +02:00
|
|
|
eapol_sm_notify_portEnabled(wpa_s->eapol, false);
|
|
|
|
eapol_sm_notify_portValid(wpa_s->eapol, false);
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
2017-03-11 23:32:23 +01:00
|
|
|
if (wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
|
2017-06-17 22:48:52 +02:00
|
|
|
wpa_s->key_mgmt == WPA_KEY_MGMT_DPP ||
|
2017-03-11 23:32:23 +01:00
|
|
|
wpa_s->key_mgmt == WPA_KEY_MGMT_OWE || ft_completed ||
|
2019-08-07 10:51:44 +02:00
|
|
|
already_authorized || wpa_s->drv_authorized_port)
|
2020-04-23 23:51:11 +02:00
|
|
|
eapol_sm_notify_eap_success(wpa_s->eapol, false);
|
2008-02-28 02:34:43 +01:00
|
|
|
/* 802.1X::portControl = Auto */
|
2020-04-23 23:51:11 +02:00
|
|
|
eapol_sm_notify_portEnabled(wpa_s->eapol, true);
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_s->eapol_received = 0;
|
|
|
|
if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
|
2009-12-04 21:09:06 +01:00
|
|
|
wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE ||
|
|
|
|
(wpa_s->current_ssid &&
|
2019-06-14 16:49:19 +02:00
|
|
|
wpa_s->current_ssid->mode == WPAS_MODE_IBSS)) {
|
2014-06-07 12:32:13 +02:00
|
|
|
if (wpa_s->current_ssid &&
|
|
|
|
wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE &&
|
2013-05-07 17:14:56 +02:00
|
|
|
(wpa_s->drv_flags &
|
|
|
|
WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE)) {
|
|
|
|
/*
|
|
|
|
* Set the key after having received joined-IBSS event
|
|
|
|
* from the driver.
|
|
|
|
*/
|
|
|
|
wpa_supplicant_set_wpa_none_key(wpa_s,
|
|
|
|
wpa_s->current_ssid);
|
|
|
|
}
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_supplicant_cancel_auth_timeout(wpa_s);
|
|
|
|
wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
|
|
|
|
} else if (!ft_completed) {
|
|
|
|
/* Timeout for receiving the first EAPOL packet */
|
|
|
|
wpa_supplicant_req_auth_timeout(wpa_s, 10, 0);
|
|
|
|
}
|
|
|
|
wpa_supplicant_cancel_scan(wpa_s);
|
|
|
|
|
2019-04-03 12:36:30 +02:00
|
|
|
if (ft_completed) {
|
|
|
|
/*
|
|
|
|
* FT protocol completed - make sure EAPOL state machine ends
|
|
|
|
* up in authenticated.
|
|
|
|
*/
|
|
|
|
wpa_supplicant_cancel_auth_timeout(wpa_s);
|
|
|
|
wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
|
2020-04-23 23:51:11 +02:00
|
|
|
eapol_sm_notify_portValid(wpa_s->eapol, true);
|
|
|
|
eapol_sm_notify_eap_success(wpa_s->eapol, true);
|
2019-04-03 12:36:30 +02:00
|
|
|
} else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_PSK) &&
|
|
|
|
wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt)) {
|
2008-02-28 02:34:43 +01:00
|
|
|
/*
|
|
|
|
* We are done; the driver will take care of RSN 4-way
|
|
|
|
* handshake.
|
|
|
|
*/
|
|
|
|
wpa_supplicant_cancel_auth_timeout(wpa_s);
|
|
|
|
wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
|
2020-04-23 23:51:11 +02:00
|
|
|
eapol_sm_notify_portValid(wpa_s->eapol, true);
|
|
|
|
eapol_sm_notify_eap_success(wpa_s->eapol, true);
|
2019-01-07 12:14:40 +01:00
|
|
|
} else if ((wpa_s->drv_flags & WPA_DRIVER_FLAGS_4WAY_HANDSHAKE_8021X) &&
|
2011-01-31 23:04:02 +01:00
|
|
|
wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt)) {
|
|
|
|
/*
|
|
|
|
* The driver will take care of RSN 4-way handshake, so we need
|
|
|
|
* to allow EAPOL supplicant to complete its work without
|
|
|
|
* waiting for WPA supplicant.
|
|
|
|
*/
|
2020-04-23 23:51:11 +02:00
|
|
|
eapol_sm_notify_portValid(wpa_s->eapol, true);
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
2009-09-04 17:04:41 +02:00
|
|
|
|
2012-12-21 20:35:35 +01:00
|
|
|
wpa_s->last_eapol_matches_bssid = 0;
|
|
|
|
|
2019-12-13 02:05:38 +01:00
|
|
|
#ifdef CONFIG_TESTING_OPTIONS
|
2020-03-15 10:11:38 +01:00
|
|
|
if (wpa_s->rsne_override_eapol) {
|
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
"TESTING: RSNE EAPOL-Key msg 2/4 override");
|
|
|
|
wpa_sm_set_assoc_wpa_ie(wpa_s->wpa,
|
|
|
|
wpabuf_head(wpa_s->rsne_override_eapol),
|
|
|
|
wpabuf_len(wpa_s->rsne_override_eapol));
|
|
|
|
}
|
2019-12-13 02:05:38 +01:00
|
|
|
if (wpa_s->rsnxe_override_eapol) {
|
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
"TESTING: RSNXE EAPOL-Key msg 2/4 override");
|
|
|
|
wpa_sm_set_assoc_rsnxe(wpa_s->wpa,
|
|
|
|
wpabuf_head(wpa_s->rsnxe_override_eapol),
|
|
|
|
wpabuf_len(wpa_s->rsnxe_override_eapol));
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_TESTING_OPTIONS */
|
|
|
|
|
2009-09-04 17:04:41 +02:00
|
|
|
if (wpa_s->pending_eapol_rx) {
|
2013-12-16 21:08:33 +01:00
|
|
|
struct os_reltime now, age;
|
|
|
|
os_get_reltime(&now);
|
|
|
|
os_reltime_sub(&now, &wpa_s->pending_eapol_rx_time, &age);
|
2017-01-23 13:34:46 +01:00
|
|
|
if (age.sec == 0 && age.usec < 200000 &&
|
2009-09-04 17:04:41 +02:00
|
|
|
os_memcmp(wpa_s->pending_eapol_rx_src, bssid, ETH_ALEN) ==
|
|
|
|
0) {
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Process pending EAPOL "
|
|
|
|
"frame that was received just before "
|
|
|
|
"association notification");
|
2009-09-04 17:04:41 +02:00
|
|
|
wpa_supplicant_rx_eapol(
|
|
|
|
wpa_s, wpa_s->pending_eapol_rx_src,
|
|
|
|
wpabuf_head(wpa_s->pending_eapol_rx),
|
|
|
|
wpabuf_len(wpa_s->pending_eapol_rx));
|
|
|
|
}
|
|
|
|
wpabuf_free(wpa_s->pending_eapol_rx);
|
|
|
|
wpa_s->pending_eapol_rx = NULL;
|
|
|
|
}
|
2009-09-14 23:08:24 +02:00
|
|
|
|
2020-02-29 15:52:39 +01:00
|
|
|
#ifdef CONFIG_WEP
|
2009-09-15 09:48:30 +02:00
|
|
|
if ((wpa_s->key_mgmt == WPA_KEY_MGMT_NONE ||
|
|
|
|
wpa_s->key_mgmt == WPA_KEY_MGMT_IEEE8021X_NO_WPA) &&
|
2013-05-07 16:36:40 +02:00
|
|
|
wpa_s->current_ssid &&
|
|
|
|
(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE)) {
|
2009-09-15 09:48:30 +02:00
|
|
|
/* Set static WEP keys again */
|
|
|
|
wpa_set_wep_keys(wpa_s, wpa_s->current_ssid);
|
|
|
|
}
|
2020-02-29 15:52:39 +01:00
|
|
|
#endif /* CONFIG_WEP */
|
2011-01-15 13:07:02 +01:00
|
|
|
|
|
|
|
#ifdef CONFIG_IBSS_RSN
|
|
|
|
if (wpa_s->current_ssid &&
|
|
|
|
wpa_s->current_ssid->mode == WPAS_MODE_IBSS &&
|
|
|
|
wpa_s->key_mgmt != WPA_KEY_MGMT_NONE &&
|
2011-03-23 20:15:46 +01:00
|
|
|
wpa_s->key_mgmt != WPA_KEY_MGMT_WPA_NONE &&
|
|
|
|
wpa_s->ibss_rsn == NULL) {
|
2016-08-13 15:22:53 +02:00
|
|
|
wpa_s->ibss_rsn = ibss_rsn_init(wpa_s, wpa_s->current_ssid);
|
2011-03-23 20:15:46 +01:00
|
|
|
if (!wpa_s->ibss_rsn) {
|
|
|
|
wpa_msg(wpa_s, MSG_INFO, "Failed to init IBSS RSN");
|
|
|
|
wpa_supplicant_deauthenticate(
|
|
|
|
wpa_s, WLAN_REASON_DEAUTH_LEAVING);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ibss_rsn_set_psk(wpa_s->ibss_rsn, wpa_s->current_ssid->psk);
|
|
|
|
}
|
2011-01-15 13:07:02 +01:00
|
|
|
#endif /* CONFIG_IBSS_RSN */
|
2012-08-27 12:48:11 +02:00
|
|
|
|
|
|
|
wpas_wps_notify_assoc(wpa_s, bssid);
|
2014-10-22 14:03:54 +02:00
|
|
|
|
|
|
|
if (data) {
|
|
|
|
wmm_ac_notify_assoc(wpa_s, data->assoc_info.resp_ies,
|
|
|
|
data->assoc_info.resp_ies_len,
|
|
|
|
&data->assoc_info.wmm_params);
|
2014-12-29 03:15:01 +01:00
|
|
|
|
|
|
|
if (wpa_s->reassoc_same_bss)
|
|
|
|
wmm_ac_restore_tspecs(wpa_s);
|
2014-10-22 14:03:54 +02:00
|
|
|
}
|
2017-03-22 11:40:05 +01:00
|
|
|
|
2019-09-27 07:58:34 +02:00
|
|
|
#if defined(CONFIG_FILS) || defined(CONFIG_MBO)
|
|
|
|
bss = wpa_bss_get_bssid(wpa_s, bssid);
|
|
|
|
#endif /* CONFIG_FILS || CONFIG_MBO */
|
2017-03-22 11:40:05 +01:00
|
|
|
#ifdef CONFIG_FILS
|
|
|
|
if (wpa_key_mgmt_fils(wpa_s->key_mgmt)) {
|
|
|
|
const u8 *fils_cache_id = wpa_bss_get_fils_cache_id(bss);
|
|
|
|
|
|
|
|
if (fils_cache_id)
|
|
|
|
wpa_sm_set_fils_cache_id(wpa_s->wpa, fils_cache_id);
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_FILS */
|
2019-09-27 07:58:34 +02:00
|
|
|
|
|
|
|
#ifdef CONFIG_MBO
|
|
|
|
wpas_mbo_check_pmf(wpa_s, bss, wpa_s->current_ssid);
|
|
|
|
#endif /* CONFIG_MBO */
|
2020-03-28 14:06:15 +01:00
|
|
|
|
|
|
|
#ifdef CONFIG_DPP2
|
|
|
|
wpa_s->dpp_pfs_fallback = 0;
|
|
|
|
#endif /* CONFIG_DPP2 */
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-12-04 20:57:14 +01:00
|
|
|
static int disconnect_reason_recoverable(u16 reason_code)
|
|
|
|
{
|
|
|
|
return reason_code == WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY ||
|
|
|
|
reason_code == WLAN_REASON_CLASS2_FRAME_FROM_NONAUTH_STA ||
|
|
|
|
reason_code == WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-04-11 20:25:15 +02:00
|
|
|
static void wpa_supplicant_event_disassoc(struct wpa_supplicant *wpa_s,
|
2012-01-01 17:53:12 +01:00
|
|
|
u16 reason_code,
|
|
|
|
int locally_generated)
|
2008-02-28 02:34:43 +01:00
|
|
|
{
|
|
|
|
const u8 *bssid;
|
2012-08-31 21:04:41 +02:00
|
|
|
|
|
|
|
if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
|
|
|
|
/*
|
|
|
|
* At least Host AP driver and a Prism3 card seemed to be
|
|
|
|
* generating streams of disconnected events when configuring
|
|
|
|
* IBSS for WPA-None. Ignore them for now.
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
bssid = wpa_s->bssid;
|
|
|
|
if (is_zero_ether_addr(bssid))
|
|
|
|
bssid = wpa_s->pending_bssid;
|
|
|
|
|
|
|
|
if (!is_zero_ether_addr(bssid) ||
|
|
|
|
wpa_s->wpa_state >= WPA_AUTHENTICATING) {
|
|
|
|
wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_DISCONNECTED "bssid=" MACSTR
|
|
|
|
" reason=%d%s",
|
|
|
|
MAC2STR(bssid), reason_code,
|
|
|
|
locally_generated ? " locally_generated=1" : "");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-10-08 16:49:54 +02:00
|
|
|
static int could_be_psk_mismatch(struct wpa_supplicant *wpa_s, u16 reason_code,
|
|
|
|
int locally_generated)
|
|
|
|
{
|
|
|
|
if (wpa_s->wpa_state != WPA_4WAY_HANDSHAKE ||
|
2019-12-20 20:21:26 +01:00
|
|
|
!wpa_s->new_connection ||
|
2019-10-27 11:54:40 +01:00
|
|
|
!wpa_key_mgmt_wpa_psk(wpa_s->key_mgmt) ||
|
|
|
|
wpa_key_mgmt_sae(wpa_s->key_mgmt))
|
2019-12-20 20:21:26 +01:00
|
|
|
return 0; /* Not in initial 4-way handshake with PSK */
|
2012-10-08 16:49:54 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* It looks like connection was lost while trying to go through PSK
|
|
|
|
* 4-way handshake. Filter out known disconnection cases that are caused
|
|
|
|
* by something else than PSK mismatch to avoid confusing reports.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (locally_generated) {
|
|
|
|
if (reason_code == WLAN_REASON_IE_IN_4WAY_DIFFERS)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-08-31 21:04:41 +02:00
|
|
|
static void wpa_supplicant_event_disassoc_finish(struct wpa_supplicant *wpa_s,
|
|
|
|
u16 reason_code,
|
|
|
|
int locally_generated)
|
|
|
|
{
|
|
|
|
const u8 *bssid;
|
2009-10-12 08:39:55 +02:00
|
|
|
int authenticating;
|
|
|
|
u8 prev_pending_bssid[ETH_ALEN];
|
2011-12-04 20:57:14 +01:00
|
|
|
struct wpa_bss *fast_reconnect = NULL;
|
|
|
|
struct wpa_ssid *fast_reconnect_ssid = NULL;
|
2012-09-01 16:20:27 +02:00
|
|
|
struct wpa_ssid *last_ssid;
|
2016-09-05 16:33:07 +02:00
|
|
|
struct wpa_bss *curr = NULL;
|
2009-10-12 08:39:55 +02:00
|
|
|
|
|
|
|
authenticating = wpa_s->wpa_state == WPA_AUTHENTICATING;
|
|
|
|
os_memcpy(prev_pending_bssid, wpa_s->pending_bssid, ETH_ALEN);
|
2008-02-28 02:34:43 +01:00
|
|
|
|
|
|
|
if (wpa_s->key_mgmt == WPA_KEY_MGMT_WPA_NONE) {
|
|
|
|
/*
|
|
|
|
* At least Host AP driver and a Prism3 card seemed to be
|
|
|
|
* generating streams of disconnected events when configuring
|
|
|
|
* IBSS for WPA-None. Ignore them for now.
|
|
|
|
*/
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Disconnect event - ignore in "
|
|
|
|
"IBSS/WPA-None mode");
|
2008-02-28 02:34:43 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-09-05 16:33:07 +02:00
|
|
|
if (!wpa_s->disconnected && wpa_s->wpa_state >= WPA_AUTHENTICATING &&
|
|
|
|
reason_code == WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY &&
|
|
|
|
locally_generated)
|
|
|
|
/*
|
|
|
|
* Remove the inactive AP (which is probably out of range) from
|
|
|
|
* the BSS list after marking disassociation. In particular
|
|
|
|
* mac80211-based drivers use the
|
|
|
|
* WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY reason code in
|
|
|
|
* locally generated disconnection events for cases where the
|
|
|
|
* AP does not reply anymore.
|
|
|
|
*/
|
|
|
|
curr = wpa_s->current_bss;
|
|
|
|
|
2012-10-08 16:49:54 +02:00
|
|
|
if (could_be_psk_mismatch(wpa_s, reason_code, locally_generated)) {
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_msg(wpa_s, MSG_INFO, "WPA: 4-Way Handshake failed - "
|
|
|
|
"pre-shared key may be incorrect");
|
2013-09-01 20:28:16 +02:00
|
|
|
if (wpas_p2p_4way_hs_failed(wpa_s) > 0)
|
|
|
|
return; /* P2P group removed */
|
2014-05-16 00:55:21 +02:00
|
|
|
wpas_auth_failed(wpa_s, "WRONG_KEY");
|
2019-09-15 15:19:45 +02:00
|
|
|
#ifdef CONFIG_DPP2
|
|
|
|
wpas_dpp_send_conn_status_result(wpa_s,
|
|
|
|
DPP_STATUS_AUTH_FAILURE);
|
|
|
|
#endif /* CONFIG_DPP2 */
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
2013-05-12 18:15:33 +02:00
|
|
|
if (!wpa_s->disconnected &&
|
|
|
|
(!wpa_s->auto_reconnect_disabled ||
|
2014-09-27 21:41:28 +02:00
|
|
|
wpa_s->key_mgmt == WPA_KEY_MGMT_WPS ||
|
2015-11-16 16:02:56 +01:00
|
|
|
wpas_wps_searching(wpa_s) ||
|
|
|
|
wpas_wps_reenable_networks_pending(wpa_s))) {
|
2011-12-04 20:57:14 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Auto connect enabled: try to "
|
2014-09-27 21:41:28 +02:00
|
|
|
"reconnect (wps=%d/%d wpa_state=%d)",
|
2011-12-01 17:22:10 +01:00
|
|
|
wpa_s->key_mgmt == WPA_KEY_MGMT_WPS,
|
2014-09-27 21:41:28 +02:00
|
|
|
wpas_wps_searching(wpa_s),
|
2011-12-01 17:22:10 +01:00
|
|
|
wpa_s->wpa_state);
|
2011-12-04 20:57:14 +01:00
|
|
|
if (wpa_s->wpa_state == WPA_COMPLETED &&
|
|
|
|
wpa_s->current_ssid &&
|
|
|
|
wpa_s->current_ssid->mode == WPAS_MODE_INFRA &&
|
2020-01-10 23:19:09 +01:00
|
|
|
(wpa_s->own_reconnect_req ||
|
|
|
|
(!locally_generated &&
|
|
|
|
disconnect_reason_recoverable(reason_code)))) {
|
2011-12-04 20:57:14 +01:00
|
|
|
/*
|
|
|
|
* It looks like the AP has dropped association with
|
2020-01-10 23:19:09 +01:00
|
|
|
* us, but could allow us to get back in. This is also
|
|
|
|
* triggered for cases where local reconnection request
|
|
|
|
* is used to force reassociation with the same BSS.
|
|
|
|
* Try to reconnect to the same BSS without a full scan
|
|
|
|
* to save time for some common cases.
|
2011-12-04 20:57:14 +01:00
|
|
|
*/
|
|
|
|
fast_reconnect = wpa_s->current_bss;
|
|
|
|
fast_reconnect_ssid = wpa_s->current_ssid;
|
2020-01-10 23:19:09 +01:00
|
|
|
} else if (wpa_s->wpa_state >= WPA_ASSOCIATING) {
|
2010-09-06 16:28:45 +02:00
|
|
|
wpa_supplicant_req_scan(wpa_s, 0, 100000);
|
2020-01-10 23:19:09 +01:00
|
|
|
} else {
|
2011-12-01 17:22:10 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Do not request new "
|
|
|
|
"immediate scan");
|
2020-01-10 23:19:09 +01:00
|
|
|
}
|
2010-09-06 16:28:45 +02:00
|
|
|
} else {
|
2011-12-04 20:57:14 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Auto connect disabled: do not "
|
2011-02-10 19:14:46 +01:00
|
|
|
"try to re-connect");
|
2010-09-06 16:28:45 +02:00
|
|
|
wpa_s->reassociate = 0;
|
|
|
|
wpa_s->disconnected = 1;
|
2015-06-30 09:11:27 +02:00
|
|
|
if (!wpa_s->pno)
|
|
|
|
wpa_supplicant_cancel_sched_scan(wpa_s);
|
2010-09-06 16:28:45 +02:00
|
|
|
}
|
2008-02-28 02:34:43 +01:00
|
|
|
bssid = wpa_s->bssid;
|
2008-06-03 17:08:48 +02:00
|
|
|
if (is_zero_ether_addr(bssid))
|
2008-02-28 02:34:43 +01:00
|
|
|
bssid = wpa_s->pending_bssid;
|
2011-12-01 17:22:56 +01:00
|
|
|
if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
|
|
|
|
wpas_connection_failed(wpa_s, bssid);
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_sm_notify_disassoc(wpa_s->wpa);
|
2020-12-16 12:00:27 +01:00
|
|
|
ptksa_cache_flush(wpa_s->ptksa, wpa_s->bssid, WPA_CIPHER_NONE);
|
|
|
|
|
2012-06-30 15:43:50 +02:00
|
|
|
if (locally_generated)
|
|
|
|
wpa_s->disconnect_reason = -reason_code;
|
|
|
|
else
|
|
|
|
wpa_s->disconnect_reason = reason_code;
|
|
|
|
wpas_notify_disconnect_reason(wpa_s);
|
2008-02-28 02:34:43 +01:00
|
|
|
if (wpa_supplicant_dynamic_keys(wpa_s)) {
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Disconnect event - remove keys");
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_clear_keys(wpa_s, wpa_s->bssid);
|
|
|
|
}
|
2012-09-01 16:20:27 +02:00
|
|
|
last_ssid = wpa_s->current_ssid;
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_supplicant_mark_disassoc(wpa_s);
|
2011-02-24 15:59:46 +01:00
|
|
|
|
2016-09-05 16:33:07 +02:00
|
|
|
if (curr)
|
|
|
|
wpa_bss_remove(wpa_s, curr, "Connection to AP lost");
|
|
|
|
|
2012-09-01 16:20:27 +02:00
|
|
|
if (authenticating && (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)) {
|
2011-02-24 15:59:46 +01:00
|
|
|
sme_disassoc_while_authenticating(wpa_s, prev_pending_bssid);
|
2012-09-01 16:20:27 +02:00
|
|
|
wpa_s->current_ssid = last_ssid;
|
|
|
|
}
|
2011-12-04 20:57:14 +01:00
|
|
|
|
2014-02-18 11:07:06 +01:00
|
|
|
if (fast_reconnect &&
|
|
|
|
!wpas_network_disabled(wpa_s, fast_reconnect_ssid) &&
|
|
|
|
!disallowed_bssid(wpa_s, fast_reconnect->bssid) &&
|
|
|
|
!disallowed_ssid(wpa_s, fast_reconnect->ssid,
|
|
|
|
fast_reconnect->ssid_len) &&
|
2016-02-15 15:53:36 +01:00
|
|
|
!wpas_temp_disabled(wpa_s, fast_reconnect_ssid) &&
|
2017-08-21 18:43:52 +02:00
|
|
|
!wpa_is_bss_tmp_disallowed(wpa_s, fast_reconnect)) {
|
2011-12-11 17:14:09 +01:00
|
|
|
#ifndef CONFIG_NO_SCAN_PROCESSING
|
2011-12-04 20:57:14 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Try to reconnect to the same BSS");
|
|
|
|
if (wpa_supplicant_connect(wpa_s, fast_reconnect,
|
|
|
|
fast_reconnect_ssid) < 0) {
|
|
|
|
/* Recover through full scan */
|
|
|
|
wpa_supplicant_req_scan(wpa_s, 0, 100000);
|
|
|
|
}
|
2011-12-11 17:14:09 +01:00
|
|
|
#endif /* CONFIG_NO_SCAN_PROCESSING */
|
2014-02-18 11:07:06 +01:00
|
|
|
} else if (fast_reconnect) {
|
|
|
|
/*
|
|
|
|
* Could not reconnect to the same BSS due to network being
|
|
|
|
* disabled. Use a new scan to match the alternative behavior
|
|
|
|
* above, i.e., to continue automatic reconnection attempt in a
|
|
|
|
* way that enforces disabled network rules.
|
|
|
|
*/
|
|
|
|
wpa_supplicant_req_scan(wpa_s, 0, 100000);
|
2011-12-04 20:57:14 +01:00
|
|
|
}
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-11-08 03:43:12 +01:00
|
|
|
#ifdef CONFIG_DELAYED_MIC_ERROR_REPORT
|
2011-10-30 11:43:30 +01:00
|
|
|
void wpa_supplicant_delayed_mic_error_report(void *eloop_ctx, void *sock_ctx)
|
2008-11-08 03:43:12 +01:00
|
|
|
{
|
|
|
|
struct wpa_supplicant *wpa_s = eloop_ctx;
|
|
|
|
|
|
|
|
if (!wpa_s->pending_mic_error_report)
|
|
|
|
return;
|
|
|
|
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Sending pending MIC error report");
|
2008-11-08 03:43:12 +01:00
|
|
|
wpa_sm_key_request(wpa_s->wpa, 1, wpa_s->pending_mic_error_pairwise);
|
|
|
|
wpa_s->pending_mic_error_report = 0;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */
|
|
|
|
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
static void
|
|
|
|
wpa_supplicant_event_michael_mic_failure(struct wpa_supplicant *wpa_s,
|
|
|
|
union wpa_event_data *data)
|
|
|
|
{
|
|
|
|
int pairwise;
|
2013-12-16 21:08:42 +01:00
|
|
|
struct os_reltime t;
|
2008-02-28 02:34:43 +01:00
|
|
|
|
|
|
|
wpa_msg(wpa_s, MSG_WARNING, "Michael MIC failure detected");
|
|
|
|
pairwise = (data && data->michael_mic_failure.unicast);
|
2013-12-16 21:08:42 +01:00
|
|
|
os_get_reltime(&t);
|
|
|
|
if ((wpa_s->last_michael_mic_error.sec &&
|
|
|
|
!os_reltime_expired(&t, &wpa_s->last_michael_mic_error, 60)) ||
|
2008-11-08 03:43:12 +01:00
|
|
|
wpa_s->pending_mic_error_report) {
|
|
|
|
if (wpa_s->pending_mic_error_report) {
|
|
|
|
/*
|
|
|
|
* Send the pending MIC error report immediately since
|
|
|
|
* we are going to start countermeasures and AP better
|
|
|
|
* do the same.
|
|
|
|
*/
|
|
|
|
wpa_sm_key_request(wpa_s->wpa, 1,
|
|
|
|
wpa_s->pending_mic_error_pairwise);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send the new MIC error report immediately since we are going
|
|
|
|
* to start countermeasures and AP better do the same.
|
|
|
|
*/
|
|
|
|
wpa_sm_key_request(wpa_s->wpa, 1, pairwise);
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
/* initialize countermeasures */
|
|
|
|
wpa_s->countermeasures = 1;
|
2011-12-25 20:09:17 +01:00
|
|
|
|
2021-02-07 16:02:37 +01:00
|
|
|
wpa_bssid_ignore_add(wpa_s, wpa_s->bssid);
|
2011-12-25 20:09:17 +01:00
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_msg(wpa_s, MSG_WARNING, "TKIP countermeasures started");
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Need to wait for completion of request frame. We do not get
|
|
|
|
* any callback for the message completion, so just wait a
|
|
|
|
* short while and hope for the best. */
|
|
|
|
os_sleep(0, 10000);
|
|
|
|
|
|
|
|
wpa_drv_set_countermeasures(wpa_s, 1);
|
|
|
|
wpa_supplicant_deauthenticate(wpa_s,
|
|
|
|
WLAN_REASON_MICHAEL_MIC_FAILURE);
|
|
|
|
eloop_cancel_timeout(wpa_supplicant_stop_countermeasures,
|
|
|
|
wpa_s, NULL);
|
|
|
|
eloop_register_timeout(60, 0,
|
|
|
|
wpa_supplicant_stop_countermeasures,
|
|
|
|
wpa_s, NULL);
|
|
|
|
/* TODO: mark the AP rejected for 60 second. STA is
|
|
|
|
* allowed to associate with another AP.. */
|
2008-11-08 03:43:12 +01:00
|
|
|
} else {
|
|
|
|
#ifdef CONFIG_DELAYED_MIC_ERROR_REPORT
|
|
|
|
if (wpa_s->mic_errors_seen) {
|
|
|
|
/*
|
|
|
|
* Reduce the effectiveness of Michael MIC error
|
|
|
|
* reports as a means for attacking against TKIP if
|
|
|
|
* more than one MIC failure is noticed with the same
|
|
|
|
* PTK. We delay the transmission of the reports by a
|
|
|
|
* random time between 0 and 60 seconds in order to
|
|
|
|
* force the attacker wait 60 seconds before getting
|
|
|
|
* the information on whether a frame resulted in a MIC
|
|
|
|
* failure.
|
|
|
|
*/
|
|
|
|
u8 rval[4];
|
|
|
|
int sec;
|
|
|
|
|
|
|
|
if (os_get_random(rval, sizeof(rval)) < 0)
|
|
|
|
sec = os_random() % 60;
|
|
|
|
else
|
|
|
|
sec = WPA_GET_BE32(rval) % 60;
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "WPA: Delay MIC error "
|
|
|
|
"report %d seconds", sec);
|
2008-11-08 03:43:12 +01:00
|
|
|
wpa_s->pending_mic_error_report = 1;
|
|
|
|
wpa_s->pending_mic_error_pairwise = pairwise;
|
|
|
|
eloop_cancel_timeout(
|
|
|
|
wpa_supplicant_delayed_mic_error_report,
|
|
|
|
wpa_s, NULL);
|
|
|
|
eloop_register_timeout(
|
|
|
|
sec, os_random() % 1000000,
|
|
|
|
wpa_supplicant_delayed_mic_error_report,
|
|
|
|
wpa_s, NULL);
|
|
|
|
} else {
|
|
|
|
wpa_sm_key_request(wpa_s->wpa, 1, pairwise);
|
|
|
|
}
|
|
|
|
#else /* CONFIG_DELAYED_MIC_ERROR_REPORT */
|
|
|
|
wpa_sm_key_request(wpa_s->wpa, 1, pairwise);
|
|
|
|
#endif /* CONFIG_DELAYED_MIC_ERROR_REPORT */
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
2013-12-16 21:08:42 +01:00
|
|
|
wpa_s->last_michael_mic_error = t;
|
2008-11-08 03:43:12 +01:00
|
|
|
wpa_s->mic_errors_seen++;
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-03-02 20:57:00 +01:00
|
|
|
#ifdef CONFIG_TERMINATE_ONLASTIF
|
|
|
|
static int any_interfaces(struct wpa_supplicant *head)
|
|
|
|
{
|
|
|
|
struct wpa_supplicant *wpa_s;
|
|
|
|
|
|
|
|
for (wpa_s = head; wpa_s != NULL; wpa_s = wpa_s->next)
|
|
|
|
if (!wpa_s->interface_removed)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_TERMINATE_ONLASTIF */
|
|
|
|
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
static void
|
|
|
|
wpa_supplicant_event_interface_status(struct wpa_supplicant *wpa_s,
|
|
|
|
union wpa_event_data *data)
|
|
|
|
{
|
|
|
|
if (os_strcmp(wpa_s->ifname, data->interface_status.ifname) != 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch (data->interface_status.ievent) {
|
|
|
|
case EVENT_INTERFACE_ADDED:
|
|
|
|
if (!wpa_s->interface_removed)
|
|
|
|
break;
|
|
|
|
wpa_s->interface_removed = 0;
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Configured interface was added");
|
2008-02-28 02:34:43 +01:00
|
|
|
if (wpa_supplicant_driver_init(wpa_s) < 0) {
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_msg(wpa_s, MSG_INFO, "Failed to initialize the "
|
|
|
|
"driver after interface was added");
|
2008-02-28 02:34:43 +01:00
|
|
|
}
|
2015-06-17 15:18:20 +02:00
|
|
|
|
|
|
|
#ifdef CONFIG_P2P
|
|
|
|
if (!wpa_s->global->p2p &&
|
|
|
|
!wpa_s->global->p2p_disabled &&
|
|
|
|
!wpa_s->conf->p2p_disabled &&
|
|
|
|
(wpa_s->drv_flags &
|
|
|
|
WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE) &&
|
|
|
|
wpas_p2p_add_p2pdev_interface(
|
|
|
|
wpa_s, wpa_s->global->params.conf_p2p_dev) < 0) {
|
|
|
|
wpa_printf(MSG_INFO,
|
|
|
|
"P2P: Failed to enable P2P Device interface");
|
|
|
|
/* Try to continue without. P2P will be disabled. */
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_P2P */
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
case EVENT_INTERFACE_REMOVED:
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Configured interface was removed");
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_s->interface_removed = 1;
|
|
|
|
wpa_supplicant_mark_disassoc(wpa_s);
|
2012-02-18 12:16:17 +01:00
|
|
|
wpa_supplicant_set_state(wpa_s, WPA_INTERFACE_DISABLED);
|
2008-02-28 02:34:43 +01:00
|
|
|
l2_packet_deinit(wpa_s->l2);
|
|
|
|
wpa_s->l2 = NULL;
|
2015-06-17 15:18:20 +02:00
|
|
|
|
|
|
|
#ifdef CONFIG_P2P
|
|
|
|
if (wpa_s->global->p2p &&
|
|
|
|
wpa_s->global->p2p_init_wpa_s->parent == wpa_s &&
|
|
|
|
(wpa_s->drv_flags &
|
|
|
|
WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE)) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"Removing P2P Device interface");
|
|
|
|
wpa_supplicant_remove_iface(
|
|
|
|
wpa_s->global, wpa_s->global->p2p_init_wpa_s,
|
|
|
|
0);
|
|
|
|
wpa_s->global->p2p_init_wpa_s = NULL;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_P2P */
|
|
|
|
|
2016-03-15 14:40:14 +01:00
|
|
|
#ifdef CONFIG_MATCH_IFACE
|
|
|
|
if (wpa_s->matched) {
|
|
|
|
wpa_supplicant_remove_iface(wpa_s->global, wpa_s, 0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_MATCH_IFACE */
|
|
|
|
|
2009-03-02 20:57:00 +01:00
|
|
|
#ifdef CONFIG_TERMINATE_ONLASTIF
|
|
|
|
/* check if last interface */
|
|
|
|
if (!any_interfaces(wpa_s->global->ifaces))
|
|
|
|
eloop_terminate();
|
|
|
|
#endif /* CONFIG_TERMINATE_ONLASTIF */
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-10-07 09:26:56 +02:00
|
|
|
#ifdef CONFIG_TDLS
|
|
|
|
static void wpa_supplicant_event_tdls(struct wpa_supplicant *wpa_s,
|
|
|
|
union wpa_event_data *data)
|
|
|
|
{
|
|
|
|
if (data == NULL)
|
|
|
|
return;
|
|
|
|
switch (data->tdls.oper) {
|
|
|
|
case TDLS_REQUEST_SETUP:
|
2013-02-05 12:27:56 +01:00
|
|
|
wpa_tdls_remove(wpa_s->wpa, data->tdls.peer);
|
|
|
|
if (wpa_tdls_is_external_setup(wpa_s->wpa))
|
|
|
|
wpa_tdls_start(wpa_s->wpa, data->tdls.peer);
|
|
|
|
else
|
|
|
|
wpa_drv_tdls_oper(wpa_s, TDLS_SETUP, data->tdls.peer);
|
2010-10-07 09:26:56 +02:00
|
|
|
break;
|
|
|
|
case TDLS_REQUEST_TEARDOWN:
|
2013-09-30 16:10:18 +02:00
|
|
|
if (wpa_tdls_is_external_setup(wpa_s->wpa))
|
|
|
|
wpa_tdls_teardown_link(wpa_s->wpa, data->tdls.peer,
|
|
|
|
data->tdls.reason_code);
|
|
|
|
else
|
|
|
|
wpa_drv_tdls_oper(wpa_s, TDLS_TEARDOWN,
|
|
|
|
data->tdls.peer);
|
2010-10-07 09:26:56 +02:00
|
|
|
break;
|
2015-03-06 15:47:29 +01:00
|
|
|
case TDLS_REQUEST_DISCOVER:
|
|
|
|
wpa_tdls_send_discovery_request(wpa_s->wpa,
|
|
|
|
data->tdls.peer);
|
|
|
|
break;
|
2010-10-07 09:26:56 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_TDLS */
|
|
|
|
|
|
|
|
|
2012-12-16 17:22:54 +01:00
|
|
|
#ifdef CONFIG_WNM
|
2012-02-26 16:27:19 +01:00
|
|
|
static void wpa_supplicant_event_wnm(struct wpa_supplicant *wpa_s,
|
|
|
|
union wpa_event_data *data)
|
|
|
|
{
|
|
|
|
if (data == NULL)
|
|
|
|
return;
|
|
|
|
switch (data->wnm.oper) {
|
|
|
|
case WNM_OPER_SLEEP:
|
|
|
|
wpa_printf(MSG_DEBUG, "Start sending WNM-Sleep Request "
|
|
|
|
"(action=%d, intval=%d)",
|
|
|
|
data->wnm.sleep_action, data->wnm.sleep_intval);
|
|
|
|
ieee802_11_send_wnmsleep_req(wpa_s, data->wnm.sleep_action,
|
2012-12-16 11:31:16 +01:00
|
|
|
data->wnm.sleep_intval, NULL);
|
2012-02-26 16:27:19 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2012-12-16 17:22:54 +01:00
|
|
|
#endif /* CONFIG_WNM */
|
2012-02-26 16:27:19 +01:00
|
|
|
|
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
#ifdef CONFIG_IEEE80211R
|
|
|
|
static void
|
|
|
|
wpa_supplicant_event_ft_response(struct wpa_supplicant *wpa_s,
|
|
|
|
union wpa_event_data *data)
|
|
|
|
{
|
|
|
|
if (data == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (wpa_ft_process_response(wpa_s->wpa, data->ft_ies.ies,
|
|
|
|
data->ft_ies.ies_len,
|
|
|
|
data->ft_ies.ft_action,
|
2009-03-09 19:45:17 +01:00
|
|
|
data->ft_ies.target_ap,
|
|
|
|
data->ft_ies.ric_ies,
|
|
|
|
data->ft_ies.ric_ies_len) < 0) {
|
2008-02-28 02:34:43 +01:00
|
|
|
/* TODO: prevent MLME/driver from trying to associate? */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_IEEE80211R */
|
|
|
|
|
|
|
|
|
2009-01-15 00:21:55 +01:00
|
|
|
#ifdef CONFIG_IBSS_RSN
|
|
|
|
static void wpa_supplicant_event_ibss_rsn_start(struct wpa_supplicant *wpa_s,
|
|
|
|
union wpa_event_data *data)
|
|
|
|
{
|
2010-12-05 03:17:05 +01:00
|
|
|
struct wpa_ssid *ssid;
|
2011-03-16 15:26:26 +01:00
|
|
|
if (wpa_s->wpa_state < WPA_ASSOCIATED)
|
|
|
|
return;
|
2009-01-15 00:21:55 +01:00
|
|
|
if (data == NULL)
|
|
|
|
return;
|
2010-12-05 03:17:05 +01:00
|
|
|
ssid = wpa_s->current_ssid;
|
|
|
|
if (ssid == NULL)
|
|
|
|
return;
|
|
|
|
if (ssid->mode != WPAS_MODE_IBSS || !wpa_key_mgmt_wpa(ssid->key_mgmt))
|
|
|
|
return;
|
|
|
|
|
2009-01-15 00:21:55 +01:00
|
|
|
ibss_rsn_start(wpa_s->ibss_rsn, data->ibss_rsn_start.peer);
|
|
|
|
}
|
2013-07-21 14:56:53 +02:00
|
|
|
|
|
|
|
|
|
|
|
static void wpa_supplicant_event_ibss_auth(struct wpa_supplicant *wpa_s,
|
|
|
|
union wpa_event_data *data)
|
|
|
|
{
|
|
|
|
struct wpa_ssid *ssid = wpa_s->current_ssid;
|
|
|
|
|
|
|
|
if (ssid == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* check if the ssid is correctly configured as IBSS/RSN */
|
|
|
|
if (ssid->mode != WPAS_MODE_IBSS || !wpa_key_mgmt_wpa(ssid->key_mgmt))
|
|
|
|
return;
|
|
|
|
|
|
|
|
ibss_rsn_handle_auth(wpa_s->ibss_rsn, data->rx_mgmt.frame,
|
|
|
|
data->rx_mgmt.frame_len);
|
|
|
|
}
|
2009-01-15 00:21:55 +01:00
|
|
|
#endif /* CONFIG_IBSS_RSN */
|
|
|
|
|
|
|
|
|
2010-03-11 23:43:00 +01:00
|
|
|
#ifdef CONFIG_IEEE80211R
|
|
|
|
static void ft_rx_action(struct wpa_supplicant *wpa_s, const u8 *data,
|
|
|
|
size_t len)
|
|
|
|
{
|
|
|
|
const u8 *sta_addr, *target_ap_addr;
|
|
|
|
u16 status;
|
|
|
|
|
|
|
|
wpa_hexdump(MSG_MSGDUMP, "FT: RX Action", data, len);
|
|
|
|
if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME))
|
|
|
|
return; /* only SME case supported for now */
|
|
|
|
if (len < 1 + 2 * ETH_ALEN + 2)
|
|
|
|
return;
|
|
|
|
if (data[0] != 2)
|
|
|
|
return; /* Only FT Action Response is supported for now */
|
|
|
|
sta_addr = data + 1;
|
|
|
|
target_ap_addr = data + 1 + ETH_ALEN;
|
|
|
|
status = WPA_GET_LE16(data + 1 + 2 * ETH_ALEN);
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "FT: Received FT Action Response: STA "
|
|
|
|
MACSTR " TargetAP " MACSTR " status %u",
|
|
|
|
MAC2STR(sta_addr), MAC2STR(target_ap_addr), status);
|
2010-03-11 23:43:00 +01:00
|
|
|
|
|
|
|
if (os_memcmp(sta_addr, wpa_s->own_addr, ETH_ALEN) != 0) {
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "FT: Foreign STA Address " MACSTR
|
|
|
|
" in FT Action Response", MAC2STR(sta_addr));
|
2010-03-11 23:43:00 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (status) {
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "FT: FT Action Response indicates "
|
|
|
|
"failure (status code %d)", status);
|
2010-03-11 23:43:00 +01:00
|
|
|
/* TODO: report error to FT code(?) */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wpa_ft_process_response(wpa_s->wpa, data + 1 + 2 * ETH_ALEN + 2,
|
|
|
|
len - (1 + 2 * ETH_ALEN + 2), 1,
|
|
|
|
target_ap_addr, NULL, 0) < 0)
|
|
|
|
return;
|
|
|
|
|
2010-03-13 17:26:25 +01:00
|
|
|
#ifdef CONFIG_SME
|
|
|
|
{
|
|
|
|
struct wpa_bss *bss;
|
|
|
|
bss = wpa_bss_get_bssid(wpa_s, target_ap_addr);
|
|
|
|
if (bss)
|
|
|
|
wpa_s->sme.freq = bss->freq;
|
2010-03-13 20:13:18 +01:00
|
|
|
wpa_s->sme.auth_alg = WPA_AUTH_ALG_FT;
|
2010-03-13 17:26:25 +01:00
|
|
|
sme_associate(wpa_s, WPAS_MODE_INFRA, target_ap_addr,
|
|
|
|
WLAN_AUTH_FT);
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SME */
|
2010-03-11 23:43:00 +01:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_IEEE80211R */
|
|
|
|
|
|
|
|
|
2010-12-19 10:58:00 +01:00
|
|
|
static void wpa_supplicant_event_unprot_deauth(struct wpa_supplicant *wpa_s,
|
|
|
|
struct unprot_deauth *e)
|
|
|
|
{
|
|
|
|
wpa_printf(MSG_DEBUG, "Unprotected Deauthentication frame "
|
|
|
|
"dropped: " MACSTR " -> " MACSTR
|
|
|
|
" (reason code %u)",
|
|
|
|
MAC2STR(e->sa), MAC2STR(e->da), e->reason_code);
|
|
|
|
sme_event_unprot_disconnect(wpa_s, e->sa, e->da, e->reason_code);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void wpa_supplicant_event_unprot_disassoc(struct wpa_supplicant *wpa_s,
|
|
|
|
struct unprot_disassoc *e)
|
|
|
|
{
|
|
|
|
wpa_printf(MSG_DEBUG, "Unprotected Disassociation frame "
|
|
|
|
"dropped: " MACSTR " -> " MACSTR
|
|
|
|
" (reason code %u)",
|
|
|
|
MAC2STR(e->sa), MAC2STR(e->da), e->reason_code);
|
|
|
|
sme_event_unprot_disconnect(wpa_s, e->sa, e->da, e->reason_code);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-07-21 15:40:40 +02:00
|
|
|
static void wpas_event_disconnect(struct wpa_supplicant *wpa_s, const u8 *addr,
|
|
|
|
u16 reason_code, int locally_generated,
|
|
|
|
const u8 *ie, size_t ie_len, int deauth)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_AP
|
|
|
|
if (wpa_s->ap_iface && addr) {
|
|
|
|
hostapd_notif_disassoc(wpa_s->ap_iface->bss[0], addr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wpa_s->ap_iface) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Ignore deauth event in AP mode");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_AP */
|
|
|
|
|
2015-03-01 14:54:24 +01:00
|
|
|
if (!locally_generated)
|
|
|
|
wpa_s->own_disconnect_req = 0;
|
|
|
|
|
2013-07-21 15:40:40 +02:00
|
|
|
wpa_supplicant_event_disassoc(wpa_s, reason_code, locally_generated);
|
|
|
|
|
2014-01-08 09:24:05 +01:00
|
|
|
if (((reason_code == WLAN_REASON_IEEE_802_1X_AUTH_FAILED ||
|
|
|
|
((wpa_key_mgmt_wpa_ieee8021x(wpa_s->key_mgmt) ||
|
|
|
|
(wpa_s->key_mgmt & WPA_KEY_MGMT_IEEE8021X_NO_WPA)) &&
|
|
|
|
eapol_sm_failed(wpa_s->eapol))) &&
|
|
|
|
!wpa_s->eap_expected_failure))
|
2014-05-16 00:55:21 +02:00
|
|
|
wpas_auth_failed(wpa_s, "AUTH_FAILED");
|
2013-07-21 15:40:40 +02:00
|
|
|
|
|
|
|
#ifdef CONFIG_P2P
|
2013-08-31 10:11:41 +02:00
|
|
|
if (deauth && reason_code > 0) {
|
2013-07-21 15:40:40 +02:00
|
|
|
if (wpas_p2p_deauth_notif(wpa_s, addr, reason_code, ie, ie_len,
|
|
|
|
locally_generated) > 0) {
|
|
|
|
/*
|
|
|
|
* The interface was removed, so cannot continue
|
|
|
|
* processing any additional operations after this.
|
|
|
|
*/
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_P2P */
|
|
|
|
|
|
|
|
wpa_supplicant_event_disassoc_finish(wpa_s, reason_code,
|
|
|
|
locally_generated);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void wpas_event_disassoc(struct wpa_supplicant *wpa_s,
|
|
|
|
struct disassoc_info *info)
|
|
|
|
{
|
|
|
|
u16 reason_code = 0;
|
|
|
|
int locally_generated = 0;
|
|
|
|
const u8 *addr = NULL;
|
|
|
|
const u8 *ie = NULL;
|
|
|
|
size_t ie_len = 0;
|
|
|
|
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Disassociation notification");
|
|
|
|
|
|
|
|
if (info) {
|
|
|
|
addr = info->addr;
|
|
|
|
ie = info->ie;
|
|
|
|
ie_len = info->ie_len;
|
|
|
|
reason_code = info->reason_code;
|
|
|
|
locally_generated = info->locally_generated;
|
2019-04-15 21:20:05 +02:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, " * reason %u (%s)%s", reason_code,
|
|
|
|
reason2str(reason_code),
|
|
|
|
locally_generated ? " locally_generated=1" : "");
|
2013-07-21 15:40:40 +02:00
|
|
|
if (addr)
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, " * address " MACSTR,
|
|
|
|
MAC2STR(addr));
|
|
|
|
wpa_hexdump(MSG_DEBUG, "Disassociation frame IE(s)",
|
|
|
|
ie, ie_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_AP
|
|
|
|
if (wpa_s->ap_iface && info && info->addr) {
|
|
|
|
hostapd_notif_disassoc(wpa_s->ap_iface->bss[0], info->addr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (wpa_s->ap_iface) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Ignore disassoc event in AP mode");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_AP */
|
|
|
|
|
|
|
|
#ifdef CONFIG_P2P
|
|
|
|
if (info) {
|
|
|
|
wpas_p2p_disassoc_notif(
|
|
|
|
wpa_s, info->addr, reason_code, info->ie, info->ie_len,
|
|
|
|
locally_generated);
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_P2P */
|
|
|
|
|
|
|
|
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)
|
|
|
|
sme_event_disassoc(wpa_s, info);
|
|
|
|
|
|
|
|
wpas_event_disconnect(wpa_s, addr, reason_code, locally_generated,
|
|
|
|
ie, ie_len, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void wpas_event_deauth(struct wpa_supplicant *wpa_s,
|
|
|
|
struct deauth_info *info)
|
|
|
|
{
|
|
|
|
u16 reason_code = 0;
|
|
|
|
int locally_generated = 0;
|
|
|
|
const u8 *addr = NULL;
|
|
|
|
const u8 *ie = NULL;
|
|
|
|
size_t ie_len = 0;
|
|
|
|
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Deauthentication notification");
|
|
|
|
|
|
|
|
if (info) {
|
|
|
|
addr = info->addr;
|
|
|
|
ie = info->ie;
|
|
|
|
ie_len = info->ie_len;
|
|
|
|
reason_code = info->reason_code;
|
|
|
|
locally_generated = info->locally_generated;
|
2019-04-15 21:20:05 +02:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, " * reason %u (%s)%s",
|
|
|
|
reason_code, reason2str(reason_code),
|
|
|
|
locally_generated ? " locally_generated=1" : "");
|
2013-07-21 15:40:40 +02:00
|
|
|
if (addr) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, " * address " MACSTR,
|
|
|
|
MAC2STR(addr));
|
|
|
|
}
|
|
|
|
wpa_hexdump(MSG_DEBUG, "Deauthentication frame IE(s)",
|
|
|
|
ie, ie_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
wpa_reset_ft_completed(wpa_s->wpa);
|
|
|
|
|
|
|
|
wpas_event_disconnect(wpa_s, addr, reason_code,
|
|
|
|
locally_generated, ie, ie_len, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-04-13 15:32:38 +02:00
|
|
|
static const char * reg_init_str(enum reg_change_initiator init)
|
|
|
|
{
|
|
|
|
switch (init) {
|
|
|
|
case REGDOM_SET_BY_CORE:
|
|
|
|
return "CORE";
|
|
|
|
case REGDOM_SET_BY_USER:
|
|
|
|
return "USER";
|
|
|
|
case REGDOM_SET_BY_DRIVER:
|
|
|
|
return "DRIVER";
|
|
|
|
case REGDOM_SET_BY_COUNTRY_IE:
|
|
|
|
return "COUNTRY_IE";
|
|
|
|
case REGDOM_BEACON_HINT:
|
|
|
|
return "BEACON_HINT";
|
|
|
|
}
|
|
|
|
return "?";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static const char * reg_type_str(enum reg_type type)
|
|
|
|
{
|
|
|
|
switch (type) {
|
|
|
|
case REGDOM_TYPE_UNKNOWN:
|
|
|
|
return "UNKNOWN";
|
|
|
|
case REGDOM_TYPE_COUNTRY:
|
|
|
|
return "COUNTRY";
|
|
|
|
case REGDOM_TYPE_WORLD:
|
|
|
|
return "WORLD";
|
|
|
|
case REGDOM_TYPE_CUSTOM_WORLD:
|
|
|
|
return "CUSTOM_WORLD";
|
|
|
|
case REGDOM_TYPE_INTERSECTION:
|
|
|
|
return "INTERSECTION";
|
|
|
|
}
|
|
|
|
return "?";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-01-01 14:58:46 +01:00
|
|
|
void wpa_supplicant_update_channel_list(struct wpa_supplicant *wpa_s,
|
|
|
|
struct channel_list_changed *info)
|
2013-10-29 22:03:23 +01:00
|
|
|
{
|
|
|
|
struct wpa_supplicant *ifs;
|
2017-05-12 09:48:00 +02:00
|
|
|
u8 dfs_domain;
|
2013-10-29 22:03:23 +01:00
|
|
|
|
2016-04-25 10:24:58 +02:00
|
|
|
/*
|
|
|
|
* To allow backwards compatibility with higher level layers that
|
|
|
|
* assumed the REGDOM_CHANGE event is sent over the initially added
|
|
|
|
* interface. Find the highest parent of this interface and use it to
|
|
|
|
* send the event.
|
|
|
|
*/
|
|
|
|
for (ifs = wpa_s; ifs->parent && ifs != ifs->parent; ifs = ifs->parent)
|
|
|
|
;
|
|
|
|
|
2019-01-01 14:58:46 +01:00
|
|
|
if (info) {
|
|
|
|
wpa_msg(ifs, MSG_INFO,
|
|
|
|
WPA_EVENT_REGDOM_CHANGE "init=%s type=%s%s%s",
|
|
|
|
reg_init_str(info->initiator), reg_type_str(info->type),
|
|
|
|
info->alpha2[0] ? " alpha2=" : "",
|
|
|
|
info->alpha2[0] ? info->alpha2 : "");
|
|
|
|
}
|
2014-04-13 15:32:38 +02:00
|
|
|
|
2013-10-29 22:03:23 +01:00
|
|
|
if (wpa_s->drv_priv == NULL)
|
|
|
|
return; /* Ignore event during drv initialization */
|
|
|
|
|
2013-11-24 18:59:28 +01:00
|
|
|
dl_list_for_each(ifs, &wpa_s->radio->ifaces, struct wpa_supplicant,
|
|
|
|
radio_list) {
|
2015-07-27 21:24:24 +02:00
|
|
|
wpa_printf(MSG_DEBUG, "%s: Updating hw mode",
|
|
|
|
ifs->ifname);
|
|
|
|
free_hw_features(ifs);
|
|
|
|
ifs->hw.modes = wpa_drv_get_hw_feature_data(
|
2017-05-12 09:48:00 +02:00
|
|
|
ifs, &ifs->hw.num_modes, &ifs->hw.flags, &dfs_domain);
|
2015-03-19 15:41:39 +01:00
|
|
|
|
2016-09-27 12:09:58 +02:00
|
|
|
/* Restart PNO/sched_scan with updated channel list */
|
|
|
|
if (ifs->pno) {
|
|
|
|
wpas_stop_pno(ifs);
|
|
|
|
wpas_start_pno(ifs);
|
|
|
|
} else if (ifs->sched_scanning && !ifs->pno_sched_pending) {
|
|
|
|
wpa_dbg(ifs, MSG_DEBUG,
|
|
|
|
"Channel list changed - restart sched_scan");
|
|
|
|
wpas_scan_restart_sched_scan(ifs);
|
|
|
|
}
|
2015-03-19 15:41:39 +01:00
|
|
|
}
|
2015-07-27 21:24:24 +02:00
|
|
|
|
2015-07-27 21:24:27 +02:00
|
|
|
wpas_p2p_update_channel_list(wpa_s, WPAS_P2P_CHANNEL_UPDATE_DRIVER);
|
2013-10-29 22:03:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-12-29 10:22:23 +01:00
|
|
|
static void wpas_event_rx_mgmt_action(struct wpa_supplicant *wpa_s,
|
2014-11-05 09:42:56 +01:00
|
|
|
const u8 *frame, size_t len, int freq,
|
|
|
|
int rssi)
|
2013-12-29 10:22:23 +01:00
|
|
|
{
|
2014-06-12 18:42:50 +02:00
|
|
|
const struct ieee80211_mgmt *mgmt;
|
2013-12-29 10:22:23 +01:00
|
|
|
const u8 *payload;
|
|
|
|
size_t plen;
|
|
|
|
u8 category;
|
|
|
|
|
|
|
|
if (len < IEEE80211_HDRLEN + 2)
|
|
|
|
return;
|
|
|
|
|
2014-06-12 18:42:50 +02:00
|
|
|
mgmt = (const struct ieee80211_mgmt *) frame;
|
|
|
|
payload = frame + IEEE80211_HDRLEN;
|
2013-12-29 10:22:23 +01:00
|
|
|
category = *payload++;
|
2014-06-12 18:42:50 +02:00
|
|
|
plen = len - IEEE80211_HDRLEN - 1;
|
2013-12-29 10:22:23 +01:00
|
|
|
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Received Action frame: SA=" MACSTR
|
|
|
|
" Category=%u DataLen=%d freq=%d MHz",
|
|
|
|
MAC2STR(mgmt->sa), category, (int) plen, freq);
|
|
|
|
|
2014-10-22 14:03:57 +02:00
|
|
|
if (category == WLAN_ACTION_WMM) {
|
|
|
|
wmm_ac_rx_action(wpa_s, mgmt->da, mgmt->sa, payload, plen);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-12-29 10:22:23 +01:00
|
|
|
#ifdef CONFIG_IEEE80211R
|
|
|
|
if (category == WLAN_ACTION_FT) {
|
|
|
|
ft_rx_action(wpa_s, payload, plen);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_IEEE80211R */
|
|
|
|
|
|
|
|
#ifdef CONFIG_SME
|
|
|
|
if (category == WLAN_ACTION_SA_QUERY) {
|
|
|
|
sme_sa_query_rx(wpa_s, mgmt->sa, payload, plen);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SME */
|
|
|
|
|
|
|
|
#ifdef CONFIG_WNM
|
|
|
|
if (mgmt->u.action.category == WLAN_ACTION_WNM) {
|
|
|
|
ieee802_11_rx_wnm_action(wpa_s, mgmt, len);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_WNM */
|
|
|
|
|
|
|
|
#ifdef CONFIG_GAS
|
2014-01-23 10:18:20 +01:00
|
|
|
if ((mgmt->u.action.category == WLAN_ACTION_PUBLIC ||
|
|
|
|
mgmt->u.action.category == WLAN_ACTION_PROTECTED_DUAL) &&
|
2013-12-29 10:22:23 +01:00
|
|
|
gas_query_rx(wpa_s->gas, mgmt->da, mgmt->sa, mgmt->bssid,
|
2014-01-23 10:18:20 +01:00
|
|
|
mgmt->u.action.category,
|
2013-12-29 10:22:23 +01:00
|
|
|
payload, plen, freq) == 0)
|
|
|
|
return;
|
|
|
|
#endif /* CONFIG_GAS */
|
|
|
|
|
2017-06-15 20:18:15 +02:00
|
|
|
#ifdef CONFIG_GAS_SERVER
|
|
|
|
if ((mgmt->u.action.category == WLAN_ACTION_PUBLIC ||
|
|
|
|
mgmt->u.action.category == WLAN_ACTION_PROTECTED_DUAL) &&
|
|
|
|
gas_server_rx(wpa_s->gas_server, mgmt->da, mgmt->sa, mgmt->bssid,
|
|
|
|
mgmt->u.action.category,
|
|
|
|
payload, plen, freq) == 0)
|
|
|
|
return;
|
|
|
|
#endif /* CONFIG_GAS_SERVER */
|
|
|
|
|
2013-12-29 10:22:23 +01:00
|
|
|
#ifdef CONFIG_TDLS
|
|
|
|
if (category == WLAN_ACTION_PUBLIC && plen >= 4 &&
|
|
|
|
payload[0] == WLAN_TDLS_DISCOVERY_RESPONSE) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"TDLS: Received Discovery Response from " MACSTR,
|
|
|
|
MAC2STR(mgmt->sa));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_TDLS */
|
|
|
|
|
|
|
|
#ifdef CONFIG_INTERWORKING
|
|
|
|
if (category == WLAN_ACTION_QOS && plen >= 1 &&
|
|
|
|
payload[0] == QOS_QOS_MAP_CONFIG) {
|
|
|
|
const u8 *pos = payload + 1;
|
|
|
|
size_t qlen = plen - 1;
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Interworking: Received QoS Map Configure frame from "
|
|
|
|
MACSTR, MAC2STR(mgmt->sa));
|
|
|
|
if (os_memcmp(mgmt->sa, wpa_s->bssid, ETH_ALEN) == 0 &&
|
|
|
|
qlen > 2 && pos[0] == WLAN_EID_QOS_MAP_SET &&
|
|
|
|
pos[1] <= qlen - 2 && pos[1] >= 16)
|
|
|
|
wpas_qos_map_set(wpa_s, pos + 2, pos[1]);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_INTERWORKING */
|
|
|
|
|
2016-04-06 18:42:13 +02:00
|
|
|
if (category == WLAN_ACTION_RADIO_MEASUREMENT &&
|
|
|
|
payload[0] == WLAN_RRM_RADIO_MEASUREMENT_REQUEST) {
|
|
|
|
wpas_rrm_handle_radio_measurement_request(wpa_s, mgmt->sa,
|
2017-06-11 14:41:19 +02:00
|
|
|
mgmt->da,
|
2016-04-06 18:42:13 +02:00
|
|
|
payload + 1,
|
|
|
|
plen - 1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-11-05 09:42:50 +01:00
|
|
|
if (category == WLAN_ACTION_RADIO_MEASUREMENT &&
|
|
|
|
payload[0] == WLAN_RRM_NEIGHBOR_REPORT_RESPONSE) {
|
|
|
|
wpas_rrm_process_neighbor_rep(wpa_s, payload + 1, plen - 1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-11-05 09:42:56 +01:00
|
|
|
if (category == WLAN_ACTION_RADIO_MEASUREMENT &&
|
|
|
|
payload[0] == WLAN_RRM_LINK_MEASUREMENT_REQUEST) {
|
|
|
|
wpas_rrm_handle_link_measurement_request(wpa_s, mgmt->sa,
|
|
|
|
payload + 1, plen - 1,
|
|
|
|
rssi);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-11-16 16:28:53 +01:00
|
|
|
#ifdef CONFIG_FST
|
|
|
|
if (mgmt->u.action.category == WLAN_ACTION_FST && wpa_s->fst) {
|
|
|
|
fst_rx_action(wpa_s->fst, mgmt, len);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_FST */
|
|
|
|
|
2017-06-15 20:18:12 +02:00
|
|
|
#ifdef CONFIG_DPP
|
|
|
|
if (category == WLAN_ACTION_PUBLIC && plen >= 5 &&
|
|
|
|
payload[0] == WLAN_PA_VENDOR_SPECIFIC &&
|
|
|
|
WPA_GET_BE24(&payload[1]) == OUI_WFA &&
|
|
|
|
payload[4] == DPP_OUI_TYPE) {
|
2017-10-18 21:51:30 +02:00
|
|
|
payload++;
|
|
|
|
plen--;
|
2017-06-15 20:18:12 +02:00
|
|
|
wpas_dpp_rx_action(wpa_s, mgmt->sa, payload, plen, freq);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_DPP */
|
|
|
|
|
2020-06-03 17:24:04 +02:00
|
|
|
if (category == WLAN_ACTION_ROBUST_AV_STREAMING &&
|
|
|
|
payload[0] == ROBUST_AV_MSCS_RESP) {
|
|
|
|
wpas_handle_robust_av_recv_action(wpa_s, mgmt->sa,
|
|
|
|
payload + 1, plen - 1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-12-29 10:22:23 +01:00
|
|
|
wpas_p2p_rx_action(wpa_s, mgmt->da, mgmt->sa, mgmt->bssid,
|
|
|
|
category, payload, plen, freq);
|
2014-03-11 05:07:01 +01:00
|
|
|
if (wpa_s->ifmsh)
|
|
|
|
mesh_mpm_action_rx(wpa_s, mgmt, len);
|
2013-12-29 10:22:23 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-01-24 15:14:29 +01:00
|
|
|
static void wpa_supplicant_notify_avoid_freq(struct wpa_supplicant *wpa_s,
|
|
|
|
union wpa_event_data *event)
|
|
|
|
{
|
|
|
|
struct wpa_freq_range_list *list;
|
|
|
|
char *str = NULL;
|
|
|
|
|
|
|
|
list = &event->freq_range;
|
|
|
|
|
|
|
|
if (list->num)
|
|
|
|
str = freq_range_list_str(list);
|
|
|
|
wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_AVOID_FREQ "ranges=%s",
|
|
|
|
str ? str : "");
|
|
|
|
|
|
|
|
#ifdef CONFIG_P2P
|
|
|
|
if (freq_range_list_parse(&wpa_s->global->p2p_go_avoid_freq, str)) {
|
|
|
|
wpa_dbg(wpa_s, MSG_ERROR, "%s: Failed to parse freq range",
|
|
|
|
__func__);
|
|
|
|
} else {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Update channel list based on frequency avoid event");
|
|
|
|
|
2015-07-27 21:24:22 +02:00
|
|
|
/*
|
|
|
|
* The update channel flow will also take care of moving a GO
|
|
|
|
* from the unsafe frequency if needed.
|
|
|
|
*/
|
2015-07-27 21:24:27 +02:00
|
|
|
wpas_p2p_update_channel_list(wpa_s,
|
|
|
|
WPAS_P2P_CHANNEL_UPDATE_AVOID);
|
2014-01-24 15:14:29 +01:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_P2P */
|
|
|
|
|
|
|
|
os_free(str);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-01-28 13:45:37 +01:00
|
|
|
static void wpa_supplicant_event_port_authorized(struct wpa_supplicant *wpa_s)
|
2014-10-23 17:21:49 +02:00
|
|
|
{
|
|
|
|
if (wpa_s->wpa_state == WPA_ASSOCIATED) {
|
|
|
|
wpa_supplicant_cancel_auth_timeout(wpa_s);
|
|
|
|
wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
|
2020-04-23 23:51:11 +02:00
|
|
|
eapol_sm_notify_portValid(wpa_s->eapol, true);
|
|
|
|
eapol_sm_notify_eap_success(wpa_s->eapol, true);
|
2019-08-07 10:51:44 +02:00
|
|
|
wpa_s->drv_authorized_port = 1;
|
2014-10-23 17:21:49 +02:00
|
|
|
}
|
2018-01-28 13:45:37 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-04-04 22:44:08 +02:00
|
|
|
static unsigned int wpas_event_cac_ms(const struct wpa_supplicant *wpa_s,
|
|
|
|
int freq)
|
|
|
|
{
|
|
|
|
size_t i;
|
|
|
|
int j;
|
|
|
|
|
|
|
|
for (i = 0; i < wpa_s->hw.num_modes; i++) {
|
|
|
|
const struct hostapd_hw_modes *mode = &wpa_s->hw.modes[i];
|
|
|
|
|
|
|
|
for (j = 0; j < mode->num_channels; j++) {
|
|
|
|
const struct hostapd_channel_data *chan;
|
|
|
|
|
|
|
|
chan = &mode->channels[j];
|
|
|
|
if (chan->freq == freq)
|
|
|
|
return chan->dfs_cac_ms;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void wpas_event_dfs_cac_started(struct wpa_supplicant *wpa_s,
|
|
|
|
struct dfs_event *radar)
|
|
|
|
{
|
|
|
|
#if defined(NEED_AP_MLME) && defined(CONFIG_AP)
|
2018-08-27 23:28:44 +02:00
|
|
|
if (wpa_s->ap_iface || wpa_s->ifmsh) {
|
2018-04-04 22:44:08 +02:00
|
|
|
wpas_ap_event_dfs_cac_started(wpa_s, radar);
|
|
|
|
} else
|
|
|
|
#endif /* NEED_AP_MLME && CONFIG_AP */
|
|
|
|
{
|
|
|
|
unsigned int cac_time = wpas_event_cac_ms(wpa_s, radar->freq);
|
|
|
|
|
|
|
|
cac_time /= 1000; /* convert from ms to sec */
|
|
|
|
if (!cac_time)
|
|
|
|
cac_time = 10 * 60; /* max timeout: 10 minutes */
|
|
|
|
|
|
|
|
/* Restart auth timeout: CAC time added to initial timeout */
|
|
|
|
wpas_auth_timeout_restart(wpa_s, cac_time);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void wpas_event_dfs_cac_finished(struct wpa_supplicant *wpa_s,
|
|
|
|
struct dfs_event *radar)
|
|
|
|
{
|
|
|
|
#if defined(NEED_AP_MLME) && defined(CONFIG_AP)
|
2018-08-27 23:28:44 +02:00
|
|
|
if (wpa_s->ap_iface || wpa_s->ifmsh) {
|
2018-04-04 22:44:08 +02:00
|
|
|
wpas_ap_event_dfs_cac_finished(wpa_s, radar);
|
|
|
|
} else
|
|
|
|
#endif /* NEED_AP_MLME && CONFIG_AP */
|
|
|
|
{
|
|
|
|
/* Restart auth timeout with original value after CAC is
|
|
|
|
* finished */
|
|
|
|
wpas_auth_timeout_restart(wpa_s, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void wpas_event_dfs_cac_aborted(struct wpa_supplicant *wpa_s,
|
|
|
|
struct dfs_event *radar)
|
|
|
|
{
|
|
|
|
#if defined(NEED_AP_MLME) && defined(CONFIG_AP)
|
2018-08-27 23:28:44 +02:00
|
|
|
if (wpa_s->ap_iface || wpa_s->ifmsh) {
|
2018-04-04 22:44:08 +02:00
|
|
|
wpas_ap_event_dfs_cac_aborted(wpa_s, radar);
|
|
|
|
} else
|
|
|
|
#endif /* NEED_AP_MLME && CONFIG_AP */
|
|
|
|
{
|
|
|
|
/* Restart auth timeout with original value after CAC is
|
|
|
|
* aborted */
|
|
|
|
wpas_auth_timeout_restart(wpa_s, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-01-28 13:45:37 +01:00
|
|
|
static void wpa_supplicant_event_assoc_auth(struct wpa_supplicant *wpa_s,
|
|
|
|
union wpa_event_data *data)
|
|
|
|
{
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"Connection authorized by device, previous state %d",
|
|
|
|
wpa_s->wpa_state);
|
|
|
|
|
|
|
|
wpa_supplicant_event_port_authorized(wpa_s);
|
|
|
|
|
2017-08-17 10:28:06 +02:00
|
|
|
wpa_sm_set_rx_replay_ctr(wpa_s->wpa, data->assoc_info.key_replay_ctr);
|
2014-10-23 17:21:49 +02:00
|
|
|
wpa_sm_set_ptk_kck_kek(wpa_s->wpa, data->assoc_info.ptk_kck,
|
2015-01-25 15:49:18 +01:00
|
|
|
data->assoc_info.ptk_kck_len,
|
|
|
|
data->assoc_info.ptk_kek,
|
|
|
|
data->assoc_info.ptk_kek_len);
|
2017-03-22 11:40:05 +01:00
|
|
|
#ifdef CONFIG_FILS
|
|
|
|
if (wpa_s->auth_alg == WPA_AUTH_ALG_FILS) {
|
2017-03-22 11:40:05 +01:00
|
|
|
struct wpa_bss *bss = wpa_bss_get_bssid(wpa_s, wpa_s->bssid);
|
|
|
|
const u8 *fils_cache_id = wpa_bss_get_fils_cache_id(bss);
|
|
|
|
|
2017-03-22 11:40:05 +01:00
|
|
|
/* Update ERP next sequence number */
|
|
|
|
eapol_sm_update_erp_next_seq_num(
|
|
|
|
wpa_s->eapol, data->assoc_info.fils_erp_next_seq_num);
|
2017-03-22 11:40:05 +01:00
|
|
|
|
|
|
|
if (data->assoc_info.fils_pmk && data->assoc_info.fils_pmkid) {
|
|
|
|
/* Add the new PMK and PMKID to the PMKSA cache */
|
|
|
|
wpa_sm_pmksa_cache_add(wpa_s->wpa,
|
|
|
|
data->assoc_info.fils_pmk,
|
|
|
|
data->assoc_info.fils_pmk_len,
|
|
|
|
data->assoc_info.fils_pmkid,
|
|
|
|
wpa_s->bssid, fils_cache_id);
|
|
|
|
} else if (data->assoc_info.fils_pmkid) {
|
|
|
|
/* Update the current PMKSA used for this connection */
|
|
|
|
pmksa_cache_set_current(wpa_s->wpa,
|
|
|
|
data->assoc_info.fils_pmkid,
|
2018-04-08 19:06:40 +02:00
|
|
|
NULL, NULL, 0, NULL, 0);
|
2017-03-22 11:40:05 +01:00
|
|
|
}
|
2017-03-22 11:40:05 +01:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_FILS */
|
2014-10-23 17:21:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-10-15 16:58:17 +02:00
|
|
|
static const char * connect_fail_reason(enum sta_connect_fail_reason_codes code)
|
|
|
|
{
|
|
|
|
switch (code) {
|
|
|
|
case STA_CONNECT_FAIL_REASON_UNSPECIFIED:
|
|
|
|
return "";
|
|
|
|
case STA_CONNECT_FAIL_REASON_NO_BSS_FOUND:
|
|
|
|
return "no_bss_found";
|
|
|
|
case STA_CONNECT_FAIL_REASON_AUTH_TX_FAIL:
|
|
|
|
return "auth_tx_fail";
|
|
|
|
case STA_CONNECT_FAIL_REASON_AUTH_NO_ACK_RECEIVED:
|
|
|
|
return "auth_no_ack_received";
|
|
|
|
case STA_CONNECT_FAIL_REASON_AUTH_NO_RESP_RECEIVED:
|
|
|
|
return "auth_no_resp_received";
|
|
|
|
case STA_CONNECT_FAIL_REASON_ASSOC_REQ_TX_FAIL:
|
|
|
|
return "assoc_req_tx_fail";
|
|
|
|
case STA_CONNECT_FAIL_REASON_ASSOC_NO_ACK_RECEIVED:
|
|
|
|
return "assoc_no_ack_received";
|
|
|
|
case STA_CONNECT_FAIL_REASON_ASSOC_NO_RESP_RECEIVED:
|
|
|
|
return "assoc_no_resp_received";
|
|
|
|
default:
|
|
|
|
return "unknown_reason";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-05-16 17:47:34 +02:00
|
|
|
static void wpas_event_assoc_reject(struct wpa_supplicant *wpa_s,
|
|
|
|
union wpa_event_data *data)
|
|
|
|
{
|
|
|
|
const u8 *bssid = data->assoc_reject.bssid;
|
2019-05-22 08:59:45 +02:00
|
|
|
#ifdef CONFIG_MBO
|
|
|
|
struct wpa_bss *reject_bss;
|
|
|
|
#endif /* CONFIG_MBO */
|
2018-05-16 17:47:34 +02:00
|
|
|
|
|
|
|
if (!bssid || is_zero_ether_addr(bssid))
|
|
|
|
bssid = wpa_s->pending_bssid;
|
2019-05-22 08:59:45 +02:00
|
|
|
#ifdef CONFIG_MBO
|
|
|
|
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)
|
|
|
|
reject_bss = wpa_s->current_bss;
|
|
|
|
else
|
|
|
|
reject_bss = wpa_bss_get_bssid(wpa_s, bssid);
|
|
|
|
#endif /* CONFIG_MBO */
|
2018-05-16 17:47:34 +02:00
|
|
|
|
|
|
|
if (data->assoc_reject.bssid)
|
|
|
|
wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_ASSOC_REJECT
|
2020-10-15 16:58:17 +02:00
|
|
|
"bssid=" MACSTR " status_code=%u%s%s%s%s%s",
|
2018-05-16 17:47:34 +02:00
|
|
|
MAC2STR(data->assoc_reject.bssid),
|
|
|
|
data->assoc_reject.status_code,
|
|
|
|
data->assoc_reject.timed_out ? " timeout" : "",
|
|
|
|
data->assoc_reject.timeout_reason ? "=" : "",
|
|
|
|
data->assoc_reject.timeout_reason ?
|
2020-10-15 16:58:17 +02:00
|
|
|
data->assoc_reject.timeout_reason : "",
|
|
|
|
data->assoc_reject.reason_code !=
|
|
|
|
STA_CONNECT_FAIL_REASON_UNSPECIFIED ?
|
|
|
|
" qca_driver_reason=" : "",
|
|
|
|
connect_fail_reason(data->assoc_reject.reason_code));
|
2018-05-16 17:47:34 +02:00
|
|
|
else
|
|
|
|
wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_ASSOC_REJECT
|
2020-10-15 16:58:17 +02:00
|
|
|
"status_code=%u%s%s%s%s%s",
|
2018-05-16 17:47:34 +02:00
|
|
|
data->assoc_reject.status_code,
|
|
|
|
data->assoc_reject.timed_out ? " timeout" : "",
|
|
|
|
data->assoc_reject.timeout_reason ? "=" : "",
|
|
|
|
data->assoc_reject.timeout_reason ?
|
2020-10-15 16:58:17 +02:00
|
|
|
data->assoc_reject.timeout_reason : "",
|
|
|
|
data->assoc_reject.reason_code !=
|
|
|
|
STA_CONNECT_FAIL_REASON_UNSPECIFIED ?
|
|
|
|
" qca_driver_reason=" : "",
|
|
|
|
connect_fail_reason(data->assoc_reject.reason_code));
|
2018-05-16 17:47:34 +02:00
|
|
|
wpa_s->assoc_status_code = data->assoc_reject.status_code;
|
|
|
|
wpas_notify_assoc_status_code(wpa_s);
|
|
|
|
|
|
|
|
#ifdef CONFIG_OWE
|
|
|
|
if (data->assoc_reject.status_code ==
|
|
|
|
WLAN_STATUS_FINITE_CYCLIC_GROUP_NOT_SUPPORTED &&
|
|
|
|
wpa_s->key_mgmt == WPA_KEY_MGMT_OWE &&
|
|
|
|
wpa_s->current_ssid &&
|
|
|
|
wpa_s->current_ssid->owe_group == 0 &&
|
|
|
|
wpa_s->last_owe_group != 21) {
|
|
|
|
struct wpa_ssid *ssid = wpa_s->current_ssid;
|
|
|
|
struct wpa_bss *bss = wpa_s->current_bss;
|
|
|
|
|
|
|
|
if (!bss) {
|
|
|
|
bss = wpa_supplicant_get_new_bss(wpa_s, bssid);
|
2018-05-16 18:01:23 +02:00
|
|
|
if (!bss) {
|
|
|
|
wpas_connection_failed(wpa_s, bssid);
|
|
|
|
wpa_supplicant_mark_disassoc(wpa_s);
|
2018-05-16 17:47:34 +02:00
|
|
|
return;
|
2018-05-16 18:01:23 +02:00
|
|
|
}
|
2018-05-16 17:47:34 +02:00
|
|
|
}
|
|
|
|
wpa_printf(MSG_DEBUG, "OWE: Try next supported DH group");
|
|
|
|
wpas_connect_work_done(wpa_s);
|
|
|
|
wpa_supplicant_mark_disassoc(wpa_s);
|
|
|
|
wpa_supplicant_connect(wpa_s, bss, ssid);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_OWE */
|
|
|
|
|
2020-03-28 14:06:15 +01:00
|
|
|
#ifdef CONFIG_DPP2
|
|
|
|
/* Try to follow AP's PFS policy. WLAN_STATUS_ASSOC_DENIED_UNSPEC is
|
|
|
|
* the status code defined in the DPP R2 tech spec.
|
|
|
|
* WLAN_STATUS_AKMP_NOT_VALID is addressed in the same manner as an
|
|
|
|
* interoperability workaround with older hostapd implementation. */
|
2020-05-01 20:07:42 +02:00
|
|
|
if (DPP_VERSION > 1 && wpa_s->current_ssid &&
|
2020-09-23 22:06:55 +02:00
|
|
|
(wpa_s->current_ssid->key_mgmt == WPA_KEY_MGMT_DPP ||
|
|
|
|
((wpa_s->current_ssid->key_mgmt & WPA_KEY_MGMT_DPP) &&
|
|
|
|
wpa_s->key_mgmt == WPA_KEY_MGMT_DPP)) &&
|
2020-03-28 14:06:15 +01:00
|
|
|
wpa_s->current_ssid->dpp_pfs == 0 &&
|
|
|
|
(data->assoc_reject.status_code ==
|
|
|
|
WLAN_STATUS_ASSOC_DENIED_UNSPEC ||
|
|
|
|
data->assoc_reject.status_code == WLAN_STATUS_AKMP_NOT_VALID)) {
|
|
|
|
struct wpa_ssid *ssid = wpa_s->current_ssid;
|
|
|
|
struct wpa_bss *bss = wpa_s->current_bss;
|
|
|
|
|
|
|
|
wpa_s->current_ssid->dpp_pfs_fallback ^= 1;
|
|
|
|
if (!bss)
|
|
|
|
bss = wpa_supplicant_get_new_bss(wpa_s, bssid);
|
|
|
|
if (!bss || wpa_s->dpp_pfs_fallback) {
|
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
"DPP: Updated PFS policy for next try");
|
|
|
|
wpas_connection_failed(wpa_s, bssid);
|
|
|
|
wpa_supplicant_mark_disassoc(wpa_s);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
wpa_printf(MSG_DEBUG, "DPP: Try again with updated PFS policy");
|
|
|
|
wpa_s->dpp_pfs_fallback = 1;
|
|
|
|
wpas_connect_work_done(wpa_s);
|
|
|
|
wpa_supplicant_mark_disassoc(wpa_s);
|
|
|
|
wpa_supplicant_connect(wpa_s, bss, ssid);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_DPP2 */
|
|
|
|
|
2017-08-21 18:43:52 +02:00
|
|
|
#ifdef CONFIG_MBO
|
|
|
|
if (data->assoc_reject.status_code ==
|
|
|
|
WLAN_STATUS_DENIED_POOR_CHANNEL_CONDITIONS &&
|
2019-05-22 08:59:45 +02:00
|
|
|
reject_bss && data->assoc_reject.resp_ies) {
|
2017-08-21 18:43:52 +02:00
|
|
|
const u8 *rssi_rej;
|
|
|
|
|
|
|
|
rssi_rej = mbo_get_attr_from_ies(
|
|
|
|
data->assoc_reject.resp_ies,
|
|
|
|
data->assoc_reject.resp_ies_len,
|
|
|
|
OCE_ATTR_ID_RSSI_BASED_ASSOC_REJECT);
|
|
|
|
if (rssi_rej && rssi_rej[1] == 2) {
|
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
"OCE: RSSI-based association rejection from "
|
|
|
|
MACSTR " (Delta RSSI: %u, Retry Delay: %u)",
|
2019-05-22 08:59:45 +02:00
|
|
|
MAC2STR(reject_bss->bssid),
|
2017-08-21 18:43:52 +02:00
|
|
|
rssi_rej[2], rssi_rej[3]);
|
|
|
|
wpa_bss_tmp_disallow(wpa_s,
|
2019-05-22 08:59:45 +02:00
|
|
|
reject_bss->bssid,
|
2017-08-21 18:43:52 +02:00
|
|
|
rssi_rej[3],
|
2019-05-22 08:59:45 +02:00
|
|
|
rssi_rej[2] + reject_bss->level);
|
2017-08-21 18:43:52 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_MBO */
|
|
|
|
|
2018-05-16 17:47:34 +02:00
|
|
|
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) {
|
|
|
|
sme_event_assoc_reject(wpa_s, data);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Driver-based SME cases */
|
|
|
|
|
|
|
|
#ifdef CONFIG_SAE
|
|
|
|
if (wpa_s->current_ssid &&
|
|
|
|
wpa_key_mgmt_sae(wpa_s->current_ssid->key_mgmt) &&
|
|
|
|
!data->assoc_reject.timed_out) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "SAE: Drop PMKSA cache entry");
|
|
|
|
wpa_sm_aborted_cached(wpa_s->wpa);
|
|
|
|
wpa_sm_pmksa_cache_flush(wpa_s->wpa, wpa_s->current_ssid);
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SAE */
|
|
|
|
|
2018-09-05 16:56:29 +02:00
|
|
|
#ifdef CONFIG_DPP
|
|
|
|
if (wpa_s->current_ssid &&
|
|
|
|
wpa_s->current_ssid->key_mgmt == WPA_KEY_MGMT_DPP &&
|
|
|
|
!data->assoc_reject.timed_out) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "DPP: Drop PMKSA cache entry");
|
|
|
|
wpa_sm_aborted_cached(wpa_s->wpa);
|
|
|
|
wpa_sm_pmksa_cache_flush(wpa_s->wpa, wpa_s->current_ssid);
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_DPP */
|
|
|
|
|
2018-05-16 17:47:34 +02:00
|
|
|
#ifdef CONFIG_FILS
|
|
|
|
/* Update ERP next sequence number */
|
2018-07-27 10:25:27 +02:00
|
|
|
if (wpa_s->auth_alg == WPA_AUTH_ALG_FILS) {
|
2018-05-16 17:47:34 +02:00
|
|
|
eapol_sm_update_erp_next_seq_num(
|
|
|
|
wpa_s->eapol,
|
|
|
|
data->assoc_reject.fils_erp_next_seq_num);
|
2018-07-27 10:25:27 +02:00
|
|
|
fils_connection_failure(wpa_s);
|
|
|
|
}
|
2018-05-16 17:47:34 +02:00
|
|
|
#endif /* CONFIG_FILS */
|
|
|
|
|
|
|
|
wpas_connection_failed(wpa_s, bssid);
|
|
|
|
wpa_supplicant_mark_disassoc(wpa_s);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-04-01 15:07:25 +02:00
|
|
|
static void wpas_event_unprot_beacon(struct wpa_supplicant *wpa_s,
|
|
|
|
struct unprot_beacon *data)
|
|
|
|
{
|
|
|
|
struct wpabuf *buf;
|
|
|
|
int res;
|
|
|
|
|
|
|
|
if (!data || wpa_s->wpa_state != WPA_COMPLETED ||
|
|
|
|
os_memcmp(data->sa, wpa_s->bssid, ETH_ALEN) != 0)
|
|
|
|
return;
|
|
|
|
wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_UNPROT_BEACON MACSTR,
|
|
|
|
MAC2STR(data->sa));
|
|
|
|
|
|
|
|
buf = wpabuf_alloc(4);
|
|
|
|
if (!buf)
|
|
|
|
return;
|
|
|
|
|
|
|
|
wpabuf_put_u8(buf, WLAN_ACTION_WNM);
|
|
|
|
wpabuf_put_u8(buf, WNM_NOTIFICATION_REQ);
|
|
|
|
wpabuf_put_u8(buf, 1); /* Dialog Token */
|
|
|
|
wpabuf_put_u8(buf, WNM_NOTIF_TYPE_BEACON_PROTECTION_FAILURE);
|
|
|
|
|
|
|
|
res = wpa_drv_send_action(wpa_s, wpa_s->assoc_freq, 0, wpa_s->bssid,
|
|
|
|
wpa_s->own_addr, wpa_s->bssid,
|
|
|
|
wpabuf_head(buf), wpabuf_len(buf), 0);
|
|
|
|
if (res < 0)
|
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
"Failed to send WNM-Notification Request frame");
|
|
|
|
|
|
|
|
wpabuf_free(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-01-03 12:10:12 +01:00
|
|
|
void wpa_supplicant_event(void *ctx, enum wpa_event_type event,
|
2008-02-28 02:34:43 +01:00
|
|
|
union wpa_event_data *data)
|
|
|
|
{
|
|
|
|
struct wpa_supplicant *wpa_s = ctx;
|
2015-03-30 22:44:11 +02:00
|
|
|
int resched;
|
2020-01-02 10:51:04 +01:00
|
|
|
struct os_reltime age, clear_at;
|
2018-11-30 16:56:56 +01:00
|
|
|
#ifndef CONFIG_NO_STDOUT_DEBUG
|
|
|
|
int level = MSG_DEBUG;
|
|
|
|
#endif /* CONFIG_NO_STDOUT_DEBUG */
|
2008-02-28 02:34:43 +01:00
|
|
|
|
2010-05-23 09:27:32 +02:00
|
|
|
if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED &&
|
|
|
|
event != EVENT_INTERFACE_ENABLED &&
|
2011-12-21 12:36:58 +01:00
|
|
|
event != EVENT_INTERFACE_STATUS &&
|
2016-02-29 13:30:01 +01:00
|
|
|
event != EVENT_SCAN_RESULTS &&
|
2011-12-21 12:36:58 +01:00
|
|
|
event != EVENT_SCHED_SCAN_STOPPED) {
|
2011-11-13 18:01:38 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"Ignore event %s (%d) while interface is disabled",
|
|
|
|
event_to_string(event), event);
|
2010-05-23 09:27:32 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-12-18 20:48:25 +01:00
|
|
|
#ifndef CONFIG_NO_STDOUT_DEBUG
|
2012-04-21 17:54:35 +02:00
|
|
|
if (event == EVENT_RX_MGMT && data->rx_mgmt.frame_len >= 24) {
|
2011-12-18 20:48:25 +01:00
|
|
|
const struct ieee80211_hdr *hdr;
|
|
|
|
u16 fc;
|
|
|
|
hdr = (const struct ieee80211_hdr *) data->rx_mgmt.frame;
|
|
|
|
fc = le_to_host16(hdr->frame_control);
|
|
|
|
if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT &&
|
|
|
|
WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_BEACON)
|
|
|
|
level = MSG_EXCESSIVE;
|
|
|
|
}
|
|
|
|
|
|
|
|
wpa_dbg(wpa_s, level, "Event %s (%d) received",
|
2011-11-13 18:01:38 +01:00
|
|
|
event_to_string(event), event);
|
2011-12-18 20:48:25 +01:00
|
|
|
#endif /* CONFIG_NO_STDOUT_DEBUG */
|
2010-07-18 05:33:34 +02:00
|
|
|
|
2008-02-28 02:34:43 +01:00
|
|
|
switch (event) {
|
2009-03-20 21:26:41 +01:00
|
|
|
case EVENT_AUTH:
|
2015-11-22 13:46:54 +01:00
|
|
|
#ifdef CONFIG_FST
|
2015-12-06 11:53:24 +01:00
|
|
|
if (!wpas_fst_update_mbie(wpa_s, data->auth.ies,
|
|
|
|
data->auth.ies_len))
|
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
"FST: MB IEs updated from auth IE");
|
2015-11-22 13:46:54 +01:00
|
|
|
#endif /* CONFIG_FST */
|
2009-03-20 21:26:41 +01:00
|
|
|
sme_event_auth(wpa_s, data);
|
2018-07-06 01:29:09 +02:00
|
|
|
wpa_s->auth_status_code = data->auth.status_code;
|
|
|
|
wpas_notify_auth_status_code(wpa_s);
|
2009-03-20 21:26:41 +01:00
|
|
|
break;
|
2008-02-28 02:34:43 +01:00
|
|
|
case EVENT_ASSOC:
|
2016-09-20 08:40:04 +02:00
|
|
|
#ifdef CONFIG_TESTING_OPTIONS
|
|
|
|
if (wpa_s->ignore_auth_resp) {
|
|
|
|
wpa_printf(MSG_INFO,
|
|
|
|
"EVENT_ASSOC - ignore_auth_resp active!");
|
|
|
|
break;
|
|
|
|
}
|
2017-10-15 22:25:55 +02:00
|
|
|
if (wpa_s->testing_resend_assoc) {
|
|
|
|
wpa_printf(MSG_INFO,
|
|
|
|
"EVENT_DEAUTH - testing_resend_assoc");
|
|
|
|
break;
|
|
|
|
}
|
2016-09-20 08:40:04 +02:00
|
|
|
#endif /* CONFIG_TESTING_OPTIONS */
|
2020-12-03 17:45:29 +01:00
|
|
|
if (wpa_s->disconnected) {
|
|
|
|
wpa_printf(MSG_INFO,
|
|
|
|
"Ignore unexpected EVENT_ASSOC in disconnected state");
|
|
|
|
break;
|
|
|
|
}
|
2008-02-28 02:34:43 +01:00
|
|
|
wpa_supplicant_event_assoc(wpa_s, data);
|
2018-11-01 12:03:21 +01:00
|
|
|
wpa_s->assoc_status_code = WLAN_STATUS_SUCCESS;
|
2017-06-19 20:34:10 +02:00
|
|
|
if (data &&
|
|
|
|
(data->assoc_info.authorized ||
|
|
|
|
(!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
|
|
|
|
wpa_fils_is_completed(wpa_s->wpa))))
|
2014-10-23 17:21:49 +02:00
|
|
|
wpa_supplicant_event_assoc_auth(wpa_s, data);
|
2015-11-16 07:05:05 +01:00
|
|
|
if (data) {
|
|
|
|
wpa_msg(wpa_s, MSG_INFO,
|
|
|
|
WPA_EVENT_SUBNET_STATUS_UPDATE "status=%u",
|
|
|
|
data->assoc_info.subnet_status);
|
|
|
|
}
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
case EVENT_DISASSOC:
|
2013-07-21 15:40:40 +02:00
|
|
|
wpas_event_disassoc(wpa_s,
|
|
|
|
data ? &data->disassoc_info : NULL);
|
|
|
|
break;
|
2009-12-02 16:26:28 +01:00
|
|
|
case EVENT_DEAUTH:
|
2016-09-20 08:40:04 +02:00
|
|
|
#ifdef CONFIG_TESTING_OPTIONS
|
|
|
|
if (wpa_s->ignore_auth_resp) {
|
|
|
|
wpa_printf(MSG_INFO,
|
|
|
|
"EVENT_DEAUTH - ignore_auth_resp active!");
|
|
|
|
break;
|
|
|
|
}
|
2017-10-15 22:25:55 +02:00
|
|
|
if (wpa_s->testing_resend_assoc) {
|
|
|
|
wpa_printf(MSG_INFO,
|
|
|
|
"EVENT_DEAUTH - testing_resend_assoc");
|
|
|
|
break;
|
|
|
|
}
|
2016-09-20 08:40:04 +02:00
|
|
|
#endif /* CONFIG_TESTING_OPTIONS */
|
2013-07-21 15:40:40 +02:00
|
|
|
wpas_event_deauth(wpa_s,
|
|
|
|
data ? &data->deauth_info : NULL);
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
case EVENT_MICHAEL_MIC_FAILURE:
|
|
|
|
wpa_supplicant_event_michael_mic_failure(wpa_s, data);
|
|
|
|
break;
|
|
|
|
#ifndef CONFIG_NO_SCAN_PROCESSING
|
2013-12-26 16:33:26 +01:00
|
|
|
case EVENT_SCAN_STARTED:
|
2015-09-16 14:15:05 +02:00
|
|
|
if (wpa_s->own_scan_requested ||
|
|
|
|
(data && !data->scan_info.external_scan)) {
|
2013-12-26 16:52:56 +01:00
|
|
|
struct os_reltime diff;
|
|
|
|
|
2015-09-16 14:15:05 +02:00
|
|
|
os_get_reltime(&wpa_s->scan_start_time);
|
2013-12-26 16:52:56 +01:00
|
|
|
os_reltime_sub(&wpa_s->scan_start_time,
|
|
|
|
&wpa_s->scan_trigger_time, &diff);
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Own scan request started a scan in %ld.%06ld seconds",
|
|
|
|
diff.sec, diff.usec);
|
2013-12-26 16:33:26 +01:00
|
|
|
wpa_s->own_scan_requested = 0;
|
|
|
|
wpa_s->own_scan_running = 1;
|
2013-12-26 16:35:48 +01:00
|
|
|
if (wpa_s->last_scan_req == MANUAL_SCAN_REQ &&
|
|
|
|
wpa_s->manual_scan_use_id) {
|
2014-08-15 01:56:00 +02:00
|
|
|
wpa_msg_ctrl(wpa_s, MSG_INFO,
|
|
|
|
WPA_EVENT_SCAN_STARTED "id=%u",
|
|
|
|
wpa_s->manual_scan_id);
|
2013-12-26 16:35:48 +01:00
|
|
|
} else {
|
2014-08-15 01:56:00 +02:00
|
|
|
wpa_msg_ctrl(wpa_s, MSG_INFO,
|
|
|
|
WPA_EVENT_SCAN_STARTED);
|
2013-12-26 16:35:48 +01:00
|
|
|
}
|
2013-12-26 16:33:26 +01:00
|
|
|
} else {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "External program started a scan");
|
2021-01-26 23:26:13 +01:00
|
|
|
wpa_s->radio->external_scan_req_interface = wpa_s;
|
2014-08-15 01:56:00 +02:00
|
|
|
wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_SCAN_STARTED);
|
2013-12-26 16:33:26 +01:00
|
|
|
}
|
|
|
|
break;
|
2008-02-28 02:34:43 +01:00
|
|
|
case EVENT_SCAN_RESULTS:
|
2016-02-29 13:30:01 +01:00
|
|
|
if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
|
|
|
|
wpa_s->scan_res_handler = NULL;
|
|
|
|
wpa_s->own_scan_running = 0;
|
2021-01-26 23:26:13 +01:00
|
|
|
wpa_s->radio->external_scan_req_interface = NULL;
|
2016-02-29 13:30:01 +01:00
|
|
|
wpa_s->last_scan_req = NORMAL_SCAN_REQ;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-09-16 14:15:05 +02:00
|
|
|
if (!(data && data->scan_info.external_scan) &&
|
|
|
|
os_reltime_initialized(&wpa_s->scan_start_time)) {
|
2013-12-26 16:52:56 +01:00
|
|
|
struct os_reltime now, diff;
|
|
|
|
os_get_reltime(&now);
|
|
|
|
os_reltime_sub(&now, &wpa_s->scan_start_time, &diff);
|
|
|
|
wpa_s->scan_start_time.sec = 0;
|
|
|
|
wpa_s->scan_start_time.usec = 0;
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Scan completed in %ld.%06ld seconds",
|
|
|
|
diff.sec, diff.usec);
|
|
|
|
}
|
2015-02-08 10:38:56 +01:00
|
|
|
if (wpa_supplicant_event_scan_results(wpa_s, data))
|
|
|
|
break; /* interface may have been removed */
|
2015-09-16 14:15:05 +02:00
|
|
|
if (!(data && data->scan_info.external_scan))
|
|
|
|
wpa_s->own_scan_running = 0;
|
|
|
|
if (data && data->scan_info.nl_scan_event)
|
2021-01-26 23:26:13 +01:00
|
|
|
wpa_s->radio->external_scan_req_interface = NULL;
|
2014-01-04 09:33:14 +01:00
|
|
|
radio_work_check_next(wpa_s);
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
#endif /* CONFIG_NO_SCAN_PROCESSING */
|
|
|
|
case EVENT_ASSOCINFO:
|
|
|
|
wpa_supplicant_event_associnfo(wpa_s, data);
|
|
|
|
break;
|
|
|
|
case EVENT_INTERFACE_STATUS:
|
|
|
|
wpa_supplicant_event_interface_status(wpa_s, data);
|
|
|
|
break;
|
|
|
|
case EVENT_PMKID_CANDIDATE:
|
|
|
|
wpa_supplicant_event_pmkid_candidate(wpa_s, data);
|
|
|
|
break;
|
2010-10-07 09:26:56 +02:00
|
|
|
#ifdef CONFIG_TDLS
|
|
|
|
case EVENT_TDLS:
|
|
|
|
wpa_supplicant_event_tdls(wpa_s, data);
|
|
|
|
break;
|
|
|
|
#endif /* CONFIG_TDLS */
|
2012-12-16 17:22:54 +01:00
|
|
|
#ifdef CONFIG_WNM
|
2012-02-26 16:27:19 +01:00
|
|
|
case EVENT_WNM:
|
|
|
|
wpa_supplicant_event_wnm(wpa_s, data);
|
|
|
|
break;
|
2012-12-16 17:22:54 +01:00
|
|
|
#endif /* CONFIG_WNM */
|
2008-02-28 02:34:43 +01:00
|
|
|
#ifdef CONFIG_IEEE80211R
|
|
|
|
case EVENT_FT_RESPONSE:
|
|
|
|
wpa_supplicant_event_ft_response(wpa_s, data);
|
|
|
|
break;
|
|
|
|
#endif /* CONFIG_IEEE80211R */
|
2009-01-15 00:21:55 +01:00
|
|
|
#ifdef CONFIG_IBSS_RSN
|
|
|
|
case EVENT_IBSS_RSN_START:
|
|
|
|
wpa_supplicant_event_ibss_rsn_start(wpa_s, data);
|
|
|
|
break;
|
|
|
|
#endif /* CONFIG_IBSS_RSN */
|
2009-04-01 16:10:36 +02:00
|
|
|
case EVENT_ASSOC_REJECT:
|
2018-05-16 17:47:34 +02:00
|
|
|
wpas_event_assoc_reject(wpa_s, data);
|
2009-04-01 16:10:36 +02:00
|
|
|
break;
|
2009-04-23 23:08:24 +02:00
|
|
|
case EVENT_AUTH_TIMED_OUT:
|
2014-11-30 14:42:26 +01:00
|
|
|
/* It is possible to get this event from earlier connection */
|
|
|
|
if (wpa_s->current_ssid &&
|
|
|
|
wpa_s->current_ssid->mode == WPAS_MODE_MESH) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"Ignore AUTH_TIMED_OUT in mesh configuration");
|
|
|
|
break;
|
|
|
|
}
|
2010-10-27 19:28:16 +02:00
|
|
|
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)
|
|
|
|
sme_event_auth_timed_out(wpa_s, data);
|
2009-04-23 23:08:24 +02:00
|
|
|
break;
|
|
|
|
case EVENT_ASSOC_TIMED_OUT:
|
2014-11-30 14:42:26 +01:00
|
|
|
/* It is possible to get this event from earlier connection */
|
|
|
|
if (wpa_s->current_ssid &&
|
|
|
|
wpa_s->current_ssid->mode == WPAS_MODE_MESH) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"Ignore ASSOC_TIMED_OUT in mesh configuration");
|
|
|
|
break;
|
|
|
|
}
|
2010-10-27 19:28:16 +02:00
|
|
|
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)
|
|
|
|
sme_event_assoc_timed_out(wpa_s, data);
|
2009-04-23 23:08:24 +02:00
|
|
|
break;
|
2009-12-13 22:05:39 +01:00
|
|
|
case EVENT_TX_STATUS:
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "EVENT_TX_STATUS dst=" MACSTR
|
|
|
|
" type=%d stype=%d",
|
|
|
|
MAC2STR(data->tx_status.dst),
|
|
|
|
data->tx_status.type, data->tx_status.stype);
|
2020-12-16 12:00:28 +01:00
|
|
|
#ifdef CONFIG_PASN
|
|
|
|
if (data->tx_status.type == WLAN_FC_TYPE_MGMT &&
|
|
|
|
data->tx_status.stype == WLAN_FC_STYPE_AUTH &&
|
|
|
|
wpas_pasn_auth_tx_status(wpa_s, data->tx_status.data,
|
|
|
|
data->tx_status.data_len,
|
|
|
|
data->tx_status.ack) == 0)
|
|
|
|
break;
|
|
|
|
#endif /* CONFIG_PASN */
|
2011-09-29 18:22:08 +02:00
|
|
|
#ifdef CONFIG_AP
|
2010-07-18 23:30:25 +02:00
|
|
|
if (wpa_s->ap_iface == NULL) {
|
2011-09-29 18:22:08 +02:00
|
|
|
#ifdef CONFIG_OFFCHANNEL
|
2010-07-18 23:30:25 +02:00
|
|
|
if (data->tx_status.type == WLAN_FC_TYPE_MGMT &&
|
|
|
|
data->tx_status.stype == WLAN_FC_STYPE_ACTION)
|
2011-09-29 18:22:08 +02:00
|
|
|
offchannel_send_action_tx_status(
|
2010-07-18 23:30:25 +02:00
|
|
|
wpa_s, data->tx_status.dst,
|
|
|
|
data->tx_status.data,
|
|
|
|
data->tx_status.data_len,
|
2010-10-19 11:47:33 +02:00
|
|
|
data->tx_status.ack ?
|
2011-09-29 18:22:08 +02:00
|
|
|
OFFCHANNEL_SEND_ACTION_SUCCESS :
|
|
|
|
OFFCHANNEL_SEND_ACTION_NO_ACK);
|
|
|
|
#endif /* CONFIG_OFFCHANNEL */
|
2010-07-18 23:30:25 +02:00
|
|
|
break;
|
|
|
|
}
|
2011-09-29 18:22:08 +02:00
|
|
|
#endif /* CONFIG_AP */
|
|
|
|
#ifdef CONFIG_OFFCHANNEL
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "EVENT_TX_STATUS pending_dst="
|
2016-03-30 13:57:31 +02:00
|
|
|
MACSTR, MAC2STR(wpa_s->p2pdev->pending_action_dst));
|
2010-07-18 23:30:25 +02:00
|
|
|
/*
|
|
|
|
* Catch TX status events for Action frames we sent via group
|
2016-03-30 13:57:31 +02:00
|
|
|
* interface in GO mode, or via standalone AP interface.
|
|
|
|
* Note, wpa_s->p2pdev will be the same as wpa_s->parent,
|
|
|
|
* except when the primary interface is used as a GO interface
|
|
|
|
* (for drivers which do not have group interface concurrency)
|
2010-07-18 23:30:25 +02:00
|
|
|
*/
|
|
|
|
if (data->tx_status.type == WLAN_FC_TYPE_MGMT &&
|
|
|
|
data->tx_status.stype == WLAN_FC_STYPE_ACTION &&
|
2016-03-30 13:57:31 +02:00
|
|
|
os_memcmp(wpa_s->p2pdev->pending_action_dst,
|
2010-07-18 23:30:25 +02:00
|
|
|
data->tx_status.dst, ETH_ALEN) == 0) {
|
2011-09-29 18:22:08 +02:00
|
|
|
offchannel_send_action_tx_status(
|
2016-03-30 13:57:31 +02:00
|
|
|
wpa_s->p2pdev, data->tx_status.dst,
|
2010-07-18 23:30:25 +02:00
|
|
|
data->tx_status.data,
|
|
|
|
data->tx_status.data_len,
|
2010-11-24 13:25:33 +01:00
|
|
|
data->tx_status.ack ?
|
2011-09-29 18:22:08 +02:00
|
|
|
OFFCHANNEL_SEND_ACTION_SUCCESS :
|
|
|
|
OFFCHANNEL_SEND_ACTION_NO_ACK);
|
2009-12-13 22:05:39 +01:00
|
|
|
break;
|
2010-07-18 23:30:25 +02:00
|
|
|
}
|
2011-09-29 18:22:08 +02:00
|
|
|
#endif /* CONFIG_OFFCHANNEL */
|
|
|
|
#ifdef CONFIG_AP
|
2009-12-13 22:05:39 +01:00
|
|
|
switch (data->tx_status.type) {
|
|
|
|
case WLAN_FC_TYPE_MGMT:
|
|
|
|
ap_mgmt_tx_cb(wpa_s, data->tx_status.data,
|
|
|
|
data->tx_status.data_len,
|
|
|
|
data->tx_status.stype,
|
|
|
|
data->tx_status.ack);
|
|
|
|
break;
|
|
|
|
case WLAN_FC_TYPE_DATA:
|
|
|
|
ap_tx_status(wpa_s, data->tx_status.dst,
|
|
|
|
data->tx_status.data,
|
|
|
|
data->tx_status.data_len,
|
|
|
|
data->tx_status.ack);
|
|
|
|
break;
|
|
|
|
}
|
2011-09-29 18:22:08 +02:00
|
|
|
#endif /* CONFIG_AP */
|
2009-12-13 22:05:39 +01:00
|
|
|
break;
|
2011-09-29 18:22:08 +02:00
|
|
|
#ifdef CONFIG_AP
|
2011-11-19 12:00:30 +01:00
|
|
|
case EVENT_EAPOL_TX_STATUS:
|
|
|
|
ap_eapol_tx_status(wpa_s, data->eapol_tx_status.dst,
|
|
|
|
data->eapol_tx_status.data,
|
|
|
|
data->eapol_tx_status.data_len,
|
|
|
|
data->eapol_tx_status.ack);
|
|
|
|
break;
|
2011-10-20 20:03:08 +02:00
|
|
|
case EVENT_DRIVER_CLIENT_POLL_OK:
|
|
|
|
ap_client_poll_ok(wpa_s, data->client_poll.addr);
|
|
|
|
break;
|
2009-12-13 22:05:39 +01:00
|
|
|
case EVENT_RX_FROM_UNKNOWN:
|
|
|
|
if (wpa_s->ap_iface == NULL)
|
|
|
|
break;
|
2011-10-20 20:51:32 +02:00
|
|
|
ap_rx_from_unknown_sta(wpa_s, data->rx_from_unknown.addr,
|
|
|
|
data->rx_from_unknown.wds);
|
2009-12-13 22:05:39 +01:00
|
|
|
break;
|
2018-04-25 11:39:57 +02:00
|
|
|
#endif /* CONFIG_AP */
|
2019-04-08 08:44:57 +02:00
|
|
|
|
|
|
|
case EVENT_CH_SWITCH_STARTED:
|
2012-06-25 13:45:14 +02:00
|
|
|
case EVENT_CH_SWITCH:
|
2015-09-08 11:46:24 +02:00
|
|
|
if (!data || !wpa_s->current_ssid)
|
2012-06-25 13:45:14 +02:00
|
|
|
break;
|
|
|
|
|
2019-04-08 08:44:57 +02:00
|
|
|
wpa_msg(wpa_s, MSG_INFO,
|
|
|
|
"%sfreq=%d ht_enabled=%d ch_offset=%d ch_width=%s cf1=%d cf2=%d",
|
|
|
|
event == EVENT_CH_SWITCH ? WPA_EVENT_CHANNEL_SWITCH :
|
|
|
|
WPA_EVENT_CHANNEL_SWITCH_STARTED,
|
2016-06-27 19:24:06 +02:00
|
|
|
data->ch_switch.freq,
|
|
|
|
data->ch_switch.ht_enabled,
|
|
|
|
data->ch_switch.ch_offset,
|
|
|
|
channel_width_to_string(data->ch_switch.ch_width),
|
|
|
|
data->ch_switch.cf1,
|
|
|
|
data->ch_switch.cf2);
|
2019-04-08 08:44:57 +02:00
|
|
|
if (event == EVENT_CH_SWITCH_STARTED)
|
|
|
|
break;
|
2016-06-27 19:24:06 +02:00
|
|
|
|
2015-09-08 11:46:24 +02:00
|
|
|
wpa_s->assoc_freq = data->ch_switch.freq;
|
|
|
|
wpa_s->current_ssid->frequency = data->ch_switch.freq;
|
2020-11-03 20:20:01 +01:00
|
|
|
if (wpa_s->current_bss &&
|
|
|
|
wpa_s->current_bss->freq != data->ch_switch.freq) {
|
|
|
|
wpa_s->current_bss->freq = data->ch_switch.freq;
|
|
|
|
notify_bss_changes(wpa_s, WPA_BSS_FREQ_CHANGED_FLAG,
|
|
|
|
wpa_s->current_bss);
|
|
|
|
}
|
2015-09-08 11:46:24 +02:00
|
|
|
|
2019-12-27 13:22:24 +01:00
|
|
|
#ifdef CONFIG_SME
|
|
|
|
switch (data->ch_switch.ch_offset) {
|
|
|
|
case 1:
|
|
|
|
wpa_s->sme.ht_sec_chan = HT_SEC_CHAN_ABOVE;
|
|
|
|
break;
|
|
|
|
case -1:
|
|
|
|
wpa_s->sme.ht_sec_chan = HT_SEC_CHAN_BELOW;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
wpa_s->sme.ht_sec_chan = HT_SEC_CHAN_UNKNOWN;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SME */
|
|
|
|
|
2018-04-25 11:39:57 +02:00
|
|
|
#ifdef CONFIG_AP
|
2015-09-08 11:46:24 +02:00
|
|
|
if (wpa_s->current_ssid->mode == WPAS_MODE_AP ||
|
|
|
|
wpa_s->current_ssid->mode == WPAS_MODE_P2P_GO ||
|
2018-08-27 23:28:44 +02:00
|
|
|
wpa_s->current_ssid->mode == WPAS_MODE_MESH ||
|
2015-09-08 11:46:24 +02:00
|
|
|
wpa_s->current_ssid->mode ==
|
|
|
|
WPAS_MODE_P2P_GROUP_FORMATION) {
|
|
|
|
wpas_ap_ch_switch(wpa_s, data->ch_switch.freq,
|
|
|
|
data->ch_switch.ht_enabled,
|
|
|
|
data->ch_switch.ch_offset,
|
|
|
|
data->ch_switch.ch_width,
|
|
|
|
data->ch_switch.cf1,
|
2019-04-08 08:44:57 +02:00
|
|
|
data->ch_switch.cf2,
|
|
|
|
1);
|
2015-09-08 11:46:24 +02:00
|
|
|
}
|
2018-04-25 11:39:57 +02:00
|
|
|
#endif /* CONFIG_AP */
|
2015-09-08 11:46:19 +02:00
|
|
|
|
2020-08-02 13:25:05 +02:00
|
|
|
if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME)
|
|
|
|
sme_event_ch_switch(wpa_s);
|
|
|
|
|
2015-09-08 11:46:19 +02:00
|
|
|
wpas_p2p_update_channel_list(wpa_s, WPAS_P2P_CHANNEL_UPDATE_CS);
|
2018-10-30 13:00:00 +01:00
|
|
|
wnm_clear_coloc_intf_reporting(wpa_s);
|
2012-06-25 13:45:14 +02:00
|
|
|
break;
|
2018-04-25 11:39:57 +02:00
|
|
|
#ifdef CONFIG_AP
|
2015-03-05 03:03:39 +01:00
|
|
|
#ifdef NEED_AP_MLME
|
|
|
|
case EVENT_DFS_RADAR_DETECTED:
|
|
|
|
if (data)
|
2018-04-04 22:44:07 +02:00
|
|
|
wpas_ap_event_dfs_radar_detected(wpa_s,
|
|
|
|
&data->dfs_event);
|
2015-03-05 03:03:39 +01:00
|
|
|
break;
|
2018-04-04 22:44:08 +02:00
|
|
|
case EVENT_DFS_NOP_FINISHED:
|
|
|
|
if (data)
|
|
|
|
wpas_ap_event_dfs_cac_nop_finished(wpa_s,
|
|
|
|
&data->dfs_event);
|
|
|
|
break;
|
|
|
|
#endif /* NEED_AP_MLME */
|
|
|
|
#endif /* CONFIG_AP */
|
2015-03-05 03:03:39 +01:00
|
|
|
case EVENT_DFS_CAC_STARTED:
|
|
|
|
if (data)
|
2018-04-04 22:44:08 +02:00
|
|
|
wpas_event_dfs_cac_started(wpa_s, &data->dfs_event);
|
2015-03-05 03:03:39 +01:00
|
|
|
break;
|
|
|
|
case EVENT_DFS_CAC_FINISHED:
|
|
|
|
if (data)
|
2018-04-04 22:44:08 +02:00
|
|
|
wpas_event_dfs_cac_finished(wpa_s, &data->dfs_event);
|
2015-03-05 03:03:39 +01:00
|
|
|
break;
|
|
|
|
case EVENT_DFS_CAC_ABORTED:
|
|
|
|
if (data)
|
2018-04-04 22:44:08 +02:00
|
|
|
wpas_event_dfs_cac_aborted(wpa_s, &data->dfs_event);
|
2015-03-05 03:03:39 +01:00
|
|
|
break;
|
2012-04-01 20:13:38 +02:00
|
|
|
case EVENT_RX_MGMT: {
|
|
|
|
u16 fc, stype;
|
|
|
|
const struct ieee80211_mgmt *mgmt;
|
|
|
|
|
2014-03-08 19:21:21 +01:00
|
|
|
#ifdef CONFIG_TESTING_OPTIONS
|
|
|
|
if (wpa_s->ext_mgmt_frame_handling) {
|
|
|
|
struct rx_mgmt *rx = &data->rx_mgmt;
|
|
|
|
size_t hex_len = 2 * rx->frame_len + 1;
|
|
|
|
char *hex = os_malloc(hex_len);
|
|
|
|
if (hex) {
|
|
|
|
wpa_snprintf_hex(hex, hex_len,
|
|
|
|
rx->frame, rx->frame_len);
|
|
|
|
wpa_msg(wpa_s, MSG_INFO, "MGMT-RX freq=%d datarate=%u ssi_signal=%d %s",
|
|
|
|
rx->freq, rx->datarate, rx->ssi_signal,
|
|
|
|
hex);
|
|
|
|
os_free(hex);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_TESTING_OPTIONS */
|
|
|
|
|
2012-04-01 20:13:38 +02:00
|
|
|
mgmt = (const struct ieee80211_mgmt *)
|
|
|
|
data->rx_mgmt.frame;
|
|
|
|
fc = le_to_host16(mgmt->frame_control);
|
|
|
|
stype = WLAN_FC_GET_STYPE(fc);
|
|
|
|
|
2013-07-21 14:56:53 +02:00
|
|
|
#ifdef CONFIG_AP
|
2010-07-18 23:30:25 +02:00
|
|
|
if (wpa_s->ap_iface == NULL) {
|
2013-07-21 14:56:53 +02:00
|
|
|
#endif /* CONFIG_AP */
|
2010-07-18 23:30:25 +02:00
|
|
|
#ifdef CONFIG_P2P
|
|
|
|
if (stype == WLAN_FC_STYPE_PROBE_REQ &&
|
2016-04-02 15:52:02 +02:00
|
|
|
data->rx_mgmt.frame_len > IEEE80211_HDRLEN) {
|
2010-07-18 23:30:25 +02:00
|
|
|
const u8 *src = mgmt->sa;
|
2016-04-02 15:52:02 +02:00
|
|
|
const u8 *ie;
|
|
|
|
size_t ie_len;
|
|
|
|
|
|
|
|
ie = data->rx_mgmt.frame + IEEE80211_HDRLEN;
|
|
|
|
ie_len = data->rx_mgmt.frame_len -
|
|
|
|
IEEE80211_HDRLEN;
|
2012-04-01 17:48:12 +02:00
|
|
|
wpas_p2p_probe_req_rx(
|
|
|
|
wpa_s, src, mgmt->da,
|
|
|
|
mgmt->bssid, ie, ie_len,
|
2015-06-10 10:43:31 +02:00
|
|
|
data->rx_mgmt.freq,
|
2012-04-01 17:48:12 +02:00
|
|
|
data->rx_mgmt.ssi_signal);
|
2010-07-18 23:30:25 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_P2P */
|
2013-07-21 14:56:53 +02:00
|
|
|
#ifdef CONFIG_IBSS_RSN
|
2014-03-11 05:07:01 +01:00
|
|
|
if (wpa_s->current_ssid &&
|
|
|
|
wpa_s->current_ssid->mode == WPAS_MODE_IBSS &&
|
|
|
|
stype == WLAN_FC_STYPE_AUTH &&
|
2013-07-21 14:56:53 +02:00
|
|
|
data->rx_mgmt.frame_len >= 30) {
|
|
|
|
wpa_supplicant_event_ibss_auth(wpa_s, data);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_IBSS_RSN */
|
2013-12-29 10:22:23 +01:00
|
|
|
|
|
|
|
if (stype == WLAN_FC_STYPE_ACTION) {
|
|
|
|
wpas_event_rx_mgmt_action(
|
2014-06-12 18:42:50 +02:00
|
|
|
wpa_s, data->rx_mgmt.frame,
|
|
|
|
data->rx_mgmt.frame_len,
|
2014-11-05 09:42:56 +01:00
|
|
|
data->rx_mgmt.freq,
|
|
|
|
data->rx_mgmt.ssi_signal);
|
2013-12-29 10:22:23 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-03-11 05:07:01 +01:00
|
|
|
if (wpa_s->ifmsh) {
|
|
|
|
mesh_mpm_mgmt_rx(wpa_s, &data->rx_mgmt);
|
|
|
|
break;
|
|
|
|
}
|
2020-12-16 12:00:28 +01:00
|
|
|
#ifdef CONFIG_PASN
|
|
|
|
if (stype == WLAN_FC_STYPE_AUTH &&
|
|
|
|
wpas_pasn_auth_rx(wpa_s, mgmt,
|
|
|
|
data->rx_mgmt.frame_len) != -2)
|
|
|
|
break;
|
|
|
|
#endif /* CONFIG_PASN */
|
2014-03-11 05:07:01 +01:00
|
|
|
|
2018-02-01 12:31:28 +01:00
|
|
|
#ifdef CONFIG_SAE
|
|
|
|
if (stype == WLAN_FC_STYPE_AUTH &&
|
|
|
|
!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SME) &&
|
|
|
|
(wpa_s->drv_flags & WPA_DRIVER_FLAGS_SAE)) {
|
|
|
|
sme_external_auth_mgmt_rx(
|
|
|
|
wpa_s, data->rx_mgmt.frame,
|
|
|
|
data->rx_mgmt.frame_len);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_SAE */
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "AP: ignore received "
|
|
|
|
"management frame in non-AP mode");
|
2009-12-13 22:05:39 +01:00
|
|
|
break;
|
2013-07-21 14:56:53 +02:00
|
|
|
#ifdef CONFIG_AP
|
2010-07-18 23:30:25 +02:00
|
|
|
}
|
2012-04-01 20:13:38 +02:00
|
|
|
|
|
|
|
if (stype == WLAN_FC_STYPE_PROBE_REQ &&
|
2016-04-02 15:52:02 +02:00
|
|
|
data->rx_mgmt.frame_len > IEEE80211_HDRLEN) {
|
|
|
|
const u8 *ie;
|
|
|
|
size_t ie_len;
|
|
|
|
|
|
|
|
ie = data->rx_mgmt.frame + IEEE80211_HDRLEN;
|
|
|
|
ie_len = data->rx_mgmt.frame_len - IEEE80211_HDRLEN;
|
2012-04-01 20:13:38 +02:00
|
|
|
|
|
|
|
wpas_notify_preq(wpa_s, mgmt->sa, mgmt->da,
|
|
|
|
mgmt->bssid, ie, ie_len,
|
|
|
|
data->rx_mgmt.ssi_signal);
|
|
|
|
}
|
|
|
|
|
2010-01-03 11:37:02 +01:00
|
|
|
ap_mgmt_rx(wpa_s, &data->rx_mgmt);
|
2013-07-21 14:56:53 +02:00
|
|
|
#endif /* CONFIG_AP */
|
2009-12-13 22:05:39 +01:00
|
|
|
break;
|
2012-04-01 20:13:38 +02:00
|
|
|
}
|
2011-02-08 13:32:35 +01:00
|
|
|
case EVENT_RX_PROBE_REQ:
|
2011-04-14 01:39:25 +02:00
|
|
|
if (data->rx_probe_req.sa == NULL ||
|
|
|
|
data->rx_probe_req.ie == NULL)
|
|
|
|
break;
|
2011-02-08 13:32:35 +01:00
|
|
|
#ifdef CONFIG_AP
|
|
|
|
if (wpa_s->ap_iface) {
|
|
|
|
hostapd_probe_req_rx(wpa_s->ap_iface->bss[0],
|
|
|
|
data->rx_probe_req.sa,
|
2011-07-15 19:25:53 +02:00
|
|
|
data->rx_probe_req.da,
|
|
|
|
data->rx_probe_req.bssid,
|
2011-02-08 13:32:35 +01:00
|
|
|
data->rx_probe_req.ie,
|
2012-04-01 17:48:12 +02:00
|
|
|
data->rx_probe_req.ie_len,
|
|
|
|
data->rx_probe_req.ssi_signal);
|
2011-02-08 13:32:35 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_AP */
|
|
|
|
wpas_p2p_probe_req_rx(wpa_s, data->rx_probe_req.sa,
|
2011-07-15 19:25:53 +02:00
|
|
|
data->rx_probe_req.da,
|
|
|
|
data->rx_probe_req.bssid,
|
2011-02-08 13:32:35 +01:00
|
|
|
data->rx_probe_req.ie,
|
2012-04-01 17:48:12 +02:00
|
|
|
data->rx_probe_req.ie_len,
|
2015-06-10 10:43:31 +02:00
|
|
|
0,
|
2012-04-01 17:48:12 +02:00
|
|
|
data->rx_probe_req.ssi_signal);
|
2010-03-11 23:43:00 +01:00
|
|
|
break;
|
2010-07-18 23:30:25 +02:00
|
|
|
case EVENT_REMAIN_ON_CHANNEL:
|
2011-09-29 18:22:08 +02:00
|
|
|
#ifdef CONFIG_OFFCHANNEL
|
|
|
|
offchannel_remain_on_channel_cb(
|
|
|
|
wpa_s, data->remain_on_channel.freq,
|
|
|
|
data->remain_on_channel.duration);
|
|
|
|
#endif /* CONFIG_OFFCHANNEL */
|
2010-07-18 23:30:25 +02:00
|
|
|
wpas_p2p_remain_on_channel_cb(
|
|
|
|
wpa_s, data->remain_on_channel.freq,
|
|
|
|
data->remain_on_channel.duration);
|
2020-05-09 16:30:48 +02:00
|
|
|
#ifdef CONFIG_DPP
|
|
|
|
wpas_dpp_remain_on_channel_cb(
|
|
|
|
wpa_s, data->remain_on_channel.freq,
|
|
|
|
data->remain_on_channel.duration);
|
|
|
|
#endif /* CONFIG_DPP */
|
2010-07-18 23:30:25 +02:00
|
|
|
break;
|
|
|
|
case EVENT_CANCEL_REMAIN_ON_CHANNEL:
|
2011-09-29 18:22:08 +02:00
|
|
|
#ifdef CONFIG_OFFCHANNEL
|
|
|
|
offchannel_cancel_remain_on_channel_cb(
|
|
|
|
wpa_s, data->remain_on_channel.freq);
|
|
|
|
#endif /* CONFIG_OFFCHANNEL */
|
2010-07-18 23:30:25 +02:00
|
|
|
wpas_p2p_cancel_remain_on_channel_cb(
|
|
|
|
wpa_s, data->remain_on_channel.freq);
|
2017-06-15 20:18:12 +02:00
|
|
|
#ifdef CONFIG_DPP
|
|
|
|
wpas_dpp_cancel_remain_on_channel_cb(
|
|
|
|
wpa_s, data->remain_on_channel.freq);
|
|
|
|
#endif /* CONFIG_DPP */
|
2010-07-18 23:30:25 +02:00
|
|
|
break;
|
2010-01-03 16:44:40 +01:00
|
|
|
case EVENT_EAPOL_RX:
|
|
|
|
wpa_supplicant_rx_eapol(wpa_s, data->eapol_rx.src,
|
|
|
|
data->eapol_rx.data,
|
|
|
|
data->eapol_rx.data_len);
|
|
|
|
break;
|
2010-03-29 00:32:34 +02:00
|
|
|
case EVENT_SIGNAL_CHANGE:
|
2014-04-12 10:48:05 +02:00
|
|
|
wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_SIGNAL_CHANGE
|
|
|
|
"above=%d signal=%d noise=%d txrate=%d",
|
|
|
|
data->signal_change.above_threshold,
|
|
|
|
data->signal_change.current_signal,
|
|
|
|
data->signal_change.current_noise,
|
|
|
|
data->signal_change.current_txrate);
|
2015-02-18 03:35:15 +01:00
|
|
|
wpa_bss_update_level(wpa_s->current_bss,
|
|
|
|
data->signal_change.current_signal);
|
2010-03-29 00:32:34 +02:00
|
|
|
bgscan_notify_signal_change(
|
2010-08-27 15:58:06 +02:00
|
|
|
wpa_s, data->signal_change.above_threshold,
|
2010-10-12 19:03:36 +02:00
|
|
|
data->signal_change.current_signal,
|
|
|
|
data->signal_change.current_noise,
|
|
|
|
data->signal_change.current_txrate);
|
2010-03-29 00:32:34 +02:00
|
|
|
break;
|
2018-02-15 11:50:01 +01:00
|
|
|
case EVENT_INTERFACE_MAC_CHANGED:
|
|
|
|
wpa_supplicant_update_mac_addr(wpa_s);
|
|
|
|
break;
|
2010-05-23 09:27:32 +02:00
|
|
|
case EVENT_INTERFACE_ENABLED:
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Interface was enabled");
|
2010-05-23 09:27:32 +02:00
|
|
|
if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED) {
|
2020-01-02 10:51:04 +01:00
|
|
|
eloop_cancel_timeout(wpas_clear_disabled_interface,
|
|
|
|
wpa_s, NULL);
|
2011-12-03 12:20:40 +01:00
|
|
|
wpa_supplicant_update_mac_addr(wpa_s);
|
2019-08-06 18:04:21 +02:00
|
|
|
wpa_supplicant_set_default_scan_ies(wpa_s);
|
2014-03-27 07:58:29 +01:00
|
|
|
if (wpa_s->p2p_mgmt) {
|
|
|
|
wpa_supplicant_set_state(wpa_s,
|
|
|
|
WPA_DISCONNECTED);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-10-07 09:41:58 +02:00
|
|
|
#ifdef CONFIG_AP
|
2010-10-06 16:10:07 +02:00
|
|
|
if (!wpa_s->ap_iface) {
|
|
|
|
wpa_supplicant_set_state(wpa_s,
|
|
|
|
WPA_DISCONNECTED);
|
2015-01-08 21:39:18 +01:00
|
|
|
wpa_s->scan_req = NORMAL_SCAN_REQ;
|
2010-10-06 16:10:07 +02:00
|
|
|
wpa_supplicant_req_scan(wpa_s, 0, 0);
|
|
|
|
} else
|
|
|
|
wpa_supplicant_set_state(wpa_s,
|
|
|
|
WPA_COMPLETED);
|
2010-10-07 09:41:58 +02:00
|
|
|
#else /* CONFIG_AP */
|
|
|
|
wpa_supplicant_set_state(wpa_s, WPA_DISCONNECTED);
|
|
|
|
wpa_supplicant_req_scan(wpa_s, 0, 0);
|
|
|
|
#endif /* CONFIG_AP */
|
2010-05-23 09:27:32 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case EVENT_INTERFACE_DISABLED:
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Interface was disabled");
|
2013-09-02 14:40:59 +02:00
|
|
|
#ifdef CONFIG_P2P
|
|
|
|
if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_GO ||
|
|
|
|
(wpa_s->current_ssid && wpa_s->current_ssid->p2p_group &&
|
|
|
|
wpa_s->current_ssid->mode == WPAS_MODE_P2P_GO)) {
|
2015-01-08 21:39:18 +01:00
|
|
|
/*
|
|
|
|
* Mark interface disabled if this happens to end up not
|
|
|
|
* being removed as a separate P2P group interface.
|
|
|
|
*/
|
|
|
|
wpa_supplicant_set_state(wpa_s, WPA_INTERFACE_DISABLED);
|
2013-09-02 14:40:59 +02:00
|
|
|
/*
|
|
|
|
* The interface was externally disabled. Remove
|
|
|
|
* it assuming an external entity will start a
|
|
|
|
* new session if needed.
|
|
|
|
*/
|
2015-01-08 21:13:17 +01:00
|
|
|
if (wpa_s->current_ssid &&
|
|
|
|
wpa_s->current_ssid->p2p_group)
|
|
|
|
wpas_p2p_interface_unavailable(wpa_s);
|
|
|
|
else
|
|
|
|
wpas_p2p_disconnect(wpa_s);
|
2015-01-08 21:39:18 +01:00
|
|
|
/*
|
|
|
|
* wpa_s instance may have been freed, so must not use
|
|
|
|
* it here anymore.
|
|
|
|
*/
|
2013-09-02 14:40:59 +02:00
|
|
|
break;
|
|
|
|
}
|
2014-05-15 20:32:54 +02:00
|
|
|
if (wpa_s->p2p_scan_work && wpa_s->global->p2p &&
|
|
|
|
p2p_in_progress(wpa_s->global->p2p) > 1) {
|
|
|
|
/* This radio work will be cancelled, so clear P2P
|
|
|
|
* state as well.
|
|
|
|
*/
|
|
|
|
p2p_stop_find(wpa_s->global->p2p);
|
|
|
|
}
|
2013-09-02 14:40:59 +02:00
|
|
|
#endif /* CONFIG_P2P */
|
|
|
|
|
2014-04-26 15:42:45 +02:00
|
|
|
if (wpa_s->wpa_state >= WPA_AUTHENTICATING) {
|
|
|
|
/*
|
|
|
|
* Indicate disconnection to keep ctrl_iface events
|
|
|
|
* consistent.
|
|
|
|
*/
|
|
|
|
wpa_supplicant_event_disassoc(
|
|
|
|
wpa_s, WLAN_REASON_DEAUTH_LEAVING, 1);
|
|
|
|
}
|
2010-05-23 09:27:32 +02:00
|
|
|
wpa_supplicant_mark_disassoc(wpa_s);
|
2020-01-02 10:51:04 +01:00
|
|
|
os_reltime_age(&wpa_s->last_scan, &age);
|
2020-11-04 10:30:27 +01:00
|
|
|
if (age.sec >= wpa_s->conf->scan_res_valid_for_connect) {
|
|
|
|
clear_at.sec = wpa_s->conf->scan_res_valid_for_connect;
|
2020-01-02 10:51:04 +01:00
|
|
|
clear_at.usec = 0;
|
|
|
|
} else {
|
|
|
|
struct os_reltime tmp;
|
|
|
|
|
2020-11-04 10:30:27 +01:00
|
|
|
tmp.sec = wpa_s->conf->scan_res_valid_for_connect;
|
2020-01-02 10:51:04 +01:00
|
|
|
tmp.usec = 0;
|
|
|
|
os_reltime_sub(&tmp, &age, &clear_at);
|
|
|
|
}
|
|
|
|
eloop_register_timeout(clear_at.sec, clear_at.usec,
|
|
|
|
wpas_clear_disabled_interface,
|
|
|
|
wpa_s, NULL);
|
2014-02-13 10:24:00 +01:00
|
|
|
radio_remove_works(wpa_s, NULL, 0);
|
|
|
|
|
2010-05-23 09:27:32 +02:00
|
|
|
wpa_supplicant_set_state(wpa_s, WPA_INTERFACE_DISABLED);
|
|
|
|
break;
|
2010-10-15 17:55:22 +02:00
|
|
|
case EVENT_CHANNEL_LIST_CHANGED:
|
2014-04-13 15:32:38 +02:00
|
|
|
wpa_supplicant_update_channel_list(
|
|
|
|
wpa_s, &data->channel_list_changed);
|
2010-10-25 18:16:11 +02:00
|
|
|
break;
|
|
|
|
case EVENT_INTERFACE_UNAVAILABLE:
|
|
|
|
wpas_p2p_interface_unavailable(wpa_s);
|
2010-11-10 12:33:47 +01:00
|
|
|
break;
|
|
|
|
case EVENT_BEST_CHANNEL:
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG, "Best channel event received "
|
|
|
|
"(%d %d %d)",
|
|
|
|
data->best_chan.freq_24, data->best_chan.freq_5,
|
|
|
|
data->best_chan.freq_overall);
|
2010-11-10 12:33:47 +01:00
|
|
|
wpa_s->best_24_freq = data->best_chan.freq_24;
|
|
|
|
wpa_s->best_5_freq = data->best_chan.freq_5;
|
|
|
|
wpa_s->best_overall_freq = data->best_chan.freq_overall;
|
|
|
|
wpas_p2p_update_best_channels(wpa_s, data->best_chan.freq_24,
|
|
|
|
data->best_chan.freq_5,
|
|
|
|
data->best_chan.freq_overall);
|
2010-10-15 17:55:22 +02:00
|
|
|
break;
|
2010-12-19 10:58:00 +01:00
|
|
|
case EVENT_UNPROT_DEAUTH:
|
|
|
|
wpa_supplicant_event_unprot_deauth(wpa_s,
|
|
|
|
&data->unprot_deauth);
|
|
|
|
break;
|
|
|
|
case EVENT_UNPROT_DISASSOC:
|
|
|
|
wpa_supplicant_event_unprot_disassoc(wpa_s,
|
|
|
|
&data->unprot_disassoc);
|
|
|
|
break;
|
2010-12-28 16:15:01 +01:00
|
|
|
case EVENT_STATION_LOW_ACK:
|
|
|
|
#ifdef CONFIG_AP
|
|
|
|
if (wpa_s->ap_iface && data)
|
|
|
|
hostapd_event_sta_low_ack(wpa_s->ap_iface->bss[0],
|
|
|
|
data->low_ack.addr);
|
|
|
|
#endif /* CONFIG_AP */
|
2011-09-26 12:55:30 +02:00
|
|
|
#ifdef CONFIG_TDLS
|
|
|
|
if (data)
|
2014-06-10 20:19:04 +02:00
|
|
|
wpa_tdls_disable_unreachable_link(wpa_s->wpa,
|
|
|
|
data->low_ack.addr);
|
2011-09-26 12:55:30 +02:00
|
|
|
#endif /* CONFIG_TDLS */
|
2010-12-28 16:15:01 +01:00
|
|
|
break;
|
2011-03-18 16:04:46 +01:00
|
|
|
case EVENT_IBSS_PEER_LOST:
|
|
|
|
#ifdef CONFIG_IBSS_RSN
|
|
|
|
ibss_rsn_stop(wpa_s->ibss_rsn, data->ibss_peer_lost.peer);
|
|
|
|
#endif /* CONFIG_IBSS_RSN */
|
|
|
|
break;
|
2011-07-12 20:22:51 +02:00
|
|
|
case EVENT_DRIVER_GTK_REKEY:
|
|
|
|
if (os_memcmp(data->driver_gtk_rekey.bssid,
|
|
|
|
wpa_s->bssid, ETH_ALEN))
|
|
|
|
break;
|
|
|
|
if (!wpa_s->wpa)
|
|
|
|
break;
|
|
|
|
wpa_sm_update_replay_ctr(wpa_s->wpa,
|
|
|
|
data->driver_gtk_rekey.replay_ctr);
|
|
|
|
break;
|
2011-09-27 21:21:29 +02:00
|
|
|
case EVENT_SCHED_SCAN_STOPPED:
|
|
|
|
wpa_s->sched_scanning = 0;
|
2016-03-03 10:04:38 +01:00
|
|
|
resched = wpa_s->scanning && wpas_scan_scheduled(wpa_s);
|
2011-09-27 21:21:29 +02:00
|
|
|
wpa_supplicant_notify_scanning(wpa_s, 0);
|
|
|
|
|
2011-12-21 12:36:58 +01:00
|
|
|
if (wpa_s->wpa_state == WPA_INTERFACE_DISABLED)
|
|
|
|
break;
|
|
|
|
|
2016-09-05 16:32:59 +02:00
|
|
|
/*
|
|
|
|
* If the driver stopped scanning without being requested to,
|
|
|
|
* request a new scan to continue scanning for networks.
|
|
|
|
*/
|
|
|
|
if (!wpa_s->sched_scan_stop_req &&
|
|
|
|
wpa_s->wpa_state == WPA_SCANNING) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"Restart scanning after unexpected sched_scan stop event");
|
|
|
|
wpa_supplicant_req_scan(wpa_s, 1, 0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
wpa_s->sched_scan_stop_req = 0;
|
|
|
|
|
2011-09-27 21:21:29 +02:00
|
|
|
/*
|
2014-01-22 15:15:23 +01:00
|
|
|
* Start a new sched scan to continue searching for more SSIDs
|
|
|
|
* either if timed out or PNO schedule scan is pending.
|
2011-09-27 21:21:29 +02:00
|
|
|
*/
|
2014-02-26 07:04:11 +01:00
|
|
|
if (wpa_s->sched_scan_timed_out) {
|
|
|
|
wpa_supplicant_req_sched_scan(wpa_s);
|
|
|
|
} else if (wpa_s->pno_sched_pending) {
|
|
|
|
wpa_s->pno_sched_pending = 0;
|
|
|
|
wpas_start_pno(wpa_s);
|
2015-03-30 22:44:11 +02:00
|
|
|
} else if (resched) {
|
|
|
|
wpa_supplicant_req_scan(wpa_s, 0, 0);
|
2014-01-22 15:15:23 +01:00
|
|
|
}
|
|
|
|
|
2011-09-27 21:21:29 +02:00
|
|
|
break;
|
2011-03-15 17:59:36 +01:00
|
|
|
case EVENT_WPS_BUTTON_PUSHED:
|
|
|
|
#ifdef CONFIG_WPS
|
2019-02-12 15:35:25 +01:00
|
|
|
wpas_wps_start_pbc(wpa_s, NULL, 0, 0);
|
2011-03-15 17:59:36 +01:00
|
|
|
#endif /* CONFIG_WPS */
|
|
|
|
break;
|
2014-01-24 15:14:29 +01:00
|
|
|
case EVENT_AVOID_FREQUENCIES:
|
|
|
|
wpa_supplicant_notify_avoid_freq(wpa_s, data);
|
|
|
|
break;
|
2013-02-07 14:24:53 +01:00
|
|
|
case EVENT_CONNECT_FAILED_REASON:
|
|
|
|
#ifdef CONFIG_AP
|
|
|
|
if (!wpa_s->ap_iface || !data)
|
|
|
|
break;
|
|
|
|
hostapd_event_connect_failed_reason(
|
|
|
|
wpa_s->ap_iface->bss[0],
|
|
|
|
data->connect_failed_reason.addr,
|
|
|
|
data->connect_failed_reason.code);
|
|
|
|
#endif /* CONFIG_AP */
|
|
|
|
break;
|
2014-09-01 06:23:21 +02:00
|
|
|
case EVENT_NEW_PEER_CANDIDATE:
|
2014-11-15 02:35:29 +01:00
|
|
|
#ifdef CONFIG_MESH
|
|
|
|
if (!wpa_s->ifmsh || !data)
|
|
|
|
break;
|
2014-09-01 06:23:21 +02:00
|
|
|
wpa_mesh_notify_peer(wpa_s, data->mesh_peer.peer,
|
|
|
|
data->mesh_peer.ies,
|
|
|
|
data->mesh_peer.ie_len);
|
2014-11-15 02:35:29 +01:00
|
|
|
#endif /* CONFIG_MESH */
|
2014-09-01 06:23:21 +02:00
|
|
|
break;
|
2015-11-27 12:40:36 +01:00
|
|
|
case EVENT_SURVEY:
|
|
|
|
#ifdef CONFIG_AP
|
|
|
|
if (!wpa_s->ap_iface)
|
|
|
|
break;
|
|
|
|
hostapd_event_get_survey(wpa_s->ap_iface,
|
|
|
|
&data->survey_results);
|
|
|
|
#endif /* CONFIG_AP */
|
|
|
|
break;
|
2015-11-27 12:40:37 +01:00
|
|
|
case EVENT_ACS_CHANNEL_SELECTED:
|
2017-01-28 10:57:23 +01:00
|
|
|
#ifdef CONFIG_AP
|
2015-11-27 12:40:37 +01:00
|
|
|
#ifdef CONFIG_ACS
|
|
|
|
if (!wpa_s->ap_iface)
|
|
|
|
break;
|
|
|
|
hostapd_acs_channel_selected(wpa_s->ap_iface->bss[0],
|
|
|
|
&data->acs_selected_channels);
|
|
|
|
#endif /* CONFIG_ACS */
|
2017-01-28 10:57:23 +01:00
|
|
|
#endif /* CONFIG_AP */
|
2015-11-27 12:40:37 +01:00
|
|
|
break;
|
2016-06-24 20:36:18 +02:00
|
|
|
case EVENT_P2P_LO_STOP:
|
|
|
|
#ifdef CONFIG_P2P
|
|
|
|
wpa_s->p2p_lo_started = 0;
|
|
|
|
wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_LISTEN_OFFLOAD_STOP
|
|
|
|
P2P_LISTEN_OFFLOAD_STOP_REASON "reason=%d",
|
|
|
|
data->p2p_lo_stop.reason_code);
|
|
|
|
#endif /* CONFIG_P2P */
|
|
|
|
break;
|
2017-01-08 11:17:58 +01:00
|
|
|
case EVENT_BEACON_LOSS:
|
|
|
|
if (!wpa_s->current_bss || !wpa_s->current_ssid)
|
|
|
|
break;
|
|
|
|
wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_BEACON_LOSS);
|
|
|
|
bgscan_notify_beacon_loss(wpa_s);
|
|
|
|
break;
|
2018-02-01 12:31:28 +01:00
|
|
|
case EVENT_EXTERNAL_AUTH:
|
|
|
|
#ifdef CONFIG_SAE
|
|
|
|
if (!wpa_s->current_ssid) {
|
|
|
|
wpa_printf(MSG_DEBUG, "SAE: current_ssid is NULL");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
sme_external_auth_trigger(wpa_s, data);
|
|
|
|
#endif /* CONFIG_SAE */
|
|
|
|
break;
|
2018-01-28 13:45:37 +01:00
|
|
|
case EVENT_PORT_AUTHORIZED:
|
|
|
|
wpa_supplicant_event_port_authorized(wpa_s);
|
|
|
|
break;
|
2018-03-09 13:49:09 +01:00
|
|
|
case EVENT_STATION_OPMODE_CHANGED:
|
|
|
|
#ifdef CONFIG_AP
|
|
|
|
if (!wpa_s->ap_iface || !data)
|
|
|
|
break;
|
|
|
|
|
|
|
|
hostapd_event_sta_opmode_changed(wpa_s->ap_iface->bss[0],
|
|
|
|
data->sta_opmode.addr,
|
|
|
|
data->sta_opmode.smps_mode,
|
|
|
|
data->sta_opmode.chan_width,
|
|
|
|
data->sta_opmode.rx_nss);
|
|
|
|
#endif /* CONFIG_AP */
|
|
|
|
break;
|
2020-04-01 15:07:25 +02:00
|
|
|
case EVENT_UNPROT_BEACON:
|
|
|
|
wpas_event_unprot_beacon(wpa_s, &data->unprot_beacon);
|
|
|
|
break;
|
2008-02-28 02:34:43 +01:00
|
|
|
default:
|
2011-02-10 19:14:46 +01:00
|
|
|
wpa_msg(wpa_s, MSG_INFO, "Unknown event %d", event);
|
2008-02-28 02:34:43 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-03-15 14:02:08 +01:00
|
|
|
|
|
|
|
|
|
|
|
void wpa_supplicant_event_global(void *ctx, enum wpa_event_type event,
|
|
|
|
union wpa_event_data *data)
|
|
|
|
{
|
|
|
|
struct wpa_supplicant *wpa_s;
|
|
|
|
|
|
|
|
if (event != EVENT_INTERFACE_STATUS)
|
|
|
|
return;
|
|
|
|
|
|
|
|
wpa_s = wpa_supplicant_get_iface(ctx, data->interface_status.ifname);
|
|
|
|
if (wpa_s && wpa_s->driver->get_ifindex) {
|
|
|
|
unsigned int ifindex;
|
|
|
|
|
|
|
|
ifindex = wpa_s->driver->get_ifindex(wpa_s->drv_priv);
|
|
|
|
if (ifindex != data->interface_status.ifindex) {
|
|
|
|
wpa_dbg(wpa_s, MSG_DEBUG,
|
|
|
|
"interface status ifindex %d mismatch (%d)",
|
|
|
|
ifindex, data->interface_status.ifindex);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2016-03-15 14:40:14 +01:00
|
|
|
#ifdef CONFIG_MATCH_IFACE
|
|
|
|
else if (data->interface_status.ievent == EVENT_INTERFACE_ADDED) {
|
|
|
|
struct wpa_interface *wpa_i;
|
|
|
|
|
|
|
|
wpa_i = wpa_supplicant_match_iface(
|
|
|
|
ctx, data->interface_status.ifname);
|
|
|
|
if (!wpa_i)
|
|
|
|
return;
|
|
|
|
wpa_s = wpa_supplicant_add_iface(ctx, wpa_i, NULL);
|
|
|
|
os_free(wpa_i);
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_MATCH_IFACE */
|
2016-03-15 14:02:08 +01:00
|
|
|
|
|
|
|
if (wpa_s)
|
|
|
|
wpa_supplicant_event(wpa_s, event, data);
|
|
|
|
}
|