2009-01-09 16:27:03 +01:00
|
|
|
/*
|
|
|
|
|
* hostapd / Callback functions for driver wrappers
|
2013-09-01 10:05:19 +02:00
|
|
|
* Copyright (c) 2002-2013, Jouni Malinen <j@w1.fi>
|
2009-01-09 16:27:03 +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.
|
2009-01-09 16:27:03 +01:00
|
|
|
*/
|
|
|
|
|
|
2009-12-25 23:05:40 +01:00
|
|
|
#include "utils/includes.h"
|
2009-01-09 16:27:03 +01:00
|
|
|
|
2009-12-25 23:05:40 +01:00
|
|
|
#include "utils/common.h"
|
2014-04-14 19:40:56 +02:00
|
|
|
#include "utils/eloop.h"
|
2009-01-09 16:27:03 +01:00
|
|
|
#include "radius/radius.h"
|
2009-12-25 23:21:22 +01:00
|
|
|
#include "drivers/driver.h"
|
2009-12-25 23:31:51 +01:00
|
|
|
#include "common/ieee802_11_defs.h"
|
2010-04-03 20:03:13 +02:00
|
|
|
#include "common/ieee802_11_common.h"
|
2013-02-07 14:24:53 +01:00
|
|
|
#include "common/wpa_ctrl.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"
|
2010-07-18 23:30:25 +02:00
|
|
|
#include "p2p/p2p.h"
|
2010-05-26 16:16:14 +02:00
|
|
|
#include "wps/wps.h"
|
2015-01-21 14:30:48 +01:00
|
|
|
#include "fst/fst.h"
|
2012-02-26 16:25:55 +01:00
|
|
|
#include "wnm_ap.h"
|
2009-12-25 23:05:40 +01:00
|
|
|
#include "hostapd.h"
|
|
|
|
|
#include "ieee802_11.h"
|
2015-10-22 18:48:04 +02:00
|
|
|
#include "ieee802_11_auth.h"
|
2009-12-25 23:05:40 +01:00
|
|
|
#include "sta_info.h"
|
|
|
|
|
#include "accounting.h"
|
|
|
|
|
#include "tkip_countermeasures.h"
|
|
|
|
|
#include "ieee802_1x.h"
|
|
|
|
|
#include "wpa_auth.h"
|
|
|
|
|
#include "wps_hostapd.h"
|
2010-11-24 14:36:02 +01:00
|
|
|
#include "ap_drv_ops.h"
|
2009-12-25 23:12:25 +01:00
|
|
|
#include "ap_config.h"
|
2012-06-25 13:45:14 +02:00
|
|
|
#include "hw_features.h"
|
2013-10-15 19:27:25 +02:00
|
|
|
#include "dfs.h"
|
2014-04-14 19:40:56 +02:00
|
|
|
#include "beacon.h"
|
2016-02-22 12:03:28 +01:00
|
|
|
#include "mbo_ap.h"
|
2009-01-09 16:27:03 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
|
int hostapd_notif_assoc(struct hostapd_data *hapd, const u8 *addr,
|
2011-10-16 16:49:02 +02:00
|
|
|
const u8 *req_ies, size_t req_ies_len, int reassoc)
|
2009-01-09 16:27:03 +01:00
|
|
|
{
|
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
int new_assoc, res;
|
2010-04-03 20:03:13 +02:00
|
|
|
struct ieee802_11_elems elems;
|
2011-10-16 16:49:02 +02:00
|
|
|
const u8 *ie;
|
|
|
|
|
size_t ielen;
|
2016-10-27 14:18:32 +02:00
|
|
|
#if defined(CONFIG_IEEE80211R_AP) || defined(CONFIG_IEEE80211W)
|
2010-10-25 13:30:04 +02:00
|
|
|
u8 buf[sizeof(struct ieee80211_mgmt) + 1024];
|
|
|
|
|
u8 *p = buf;
|
2016-10-27 14:18:32 +02:00
|
|
|
#endif /* CONFIG_IEEE80211R_AP || CONFIG_IEEE80211W */
|
2011-10-16 16:57:27 +02:00
|
|
|
u16 reason = WLAN_REASON_UNSPECIFIED;
|
2010-10-25 13:30:04 +02:00
|
|
|
u16 status = WLAN_STATUS_SUCCESS;
|
2013-09-01 10:05:19 +02:00
|
|
|
const u8 *p2p_dev_addr = NULL;
|
2009-01-09 16:27:03 +01:00
|
|
|
|
2010-04-07 09:01:49 +02:00
|
|
|
if (addr == NULL) {
|
|
|
|
|
/*
|
|
|
|
|
* This could potentially happen with unexpected event from the
|
|
|
|
|
* driver wrapper. This was seen at least in one case where the
|
|
|
|
|
* driver ended up being set to station mode while hostapd was
|
|
|
|
|
* running, so better make sure we stop processing such an
|
|
|
|
|
* event here.
|
|
|
|
|
*/
|
2015-07-22 18:56:04 +02:00
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
|
"hostapd_notif_assoc: Skip event with no address");
|
2010-04-07 09:01:49 +02:00
|
|
|
return -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(addr, ETH_ALEN);
|
2010-04-07 09:01:49 +02:00
|
|
|
|
2009-01-09 16:27:03 +01:00
|
|
|
hostapd_logger(hapd, addr, HOSTAPD_MODULE_IEEE80211,
|
|
|
|
|
HOSTAPD_LEVEL_INFO, "associated");
|
|
|
|
|
|
2011-10-16 16:49:02 +02:00
|
|
|
ieee802_11_parse_elems(req_ies, req_ies_len, &elems, 0);
|
2010-04-03 20:03:13 +02:00
|
|
|
if (elems.wps_ie) {
|
|
|
|
|
ie = elems.wps_ie - 2;
|
|
|
|
|
ielen = elems.wps_ie_len + 2;
|
|
|
|
|
wpa_printf(MSG_DEBUG, "STA included WPS IE in (Re)AssocReq");
|
|
|
|
|
} else if (elems.rsn_ie) {
|
|
|
|
|
ie = elems.rsn_ie - 2;
|
|
|
|
|
ielen = elems.rsn_ie_len + 2;
|
|
|
|
|
wpa_printf(MSG_DEBUG, "STA included RSN IE in (Re)AssocReq");
|
|
|
|
|
} else if (elems.wpa_ie) {
|
|
|
|
|
ie = elems.wpa_ie - 2;
|
|
|
|
|
ielen = elems.wpa_ie_len + 2;
|
|
|
|
|
wpa_printf(MSG_DEBUG, "STA included WPA IE in (Re)AssocReq");
|
2013-07-23 20:25:21 +02:00
|
|
|
#ifdef CONFIG_HS20
|
|
|
|
|
} else if (elems.osen) {
|
|
|
|
|
ie = elems.osen - 2;
|
|
|
|
|
ielen = elems.osen_len + 2;
|
|
|
|
|
wpa_printf(MSG_DEBUG, "STA included OSEN IE in (Re)AssocReq");
|
|
|
|
|
#endif /* CONFIG_HS20 */
|
2010-04-03 20:03:13 +02:00
|
|
|
} else {
|
|
|
|
|
ie = NULL;
|
|
|
|
|
ielen = 0;
|
2015-07-22 18:56:04 +02:00
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
|
"STA did not include WPS/RSN/WPA IE in (Re)AssocReq");
|
2010-04-03 20:03:13 +02:00
|
|
|
}
|
|
|
|
|
|
2009-01-09 16:27:03 +01:00
|
|
|
sta = ap_get_sta(hapd, addr);
|
|
|
|
|
if (sta) {
|
2013-06-18 16:40:51 +02:00
|
|
|
ap_sta_no_session_timeout(hapd, sta);
|
2009-01-09 16:27:03 +01:00
|
|
|
accounting_sta_stop(hapd, sta);
|
2012-04-11 13:06:50 +02:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Make sure that the previously registered inactivity timer
|
|
|
|
|
* will not remove the STA immediately.
|
|
|
|
|
*/
|
|
|
|
|
sta->timeout_next = STA_NULLFUNC;
|
2009-01-09 16:27:03 +01:00
|
|
|
} else {
|
|
|
|
|
sta = ap_sta_add(hapd, addr);
|
2012-05-28 06:21:37 +02:00
|
|
|
if (sta == NULL) {
|
|
|
|
|
hostapd_drv_sta_disassoc(hapd, addr,
|
|
|
|
|
WLAN_REASON_DISASSOC_AP_BUSY);
|
2009-01-09 16:27:03 +01:00
|
|
|
return -1;
|
2012-05-28 06:21:37 +02:00
|
|
|
}
|
2009-01-09 16:27:03 +01:00
|
|
|
}
|
2011-08-28 18:16:59 +02:00
|
|
|
sta->flags &= ~(WLAN_STA_WPS | WLAN_STA_MAYBE_WPS | WLAN_STA_WPS2);
|
2009-01-09 16:27:03 +01:00
|
|
|
|
2016-01-14 13:55:57 +01:00
|
|
|
/*
|
|
|
|
|
* ACL configurations to the drivers (implementing AP SME and ACL
|
|
|
|
|
* offload) without hostapd's knowledge, can result in a disconnection
|
|
|
|
|
* though the driver accepts the connection. Skip the hostapd check for
|
|
|
|
|
* ACL if the driver supports ACL offload to avoid potentially
|
|
|
|
|
* conflicting ACL rules.
|
|
|
|
|
*/
|
|
|
|
|
if (hapd->iface->drv_max_acl_mac_addrs == 0 &&
|
|
|
|
|
hostapd_check_acl(hapd, addr, NULL) != HOSTAPD_ACL_ACCEPT) {
|
2015-10-22 18:48:04 +02:00
|
|
|
wpa_printf(MSG_INFO, "STA " MACSTR " not allowed to connect",
|
|
|
|
|
MAC2STR(addr));
|
|
|
|
|
reason = WLAN_REASON_UNSPECIFIED;
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
|
|
|
|
|
2010-07-18 23:30:25 +02:00
|
|
|
#ifdef CONFIG_P2P
|
|
|
|
|
if (elems.p2p) {
|
|
|
|
|
wpabuf_free(sta->p2p_ie);
|
2011-10-16 16:49:02 +02:00
|
|
|
sta->p2p_ie = ieee802_11_vendor_ie_concat(req_ies, req_ies_len,
|
2010-07-18 23:30:25 +02:00
|
|
|
P2P_IE_VENDOR_TYPE);
|
2013-09-01 10:05:19 +02:00
|
|
|
if (sta->p2p_ie)
|
|
|
|
|
p2p_dev_addr = p2p_get_go_dev_addr(sta->p2p_ie);
|
2010-07-18 23:30:25 +02:00
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_P2P */
|
|
|
|
|
|
2014-04-14 19:40:56 +02:00
|
|
|
#ifdef CONFIG_IEEE80211N
|
|
|
|
|
#ifdef NEED_AP_MLME
|
|
|
|
|
if (elems.ht_capabilities &&
|
|
|
|
|
(hapd->iface->conf->ht_capab &
|
|
|
|
|
HT_CAP_INFO_SUPP_CHANNEL_WIDTH_SET)) {
|
|
|
|
|
struct ieee80211_ht_capabilities *ht_cap =
|
|
|
|
|
(struct ieee80211_ht_capabilities *)
|
|
|
|
|
elems.ht_capabilities;
|
|
|
|
|
|
|
|
|
|
if (le_to_host16(ht_cap->ht_capabilities_info) &
|
|
|
|
|
HT_CAP_INFO_40MHZ_INTOLERANT)
|
|
|
|
|
ht40_intolerant_add(hapd->iface, sta);
|
|
|
|
|
}
|
|
|
|
|
#endif /* NEED_AP_MLME */
|
|
|
|
|
#endif /* CONFIG_IEEE80211N */
|
|
|
|
|
|
2013-07-24 11:28:20 +02:00
|
|
|
#ifdef CONFIG_INTERWORKING
|
|
|
|
|
if (elems.ext_capab && elems.ext_capab_len > 4) {
|
|
|
|
|
if (elems.ext_capab[4] & 0x01)
|
|
|
|
|
sta->qos_map_enabled = 1;
|
|
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_INTERWORKING */
|
|
|
|
|
|
2012-11-21 23:19:17 +01:00
|
|
|
#ifdef CONFIG_HS20
|
|
|
|
|
wpabuf_free(sta->hs20_ie);
|
|
|
|
|
if (elems.hs20 && elems.hs20_len > 4) {
|
|
|
|
|
sta->hs20_ie = wpabuf_alloc_copy(elems.hs20 + 4,
|
|
|
|
|
elems.hs20_len - 4);
|
|
|
|
|
} else
|
|
|
|
|
sta->hs20_ie = NULL;
|
|
|
|
|
#endif /* CONFIG_HS20 */
|
|
|
|
|
|
2015-01-21 14:30:48 +01:00
|
|
|
#ifdef CONFIG_FST
|
|
|
|
|
wpabuf_free(sta->mb_ies);
|
|
|
|
|
if (hapd->iface->fst)
|
|
|
|
|
sta->mb_ies = mb_ies_by_info(&elems.mb_ies);
|
|
|
|
|
else
|
|
|
|
|
sta->mb_ies = NULL;
|
|
|
|
|
#endif /* CONFIG_FST */
|
|
|
|
|
|
2016-02-22 12:03:28 +01:00
|
|
|
mbo_ap_check_sta_assoc(hapd, sta, &elems);
|
|
|
|
|
|
2016-02-24 11:20:31 +01:00
|
|
|
ap_copy_sta_supp_op_classes(sta, elems.supp_op_classes,
|
|
|
|
|
elems.supp_op_classes_len);
|
|
|
|
|
|
2009-01-09 16:27:03 +01:00
|
|
|
if (hapd->conf->wpa) {
|
|
|
|
|
if (ie == NULL || ielen == 0) {
|
2011-09-12 21:23:45 +02:00
|
|
|
#ifdef CONFIG_WPS
|
2009-01-09 16:27:03 +01:00
|
|
|
if (hapd->conf->wps_state) {
|
2015-07-22 18:56:04 +02:00
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
|
"STA did not include WPA/RSN IE in (Re)Association Request - possible WPS use");
|
2009-01-09 16:27:03 +01:00
|
|
|
sta->flags |= WLAN_STA_MAYBE_WPS;
|
|
|
|
|
goto skip_wpa_check;
|
|
|
|
|
}
|
2011-09-12 21:23:45 +02:00
|
|
|
#endif /* CONFIG_WPS */
|
2009-01-09 16:27:03 +01:00
|
|
|
|
|
|
|
|
wpa_printf(MSG_DEBUG, "No WPA/RSN IE from STA");
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2011-09-12 21:23:45 +02:00
|
|
|
#ifdef CONFIG_WPS
|
2009-01-09 16:27:03 +01:00
|
|
|
if (hapd->conf->wps_state && ie[0] == 0xdd && ie[1] >= 4 &&
|
|
|
|
|
os_memcmp(ie + 2, "\x00\x50\xf2\x04", 4) == 0) {
|
2011-08-28 18:16:59 +02:00
|
|
|
struct wpabuf *wps;
|
2015-07-22 18:56:04 +02:00
|
|
|
|
2009-01-09 16:27:03 +01:00
|
|
|
sta->flags |= WLAN_STA_WPS;
|
2011-08-28 18:16:59 +02:00
|
|
|
wps = ieee802_11_vendor_ie_concat(ie, ielen,
|
|
|
|
|
WPS_IE_VENDOR_TYPE);
|
|
|
|
|
if (wps) {
|
|
|
|
|
if (wps_is_20(wps)) {
|
2015-07-22 18:56:04 +02:00
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
|
"WPS: STA supports WPS 2.0");
|
2011-08-28 18:16:59 +02:00
|
|
|
sta->flags |= WLAN_STA_WPS2;
|
|
|
|
|
}
|
|
|
|
|
wpabuf_free(wps);
|
|
|
|
|
}
|
2009-01-09 16:27:03 +01:00
|
|
|
goto skip_wpa_check;
|
|
|
|
|
}
|
2011-09-12 21:23:45 +02:00
|
|
|
#endif /* CONFIG_WPS */
|
2009-01-09 16:27:03 +01:00
|
|
|
|
|
|
|
|
if (sta->wpa_sm == NULL)
|
|
|
|
|
sta->wpa_sm = wpa_auth_sta_init(hapd->wpa_auth,
|
2013-09-01 10:05:19 +02:00
|
|
|
sta->addr,
|
|
|
|
|
p2p_dev_addr);
|
2009-01-09 16:27:03 +01:00
|
|
|
if (sta->wpa_sm == NULL) {
|
2015-07-22 18:56:04 +02:00
|
|
|
wpa_printf(MSG_ERROR,
|
|
|
|
|
"Failed to initialize WPA state machine");
|
2009-01-09 16:27:03 +01:00
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
res = wpa_validate_wpa_ie(hapd->wpa_auth, sta->wpa_sm,
|
2010-10-25 13:30:04 +02:00
|
|
|
ie, ielen,
|
|
|
|
|
elems.mdie, elems.mdie_len);
|
2009-01-09 16:27:03 +01:00
|
|
|
if (res != WPA_IE_OK) {
|
2015-07-22 18:56:04 +02:00
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
|
"WPA/RSN information element rejected? (res %u)",
|
|
|
|
|
res);
|
2009-01-09 16:27:03 +01:00
|
|
|
wpa_hexdump(MSG_DEBUG, "IE", ie, ielen);
|
2010-10-25 13:30:04 +02:00
|
|
|
if (res == WPA_INVALID_GROUP) {
|
2011-10-16 16:57:27 +02:00
|
|
|
reason = WLAN_REASON_GROUP_CIPHER_NOT_VALID;
|
2010-10-25 13:30:04 +02:00
|
|
|
status = WLAN_STATUS_GROUP_CIPHER_NOT_VALID;
|
|
|
|
|
} else if (res == WPA_INVALID_PAIRWISE) {
|
2011-10-16 16:57:27 +02:00
|
|
|
reason = WLAN_REASON_PAIRWISE_CIPHER_NOT_VALID;
|
2010-10-25 13:30:04 +02:00
|
|
|
status = WLAN_STATUS_PAIRWISE_CIPHER_NOT_VALID;
|
|
|
|
|
} else if (res == WPA_INVALID_AKMP) {
|
2011-10-16 16:57:27 +02:00
|
|
|
reason = WLAN_REASON_AKMP_NOT_VALID;
|
2010-10-25 13:30:04 +02:00
|
|
|
status = WLAN_STATUS_AKMP_NOT_VALID;
|
|
|
|
|
}
|
2009-11-11 16:33:55 +01:00
|
|
|
#ifdef CONFIG_IEEE80211W
|
2010-10-25 13:30:04 +02:00
|
|
|
else if (res == WPA_MGMT_FRAME_PROTECTION_VIOLATION) {
|
2011-10-16 16:57:27 +02:00
|
|
|
reason = WLAN_REASON_INVALID_IE;
|
2010-10-25 13:30:04 +02:00
|
|
|
status = WLAN_STATUS_INVALID_IE;
|
|
|
|
|
} else if (res == WPA_INVALID_MGMT_GROUP_CIPHER) {
|
2011-10-16 16:57:27 +02:00
|
|
|
reason = WLAN_REASON_GROUP_CIPHER_NOT_VALID;
|
2010-10-25 13:30:04 +02:00
|
|
|
status = WLAN_STATUS_GROUP_CIPHER_NOT_VALID;
|
|
|
|
|
}
|
2009-11-11 16:33:55 +01:00
|
|
|
#endif /* CONFIG_IEEE80211W */
|
2010-10-25 13:30:04 +02:00
|
|
|
else {
|
2011-10-16 16:57:27 +02:00
|
|
|
reason = WLAN_REASON_INVALID_IE;
|
2010-10-25 13:30:04 +02:00
|
|
|
status = WLAN_STATUS_INVALID_IE;
|
|
|
|
|
}
|
2011-10-16 16:57:27 +02:00
|
|
|
goto fail;
|
2009-01-09 16:27:03 +01:00
|
|
|
}
|
2011-08-22 23:35:26 +02:00
|
|
|
#ifdef CONFIG_IEEE80211W
|
|
|
|
|
if ((sta->flags & WLAN_STA_MFP) && !sta->sa_query_timed_out &&
|
|
|
|
|
sta->sa_query_count > 0)
|
|
|
|
|
ap_check_sa_query_timeout(hapd, sta);
|
|
|
|
|
if ((sta->flags & WLAN_STA_MFP) && !sta->sa_query_timed_out &&
|
|
|
|
|
(sta->auth_alg != WLAN_AUTH_FT)) {
|
|
|
|
|
/*
|
|
|
|
|
* STA has already been associated with MFP and SA
|
|
|
|
|
* Query timeout has not been reached. Reject the
|
|
|
|
|
* association attempt temporarily and start SA Query,
|
|
|
|
|
* if one is not pending.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
if (sta->sa_query_count == 0)
|
|
|
|
|
ap_sta_start_sa_query(hapd, sta);
|
|
|
|
|
|
|
|
|
|
status = WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY;
|
|
|
|
|
|
|
|
|
|
p = hostapd_eid_assoc_comeback_time(hapd, sta, p);
|
|
|
|
|
|
|
|
|
|
hostapd_sta_assoc(hapd, addr, reassoc, status, buf,
|
|
|
|
|
p - buf);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (wpa_auth_uses_mfp(sta->wpa_sm))
|
|
|
|
|
sta->flags |= WLAN_STA_MFP;
|
|
|
|
|
else
|
|
|
|
|
sta->flags &= ~WLAN_STA_MFP;
|
|
|
|
|
#endif /* CONFIG_IEEE80211W */
|
|
|
|
|
|
2016-10-27 14:18:32 +02:00
|
|
|
#ifdef CONFIG_IEEE80211R_AP
|
2010-10-25 13:30:04 +02:00
|
|
|
if (sta->auth_alg == WLAN_AUTH_FT) {
|
|
|
|
|
status = wpa_ft_validate_reassoc(sta->wpa_sm, req_ies,
|
|
|
|
|
req_ies_len);
|
|
|
|
|
if (status != WLAN_STATUS_SUCCESS) {
|
|
|
|
|
if (status == WLAN_STATUS_INVALID_PMKID)
|
|
|
|
|
reason = WLAN_REASON_INVALID_IE;
|
|
|
|
|
if (status == WLAN_STATUS_INVALID_MDIE)
|
|
|
|
|
reason = WLAN_REASON_INVALID_IE;
|
|
|
|
|
if (status == WLAN_STATUS_INVALID_FTIE)
|
|
|
|
|
reason = WLAN_REASON_INVALID_IE;
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-10-27 14:18:32 +02:00
|
|
|
#endif /* CONFIG_IEEE80211R_AP */
|
2009-02-23 19:57:07 +01:00
|
|
|
} else if (hapd->conf->wps_state) {
|
2011-09-12 21:23:45 +02:00
|
|
|
#ifdef CONFIG_WPS
|
2011-08-28 18:16:59 +02:00
|
|
|
struct wpabuf *wps;
|
2015-07-22 18:56:04 +02:00
|
|
|
|
2011-10-16 16:49:02 +02:00
|
|
|
if (req_ies)
|
|
|
|
|
wps = ieee802_11_vendor_ie_concat(req_ies, req_ies_len,
|
2011-10-16 15:41:51 +02:00
|
|
|
WPS_IE_VENDOR_TYPE);
|
|
|
|
|
else
|
|
|
|
|
wps = NULL;
|
2010-05-26 16:16:14 +02:00
|
|
|
#ifdef CONFIG_WPS_STRICT
|
2011-10-16 15:41:51 +02:00
|
|
|
if (wps && wps_validate_assoc_req(wps) < 0) {
|
2011-10-16 16:57:27 +02:00
|
|
|
reason = WLAN_REASON_INVALID_IE;
|
2010-10-25 13:30:04 +02:00
|
|
|
status = WLAN_STATUS_INVALID_IE;
|
2011-10-16 15:41:51 +02:00
|
|
|
wpabuf_free(wps);
|
2011-10-16 16:57:27 +02:00
|
|
|
goto fail;
|
2010-05-26 16:16:14 +02:00
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_WPS_STRICT */
|
2011-10-16 15:41:51 +02:00
|
|
|
if (wps) {
|
2009-02-23 19:57:07 +01:00
|
|
|
sta->flags |= WLAN_STA_WPS;
|
2011-10-16 15:41:51 +02:00
|
|
|
if (wps_is_20(wps)) {
|
2015-07-22 18:56:04 +02:00
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
|
"WPS: STA supports WPS 2.0");
|
2011-08-28 18:16:59 +02:00
|
|
|
sta->flags |= WLAN_STA_WPS2;
|
|
|
|
|
}
|
2009-02-23 19:57:07 +01:00
|
|
|
} else
|
|
|
|
|
sta->flags |= WLAN_STA_MAYBE_WPS;
|
2011-08-28 18:16:59 +02:00
|
|
|
wpabuf_free(wps);
|
2011-09-12 21:23:45 +02:00
|
|
|
#endif /* CONFIG_WPS */
|
2013-07-23 20:25:21 +02:00
|
|
|
#ifdef CONFIG_HS20
|
|
|
|
|
} else if (hapd->conf->osen) {
|
|
|
|
|
if (elems.osen == NULL) {
|
|
|
|
|
hostapd_logger(
|
|
|
|
|
hapd, sta->addr, HOSTAPD_MODULE_IEEE80211,
|
|
|
|
|
HOSTAPD_LEVEL_INFO,
|
|
|
|
|
"No HS 2.0 OSEN element in association request");
|
|
|
|
|
return WLAN_STATUS_INVALID_IE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
wpa_printf(MSG_DEBUG, "HS 2.0: OSEN association");
|
|
|
|
|
if (sta->wpa_sm == NULL)
|
|
|
|
|
sta->wpa_sm = wpa_auth_sta_init(hapd->wpa_auth,
|
|
|
|
|
sta->addr, NULL);
|
|
|
|
|
if (sta->wpa_sm == NULL) {
|
2015-07-22 18:56:04 +02:00
|
|
|
wpa_printf(MSG_WARNING,
|
|
|
|
|
"Failed to initialize WPA state machine");
|
2013-07-23 20:25:21 +02:00
|
|
|
return WLAN_STATUS_UNSPECIFIED_FAILURE;
|
|
|
|
|
}
|
|
|
|
|
if (wpa_validate_osen(hapd->wpa_auth, sta->wpa_sm,
|
|
|
|
|
elems.osen - 2, elems.osen_len + 2) < 0)
|
|
|
|
|
return WLAN_STATUS_INVALID_IE;
|
|
|
|
|
#endif /* CONFIG_HS20 */
|
2009-01-09 16:27:03 +01:00
|
|
|
}
|
2016-02-22 15:39:24 +01:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_MBO
|
|
|
|
|
if (hapd->conf->mbo_enabled && (hapd->conf->wpa & 2) &&
|
|
|
|
|
elems.mbo && sta->cell_capa && !(sta->flags & WLAN_STA_MFP) &&
|
|
|
|
|
hapd->conf->ieee80211w != NO_MGMT_FRAME_PROTECTION) {
|
|
|
|
|
wpa_printf(MSG_INFO,
|
|
|
|
|
"MBO: Reject WPA2 association without PMF");
|
|
|
|
|
return WLAN_STATUS_UNSPECIFIED_FAILURE;
|
|
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_MBO */
|
|
|
|
|
|
2011-09-12 21:23:45 +02:00
|
|
|
#ifdef CONFIG_WPS
|
2009-01-09 16:27:03 +01:00
|
|
|
skip_wpa_check:
|
2011-09-12 21:23:45 +02:00
|
|
|
#endif /* CONFIG_WPS */
|
2009-01-09 16:27:03 +01:00
|
|
|
|
2016-10-27 14:18:32 +02:00
|
|
|
#ifdef CONFIG_IEEE80211R_AP
|
2010-10-25 13:30:04 +02:00
|
|
|
p = wpa_sm_write_assoc_resp_ies(sta->wpa_sm, buf, sizeof(buf),
|
|
|
|
|
sta->auth_alg, req_ies, req_ies_len);
|
|
|
|
|
|
|
|
|
|
hostapd_sta_assoc(hapd, addr, reassoc, status, buf, p - buf);
|
2014-09-12 17:46:56 +02:00
|
|
|
|
|
|
|
|
if (sta->auth_alg == WLAN_AUTH_FT)
|
|
|
|
|
ap_sta_set_authorized(hapd, sta, 1);
|
2016-10-27 14:18:32 +02:00
|
|
|
#else /* CONFIG_IEEE80211R_AP */
|
2010-10-25 13:30:04 +02:00
|
|
|
/* Keep compiler silent about unused variables */
|
|
|
|
|
if (status) {
|
|
|
|
|
}
|
2016-10-27 14:18:32 +02:00
|
|
|
#endif /* CONFIG_IEEE80211R_AP */
|
2010-10-25 13:30:04 +02:00
|
|
|
|
2009-01-09 16:27:03 +01:00
|
|
|
new_assoc = (sta->flags & WLAN_STA_ASSOC) == 0;
|
|
|
|
|
sta->flags |= WLAN_STA_AUTH | WLAN_STA_ASSOC;
|
2013-12-27 18:06:52 +01:00
|
|
|
sta->flags &= ~WLAN_STA_WNM_SLEEP_MODE;
|
2010-10-25 13:30:04 +02:00
|
|
|
|
2014-09-12 17:46:56 +02:00
|
|
|
hostapd_set_sta_flags(hapd, sta);
|
|
|
|
|
|
2010-10-25 13:30:04 +02:00
|
|
|
if (reassoc && (sta->auth_alg == WLAN_AUTH_FT))
|
|
|
|
|
wpa_auth_sm_event(sta->wpa_sm, WPA_ASSOC_FT);
|
|
|
|
|
else
|
|
|
|
|
wpa_auth_sm_event(sta->wpa_sm, WPA_ASSOC);
|
2009-01-09 16:27:03 +01:00
|
|
|
|
|
|
|
|
hostapd_new_assoc_sta(hapd, sta, !new_assoc);
|
|
|
|
|
|
|
|
|
|
ieee802_1x_notify_port_enabled(sta->eapol_sm, 1);
|
|
|
|
|
|
2010-07-18 23:30:25 +02:00
|
|
|
#ifdef CONFIG_P2P
|
2011-11-13 21:33:32 +01:00
|
|
|
if (req_ies) {
|
|
|
|
|
p2p_group_notif_assoc(hapd->p2p_group, sta->addr,
|
|
|
|
|
req_ies, req_ies_len);
|
|
|
|
|
}
|
2010-07-18 23:30:25 +02:00
|
|
|
#endif /* CONFIG_P2P */
|
|
|
|
|
|
2009-01-09 16:27:03 +01:00
|
|
|
return 0;
|
2011-10-16 16:57:27 +02:00
|
|
|
|
|
|
|
|
fail:
|
2016-10-27 14:18:32 +02:00
|
|
|
#ifdef CONFIG_IEEE80211R_AP
|
2010-10-25 13:30:04 +02:00
|
|
|
hostapd_sta_assoc(hapd, addr, reassoc, status, buf, p - buf);
|
2016-10-27 14:18:32 +02:00
|
|
|
#endif /* CONFIG_IEEE80211R_AP */
|
2011-10-16 16:57:27 +02:00
|
|
|
hostapd_drv_sta_disassoc(hapd, sta->addr, reason);
|
|
|
|
|
ap_free_sta(hapd, sta);
|
|
|
|
|
return -1;
|
2009-01-09 16:27:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void hostapd_notif_disassoc(struct hostapd_data *hapd, const u8 *addr)
|
|
|
|
|
{
|
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
|
2010-10-22 16:43:23 +02:00
|
|
|
if (addr == NULL) {
|
|
|
|
|
/*
|
|
|
|
|
* This could potentially happen with unexpected event from the
|
|
|
|
|
* driver wrapper. This was seen at least in one case where the
|
|
|
|
|
* driver ended up reporting a station mode event while hostapd
|
|
|
|
|
* was running, so better make sure we stop processing such an
|
|
|
|
|
* event here.
|
|
|
|
|
*/
|
2015-07-22 18:56:04 +02:00
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
|
"hostapd_notif_disassoc: Skip event with no address");
|
2010-10-25 12:38:06 +02:00
|
|
|
return;
|
2010-10-22 16:43:23 +02:00
|
|
|
}
|
|
|
|
|
|
2009-01-09 16:27:03 +01:00
|
|
|
hostapd_logger(hapd, addr, HOSTAPD_MODULE_IEEE80211,
|
|
|
|
|
HOSTAPD_LEVEL_INFO, "disassociated");
|
|
|
|
|
|
|
|
|
|
sta = ap_get_sta(hapd, addr);
|
|
|
|
|
if (sta == NULL) {
|
2015-07-22 18:56:04 +02:00
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
|
"Disassociation notification for unknown STA "
|
|
|
|
|
MACSTR, MAC2STR(addr));
|
2009-01-09 16:27:03 +01:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-03 21:17:41 +01:00
|
|
|
ap_sta_set_authorized(hapd, sta, 0);
|
2009-01-09 16:27:03 +01:00
|
|
|
sta->flags &= ~(WLAN_STA_AUTH | WLAN_STA_ASSOC);
|
|
|
|
|
wpa_auth_sm_event(sta->wpa_sm, WPA_DISASSOC);
|
|
|
|
|
sta->acct_terminate_cause = RADIUS_ACCT_TERMINATE_CAUSE_USER_REQUEST;
|
|
|
|
|
ieee802_1x_notify_port_enabled(sta->eapol_sm, 0);
|
|
|
|
|
ap_free_sta(hapd, sta);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2010-12-28 16:15:01 +01:00
|
|
|
void hostapd_event_sta_low_ack(struct hostapd_data *hapd, const u8 *addr)
|
|
|
|
|
{
|
|
|
|
|
struct sta_info *sta = ap_get_sta(hapd, addr);
|
|
|
|
|
|
|
|
|
|
if (!sta || !hapd->conf->disassoc_low_ack)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
hostapd_logger(hapd, addr, HOSTAPD_MODULE_IEEE80211,
|
2015-07-22 18:56:04 +02:00
|
|
|
HOSTAPD_LEVEL_INFO,
|
|
|
|
|
"disconnected due to excessive missing ACKs");
|
2010-12-28 16:15:01 +01:00
|
|
|
hostapd_drv_sta_disassoc(hapd, addr, WLAN_REASON_DISASSOC_LOW_ACK);
|
2016-10-28 08:29:42 +02:00
|
|
|
ap_sta_disassociate(hapd, sta, WLAN_REASON_DISASSOC_LOW_ACK);
|
2010-12-28 16:15:01 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-06-25 13:45:14 +02:00
|
|
|
void hostapd_event_ch_switch(struct hostapd_data *hapd, int freq, int ht,
|
2013-11-25 20:16:12 +01:00
|
|
|
int offset, int width, int cf1, int cf2)
|
2012-06-25 13:45:14 +02:00
|
|
|
{
|
2012-07-07 11:34:48 +02:00
|
|
|
#ifdef NEED_AP_MLME
|
2015-09-08 11:46:29 +02:00
|
|
|
int channel, chwidth, is_dfs;
|
|
|
|
|
u8 seg0_idx = 0, seg1_idx = 0;
|
2012-06-25 13:45:14 +02:00
|
|
|
|
|
|
|
|
hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211,
|
2014-10-26 10:36:14 +01:00
|
|
|
HOSTAPD_LEVEL_INFO,
|
|
|
|
|
"driver had channel switch: freq=%d, ht=%d, offset=%d, width=%d (%s), cf1=%d, cf2=%d",
|
|
|
|
|
freq, ht, offset, width, channel_width_to_string(width),
|
|
|
|
|
cf1, cf2);
|
2012-06-25 13:45:14 +02:00
|
|
|
|
|
|
|
|
hapd->iface->freq = freq;
|
|
|
|
|
|
|
|
|
|
channel = hostapd_hw_get_channel(hapd, freq);
|
|
|
|
|
if (!channel) {
|
|
|
|
|
hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211,
|
2015-07-22 18:56:04 +02:00
|
|
|
HOSTAPD_LEVEL_WARNING,
|
|
|
|
|
"driver switched to bad channel!");
|
2012-06-25 13:45:14 +02:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-25 20:16:12 +01:00
|
|
|
switch (width) {
|
|
|
|
|
case CHAN_WIDTH_80:
|
|
|
|
|
chwidth = VHT_CHANWIDTH_80MHZ;
|
|
|
|
|
break;
|
|
|
|
|
case CHAN_WIDTH_80P80:
|
|
|
|
|
chwidth = VHT_CHANWIDTH_80P80MHZ;
|
|
|
|
|
break;
|
|
|
|
|
case CHAN_WIDTH_160:
|
|
|
|
|
chwidth = VHT_CHANWIDTH_160MHZ;
|
|
|
|
|
break;
|
|
|
|
|
case CHAN_WIDTH_20_NOHT:
|
|
|
|
|
case CHAN_WIDTH_20:
|
|
|
|
|
case CHAN_WIDTH_40:
|
|
|
|
|
default:
|
|
|
|
|
chwidth = VHT_CHANWIDTH_USE_HT;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (hapd->iface->current_mode->mode) {
|
|
|
|
|
case HOSTAPD_MODE_IEEE80211A:
|
|
|
|
|
if (cf1 > 5000)
|
|
|
|
|
seg0_idx = (cf1 - 5000) / 5;
|
|
|
|
|
if (cf2 > 5000)
|
|
|
|
|
seg1_idx = (cf2 - 5000) / 5;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2015-09-08 11:46:29 +02:00
|
|
|
ieee80211_freq_to_chan(cf1, &seg0_idx);
|
|
|
|
|
ieee80211_freq_to_chan(cf2, &seg1_idx);
|
2013-11-25 20:16:12 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-25 13:45:14 +02:00
|
|
|
hapd->iconf->channel = channel;
|
|
|
|
|
hapd->iconf->ieee80211n = ht;
|
2014-10-25 10:27:48 +02:00
|
|
|
if (!ht)
|
|
|
|
|
hapd->iconf->ieee80211ac = 0;
|
2012-06-25 13:45:14 +02:00
|
|
|
hapd->iconf->secondary_channel = offset;
|
2013-11-25 20:16:12 +01:00
|
|
|
hapd->iconf->vht_oper_chwidth = chwidth;
|
|
|
|
|
hapd->iconf->vht_oper_centr_freq_seg0_idx = seg0_idx;
|
|
|
|
|
hapd->iconf->vht_oper_centr_freq_seg1_idx = seg1_idx;
|
2013-11-14 11:28:31 +01:00
|
|
|
|
2015-03-05 02:04:09 +01:00
|
|
|
is_dfs = ieee80211_is_dfs(freq);
|
|
|
|
|
|
2014-06-27 14:19:27 +02:00
|
|
|
if (hapd->csa_in_progress &&
|
|
|
|
|
freq == hapd->cs_freq_params.freq) {
|
2013-11-14 11:28:31 +01:00
|
|
|
hostapd_cleanup_cs_params(hapd);
|
2014-06-27 14:19:27 +02:00
|
|
|
ieee802_11_set_beacon(hapd);
|
2013-11-14 11:28:31 +01:00
|
|
|
|
2015-03-05 02:04:09 +01:00
|
|
|
wpa_msg(hapd->msg_ctx, MSG_INFO, AP_CSA_FINISHED
|
|
|
|
|
"freq=%d dfs=%d", freq, is_dfs);
|
|
|
|
|
} else if (hapd->iface->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) {
|
|
|
|
|
wpa_msg(hapd->msg_ctx, MSG_INFO, AP_CSA_FINISHED
|
|
|
|
|
"freq=%d dfs=%d", freq, is_dfs);
|
2013-11-14 11:28:31 +01:00
|
|
|
}
|
2012-07-07 11:34:48 +02:00
|
|
|
#endif /* NEED_AP_MLME */
|
2012-06-25 13:45:14 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-02-07 14:24:53 +01:00
|
|
|
void hostapd_event_connect_failed_reason(struct hostapd_data *hapd,
|
|
|
|
|
const u8 *addr, int reason_code)
|
|
|
|
|
{
|
|
|
|
|
switch (reason_code) {
|
|
|
|
|
case MAX_CLIENT_REACHED:
|
|
|
|
|
wpa_msg(hapd->msg_ctx, MSG_INFO, AP_REJECTED_MAX_STA MACSTR,
|
|
|
|
|
MAC2STR(addr));
|
|
|
|
|
break;
|
|
|
|
|
case BLOCKED_CLIENT:
|
|
|
|
|
wpa_msg(hapd->msg_ctx, MSG_INFO, AP_REJECTED_BLOCKED_STA MACSTR,
|
|
|
|
|
MAC2STR(addr));
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2014-11-18 19:11:09 +01:00
|
|
|
#ifdef CONFIG_ACS
|
2015-11-27 12:40:37 +01:00
|
|
|
void hostapd_acs_channel_selected(struct hostapd_data *hapd,
|
|
|
|
|
struct acs_selected_channels *acs_res)
|
2014-11-18 19:11:09 +01:00
|
|
|
{
|
2015-05-08 19:53:08 +02:00
|
|
|
int ret, i;
|
2016-03-01 20:13:25 +01:00
|
|
|
int err = 0;
|
2014-11-18 19:11:09 +01:00
|
|
|
|
|
|
|
|
if (hapd->iconf->channel) {
|
|
|
|
|
wpa_printf(MSG_INFO, "ACS: Channel was already set to %d",
|
|
|
|
|
hapd->iconf->channel);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-08 19:53:08 +02:00
|
|
|
if (!hapd->iface->current_mode) {
|
|
|
|
|
for (i = 0; i < hapd->iface->num_hw_features; i++) {
|
|
|
|
|
struct hostapd_hw_modes *mode =
|
|
|
|
|
&hapd->iface->hw_features[i];
|
|
|
|
|
|
|
|
|
|
if (mode->mode == acs_res->hw_mode) {
|
|
|
|
|
hapd->iface->current_mode = mode;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (!hapd->iface->current_mode) {
|
|
|
|
|
hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211,
|
|
|
|
|
HOSTAPD_LEVEL_WARNING,
|
|
|
|
|
"driver selected to bad hw_mode");
|
2016-03-01 20:13:25 +01:00
|
|
|
err = 1;
|
|
|
|
|
goto out;
|
2015-05-08 19:53:08 +02:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-11 21:03:58 +01:00
|
|
|
hapd->iface->freq = hostapd_hw_get_freq(hapd, acs_res->pri_channel);
|
2014-11-18 19:11:09 +01:00
|
|
|
|
2015-03-11 21:03:58 +01:00
|
|
|
if (!acs_res->pri_channel) {
|
2014-11-18 19:11:09 +01:00
|
|
|
hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211,
|
|
|
|
|
HOSTAPD_LEVEL_WARNING,
|
|
|
|
|
"driver switched to bad channel");
|
2016-03-01 20:13:25 +01:00
|
|
|
err = 1;
|
|
|
|
|
goto out;
|
2014-11-18 19:11:09 +01:00
|
|
|
}
|
|
|
|
|
|
2015-03-11 21:03:58 +01:00
|
|
|
hapd->iconf->channel = acs_res->pri_channel;
|
|
|
|
|
hapd->iconf->acs = 1;
|
2014-11-18 19:11:09 +01:00
|
|
|
|
2015-03-11 21:03:58 +01:00
|
|
|
if (acs_res->sec_channel == 0)
|
2014-11-18 19:11:09 +01:00
|
|
|
hapd->iconf->secondary_channel = 0;
|
2015-03-11 21:03:58 +01:00
|
|
|
else if (acs_res->sec_channel < acs_res->pri_channel)
|
2014-11-18 19:11:09 +01:00
|
|
|
hapd->iconf->secondary_channel = -1;
|
2015-03-11 21:03:58 +01:00
|
|
|
else if (acs_res->sec_channel > acs_res->pri_channel)
|
2014-11-18 19:11:09 +01:00
|
|
|
hapd->iconf->secondary_channel = 1;
|
|
|
|
|
else {
|
|
|
|
|
wpa_printf(MSG_ERROR, "Invalid secondary channel!");
|
2016-03-01 20:13:25 +01:00
|
|
|
err = 1;
|
|
|
|
|
goto out;
|
2014-11-18 19:11:09 +01:00
|
|
|
}
|
|
|
|
|
|
2015-03-11 21:03:58 +01:00
|
|
|
if (hapd->iface->conf->ieee80211ac) {
|
|
|
|
|
/* set defaults for backwards compatibility */
|
|
|
|
|
hapd->iconf->vht_oper_centr_freq_seg1_idx = 0;
|
|
|
|
|
hapd->iconf->vht_oper_centr_freq_seg0_idx = 0;
|
|
|
|
|
hapd->iconf->vht_oper_chwidth = VHT_CHANWIDTH_USE_HT;
|
|
|
|
|
if (acs_res->ch_width == 80) {
|
|
|
|
|
hapd->iconf->vht_oper_centr_freq_seg0_idx =
|
|
|
|
|
acs_res->vht_seg0_center_ch;
|
|
|
|
|
hapd->iconf->vht_oper_chwidth = VHT_CHANWIDTH_80MHZ;
|
|
|
|
|
} else if (acs_res->ch_width == 160) {
|
|
|
|
|
if (acs_res->vht_seg1_center_ch == 0) {
|
|
|
|
|
hapd->iconf->vht_oper_centr_freq_seg0_idx =
|
|
|
|
|
acs_res->vht_seg0_center_ch;
|
|
|
|
|
hapd->iconf->vht_oper_chwidth =
|
|
|
|
|
VHT_CHANWIDTH_160MHZ;
|
|
|
|
|
} else {
|
|
|
|
|
hapd->iconf->vht_oper_centr_freq_seg0_idx =
|
|
|
|
|
acs_res->vht_seg0_center_ch;
|
|
|
|
|
hapd->iconf->vht_oper_centr_freq_seg1_idx =
|
|
|
|
|
acs_res->vht_seg1_center_ch;
|
|
|
|
|
hapd->iconf->vht_oper_chwidth =
|
|
|
|
|
VHT_CHANWIDTH_80P80MHZ;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-03-01 20:13:25 +01:00
|
|
|
out:
|
|
|
|
|
ret = hostapd_acs_completed(hapd->iface, err);
|
2014-11-18 19:11:09 +01:00
|
|
|
if (ret) {
|
|
|
|
|
wpa_printf(MSG_ERROR,
|
|
|
|
|
"ACS: Possibly channel configuration is invalid");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_ACS */
|
|
|
|
|
|
|
|
|
|
|
2011-07-15 19:25:53 +02:00
|
|
|
int hostapd_probe_req_rx(struct hostapd_data *hapd, const u8 *sa, const u8 *da,
|
2012-04-01 17:48:12 +02:00
|
|
|
const u8 *bssid, const u8 *ie, size_t ie_len,
|
|
|
|
|
int ssi_signal)
|
2011-02-08 13:32:35 +01:00
|
|
|
{
|
|
|
|
|
size_t i;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
2011-04-14 01:39:25 +02:00
|
|
|
if (sa == NULL || ie == NULL)
|
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
|
|
random_add_randomness(sa, ETH_ALEN);
|
2011-02-08 13:32:35 +01:00
|
|
|
for (i = 0; hapd->probereq_cb && i < hapd->num_probereq_cb; i++) {
|
|
|
|
|
if (hapd->probereq_cb[i].cb(hapd->probereq_cb[i].ctx,
|
2012-04-01 17:48:12 +02:00
|
|
|
sa, da, bssid, ie, ie_len,
|
|
|
|
|
ssi_signal) > 0) {
|
2011-02-08 13:32:35 +01:00
|
|
|
ret = 1;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-08-01 12:14:09 +02:00
|
|
|
#ifdef HOSTAPD
|
|
|
|
|
|
2016-10-27 14:18:32 +02:00
|
|
|
#ifdef CONFIG_IEEE80211R_AP
|
2010-10-25 13:30:04 +02:00
|
|
|
static void hostapd_notify_auth_ft_finish(void *ctx, const u8 *dst,
|
|
|
|
|
const u8 *bssid,
|
|
|
|
|
u16 auth_transaction, u16 status,
|
|
|
|
|
const u8 *ies, size_t ies_len)
|
|
|
|
|
{
|
|
|
|
|
struct hostapd_data *hapd = ctx;
|
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
|
|
|
|
|
sta = ap_get_sta(hapd, dst);
|
|
|
|
|
if (sta == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
hostapd_logger(hapd, dst, HOSTAPD_MODULE_IEEE80211,
|
|
|
|
|
HOSTAPD_LEVEL_DEBUG, "authentication OK (FT)");
|
|
|
|
|
sta->flags |= WLAN_STA_AUTH;
|
|
|
|
|
|
|
|
|
|
hostapd_sta_auth(hapd, dst, auth_transaction, status, ies, ies_len);
|
|
|
|
|
}
|
2016-10-27 14:18:32 +02:00
|
|
|
#endif /* CONFIG_IEEE80211R_AP */
|
2010-10-25 13:30:04 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
static void hostapd_notif_auth(struct hostapd_data *hapd,
|
|
|
|
|
struct auth_info *rx_auth)
|
|
|
|
|
{
|
|
|
|
|
struct sta_info *sta;
|
|
|
|
|
u16 status = WLAN_STATUS_SUCCESS;
|
|
|
|
|
u8 resp_ies[2 + WLAN_AUTH_CHALLENGE_LEN];
|
|
|
|
|
size_t resp_ies_len = 0;
|
|
|
|
|
|
|
|
|
|
sta = ap_get_sta(hapd, rx_auth->peer);
|
|
|
|
|
if (!sta) {
|
|
|
|
|
sta = ap_sta_add(hapd, rx_auth->peer);
|
|
|
|
|
if (sta == NULL) {
|
2013-04-28 15:45:55 +02:00
|
|
|
status = WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA;
|
2010-10-25 13:30:04 +02:00
|
|
|
goto fail;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
sta->flags &= ~WLAN_STA_PREAUTH;
|
|
|
|
|
ieee802_1x_notify_pre_auth(sta->eapol_sm, 0);
|
2016-10-27 14:18:32 +02:00
|
|
|
#ifdef CONFIG_IEEE80211R_AP
|
2010-10-25 13:30:04 +02:00
|
|
|
if (rx_auth->auth_type == WLAN_AUTH_FT && hapd->wpa_auth) {
|
|
|
|
|
sta->auth_alg = WLAN_AUTH_FT;
|
|
|
|
|
if (sta->wpa_sm == NULL)
|
|
|
|
|
sta->wpa_sm = wpa_auth_sta_init(hapd->wpa_auth,
|
2013-09-01 10:05:19 +02:00
|
|
|
sta->addr, NULL);
|
2010-10-25 13:30:04 +02:00
|
|
|
if (sta->wpa_sm == NULL) {
|
2015-07-22 18:56:04 +02:00
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
|
"FT: Failed to initialize WPA state machine");
|
2010-10-25 13:30:04 +02:00
|
|
|
status = WLAN_STATUS_UNSPECIFIED_FAILURE;
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
|
|
|
|
wpa_ft_process_auth(sta->wpa_sm, rx_auth->bssid,
|
|
|
|
|
rx_auth->auth_transaction, rx_auth->ies,
|
|
|
|
|
rx_auth->ies_len,
|
|
|
|
|
hostapd_notify_auth_ft_finish, hapd);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2016-10-27 14:18:32 +02:00
|
|
|
#endif /* CONFIG_IEEE80211R_AP */
|
2010-10-25 13:30:04 +02:00
|
|
|
fail:
|
|
|
|
|
hostapd_sta_auth(hapd, rx_auth->peer, rx_auth->auth_transaction + 1,
|
|
|
|
|
status, resp_ies, resp_ies_len);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void hostapd_action_rx(struct hostapd_data *hapd,
|
2013-12-29 10:22:23 +01:00
|
|
|
struct rx_mgmt *drv_mgmt)
|
2010-10-25 13:30:04 +02:00
|
|
|
{
|
2013-12-29 10:22:23 +01:00
|
|
|
struct ieee80211_mgmt *mgmt;
|
2010-10-25 13:30:04 +02:00
|
|
|
struct sta_info *sta;
|
2013-12-29 10:22:23 +01:00
|
|
|
size_t plen __maybe_unused;
|
|
|
|
|
u16 fc;
|
|
|
|
|
|
|
|
|
|
if (drv_mgmt->frame_len < 24 + 1)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
plen = drv_mgmt->frame_len - 24 - 1;
|
|
|
|
|
|
|
|
|
|
mgmt = (struct ieee80211_mgmt *) drv_mgmt->frame;
|
|
|
|
|
fc = le_to_host16(mgmt->frame_control);
|
|
|
|
|
if (WLAN_FC_GET_STYPE(fc) != WLAN_FC_STYPE_ACTION)
|
|
|
|
|
return; /* handled by the driver */
|
2010-10-25 13:30:04 +02:00
|
|
|
|
2015-07-22 18:56:04 +02:00
|
|
|
wpa_printf(MSG_DEBUG, "RX_ACTION cat %d action plen %d",
|
2013-12-29 10:22:23 +01:00
|
|
|
mgmt->u.action.category, (int) plen);
|
2011-08-22 23:35:26 +02:00
|
|
|
|
2013-12-29 10:22:23 +01:00
|
|
|
sta = ap_get_sta(hapd, mgmt->sa);
|
2010-10-25 13:30:04 +02:00
|
|
|
if (sta == NULL) {
|
|
|
|
|
wpa_printf(MSG_DEBUG, "%s: station not found", __func__);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2016-10-27 14:18:32 +02:00
|
|
|
#ifdef CONFIG_IEEE80211R_AP
|
2013-12-29 10:22:23 +01:00
|
|
|
if (mgmt->u.action.category == WLAN_ACTION_FT) {
|
|
|
|
|
const u8 *payload = drv_mgmt->frame + 24 + 1;
|
2015-07-22 18:56:04 +02:00
|
|
|
|
2013-12-29 10:22:23 +01:00
|
|
|
wpa_ft_action_rx(sta->wpa_sm, payload, plen);
|
2010-10-25 13:30:04 +02:00
|
|
|
}
|
2016-10-27 14:18:32 +02:00
|
|
|
#endif /* CONFIG_IEEE80211R_AP */
|
2011-08-22 23:35:26 +02:00
|
|
|
#ifdef CONFIG_IEEE80211W
|
2013-12-29 10:22:23 +01:00
|
|
|
if (mgmt->u.action.category == WLAN_ACTION_SA_QUERY && plen >= 4) {
|
|
|
|
|
ieee802_11_sa_query_action(
|
|
|
|
|
hapd, mgmt->sa,
|
|
|
|
|
mgmt->u.action.u.sa_query_resp.action,
|
|
|
|
|
mgmt->u.action.u.sa_query_resp.trans_id);
|
2011-08-22 23:35:26 +02:00
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_IEEE80211W */
|
2012-12-16 17:22:54 +01:00
|
|
|
#ifdef CONFIG_WNM
|
2013-12-29 10:22:23 +01:00
|
|
|
if (mgmt->u.action.category == WLAN_ACTION_WNM) {
|
|
|
|
|
ieee802_11_rx_wnm_action_ap(hapd, mgmt, drv_mgmt->frame_len);
|
2012-02-26 16:25:55 +01:00
|
|
|
}
|
2012-12-16 17:22:54 +01:00
|
|
|
#endif /* CONFIG_WNM */
|
2015-01-21 14:30:48 +01:00
|
|
|
#ifdef CONFIG_FST
|
|
|
|
|
if (mgmt->u.action.category == WLAN_ACTION_FST && hapd->iface->fst) {
|
|
|
|
|
fst_rx_action(hapd->iface->fst, mgmt, drv_mgmt->frame_len);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_FST */
|
|
|
|
|
|
2010-10-25 13:30:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2009-08-14 19:01:41 +02:00
|
|
|
#ifdef NEED_AP_MLME
|
2009-12-13 22:05:39 +01:00
|
|
|
|
|
|
|
|
#define HAPD_BROADCAST ((struct hostapd_data *) -1)
|
|
|
|
|
|
|
|
|
|
static struct hostapd_data * get_hapd_bssid(struct hostapd_iface *iface,
|
|
|
|
|
const u8 *bssid)
|
|
|
|
|
{
|
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
|
|
if (bssid == NULL)
|
|
|
|
|
return NULL;
|
|
|
|
|
if (bssid[0] == 0xff && bssid[1] == 0xff && bssid[2] == 0xff &&
|
|
|
|
|
bssid[3] == 0xff && bssid[4] == 0xff && bssid[5] == 0xff)
|
|
|
|
|
return HAPD_BROADCAST;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < iface->num_bss; i++) {
|
|
|
|
|
if (os_memcmp(bssid, iface->bss[i]->own_addr, ETH_ALEN) == 0)
|
|
|
|
|
return iface->bss[i];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void hostapd_rx_from_unknown_sta(struct hostapd_data *hapd,
|
2011-10-20 20:51:32 +02:00
|
|
|
const u8 *bssid, const u8 *addr,
|
|
|
|
|
int wds)
|
2009-12-13 22:05:39 +01:00
|
|
|
{
|
2011-10-20 20:51:32 +02:00
|
|
|
hapd = get_hapd_bssid(hapd->iface, bssid);
|
2009-12-13 22:05:39 +01:00
|
|
|
if (hapd == NULL || hapd == HAPD_BROADCAST)
|
|
|
|
|
return;
|
|
|
|
|
|
2011-10-20 20:51:32 +02:00
|
|
|
ieee802_11_rx_from_unknown(hapd, addr, wds);
|
2009-12-13 22:05:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-12-29 09:18:49 +01:00
|
|
|
static int hostapd_mgmt_rx(struct hostapd_data *hapd, struct rx_mgmt *rx_mgmt)
|
2009-01-09 16:27:03 +01:00
|
|
|
{
|
2009-04-17 12:29:29 +02:00
|
|
|
struct hostapd_iface *iface = hapd->iface;
|
2009-12-13 22:25:30 +01:00
|
|
|
const struct ieee80211_hdr *hdr;
|
2009-04-17 12:29:29 +02:00
|
|
|
const u8 *bssid;
|
2010-01-03 11:37:02 +01:00
|
|
|
struct hostapd_frame_info fi;
|
2013-12-29 09:18:49 +01:00
|
|
|
int ret;
|
2009-04-17 12:29:29 +02:00
|
|
|
|
2014-03-02 10:51:38 +01:00
|
|
|
#ifdef CONFIG_TESTING_OPTIONS
|
|
|
|
|
if (hapd->ext_mgmt_frame_handling) {
|
|
|
|
|
size_t hex_len = 2 * rx_mgmt->frame_len + 1;
|
|
|
|
|
char *hex = os_malloc(hex_len);
|
2015-07-22 18:56:04 +02:00
|
|
|
|
2014-03-02 10:51:38 +01:00
|
|
|
if (hex) {
|
|
|
|
|
wpa_snprintf_hex(hex, hex_len, rx_mgmt->frame,
|
|
|
|
|
rx_mgmt->frame_len);
|
|
|
|
|
wpa_msg(hapd->msg_ctx, MSG_INFO, "MGMT-RX %s", hex);
|
|
|
|
|
os_free(hex);
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_TESTING_OPTIONS */
|
|
|
|
|
|
2010-01-03 11:37:02 +01:00
|
|
|
hdr = (const struct ieee80211_hdr *) rx_mgmt->frame;
|
|
|
|
|
bssid = get_hdr_bssid(hdr, rx_mgmt->frame_len);
|
2009-04-17 12:29:29 +02:00
|
|
|
if (bssid == NULL)
|
2013-12-29 09:18:49 +01:00
|
|
|
return 0;
|
2009-04-17 12:29:29 +02:00
|
|
|
|
|
|
|
|
hapd = get_hapd_bssid(iface, bssid);
|
|
|
|
|
if (hapd == NULL) {
|
2015-07-22 18:56:04 +02:00
|
|
|
u16 fc = le_to_host16(hdr->frame_control);
|
2009-04-17 12:29:29 +02:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Drop frames to unknown BSSIDs except for Beacon frames which
|
|
|
|
|
* could be used to update neighbor information.
|
|
|
|
|
*/
|
|
|
|
|
if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT &&
|
|
|
|
|
WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_BEACON)
|
|
|
|
|
hapd = iface->bss[0];
|
|
|
|
|
else
|
2013-12-29 09:18:49 +01:00
|
|
|
return 0;
|
2009-04-17 12:29:29 +02:00
|
|
|
}
|
|
|
|
|
|
2010-01-03 11:37:02 +01:00
|
|
|
os_memset(&fi, 0, sizeof(fi));
|
|
|
|
|
fi.datarate = rx_mgmt->datarate;
|
|
|
|
|
fi.ssi_signal = rx_mgmt->ssi_signal;
|
|
|
|
|
|
2009-04-17 12:29:29 +02:00
|
|
|
if (hapd == HAPD_BROADCAST) {
|
|
|
|
|
size_t i;
|
2015-07-22 18:56:04 +02:00
|
|
|
|
2013-12-29 09:18:49 +01:00
|
|
|
ret = 0;
|
|
|
|
|
for (i = 0; i < iface->num_bss; i++) {
|
2014-02-10 16:04:17 +01:00
|
|
|
/* if bss is set, driver will call this function for
|
|
|
|
|
* each bss individually. */
|
|
|
|
|
if (rx_mgmt->drv_priv &&
|
|
|
|
|
(iface->bss[i]->drv_priv != rx_mgmt->drv_priv))
|
|
|
|
|
continue;
|
|
|
|
|
|
2013-12-29 09:18:49 +01:00
|
|
|
if (ieee802_11_mgmt(iface->bss[i], rx_mgmt->frame,
|
|
|
|
|
rx_mgmt->frame_len, &fi) > 0)
|
|
|
|
|
ret = 1;
|
|
|
|
|
}
|
2009-04-17 12:29:29 +02:00
|
|
|
} else
|
2013-12-29 09:18:49 +01:00
|
|
|
ret = ieee802_11_mgmt(hapd, rx_mgmt->frame, rx_mgmt->frame_len,
|
|
|
|
|
&fi);
|
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(&fi, sizeof(fi));
|
2013-12-29 09:18:49 +01:00
|
|
|
|
|
|
|
|
return ret;
|
2009-01-09 16:27:03 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2009-12-13 22:05:39 +01:00
|
|
|
static void hostapd_mgmt_tx_cb(struct hostapd_data *hapd, const u8 *buf,
|
|
|
|
|
size_t len, u16 stype, int ok)
|
2009-01-09 16:27:03 +01:00
|
|
|
{
|
2009-04-17 12:29:29 +02:00
|
|
|
struct ieee80211_hdr *hdr;
|
2016-06-10 20:35:11 +02:00
|
|
|
struct hostapd_data *orig_hapd = hapd;
|
2015-07-22 18:56:04 +02:00
|
|
|
|
2009-04-17 12:29:29 +02:00
|
|
|
hdr = (struct ieee80211_hdr *) buf;
|
|
|
|
|
hapd = get_hapd_bssid(hapd->iface, get_hdr_bssid(hdr, len));
|
2016-06-10 20:35:11 +02:00
|
|
|
if (!hapd)
|
2009-04-17 12:29:29 +02:00
|
|
|
return;
|
2016-06-10 20:35:11 +02:00
|
|
|
if (hapd == HAPD_BROADCAST) {
|
|
|
|
|
if (stype != WLAN_FC_STYPE_ACTION || len <= 25 ||
|
|
|
|
|
buf[24] != WLAN_ACTION_PUBLIC)
|
|
|
|
|
return;
|
|
|
|
|
hapd = get_hapd_bssid(orig_hapd->iface, hdr->addr2);
|
|
|
|
|
if (!hapd || hapd == HAPD_BROADCAST)
|
|
|
|
|
return;
|
|
|
|
|
/*
|
|
|
|
|
* Allow processing of TX status for a Public Action frame that
|
|
|
|
|
* used wildcard BBSID.
|
|
|
|
|
*/
|
|
|
|
|
}
|
2009-01-09 16:27:03 +01:00
|
|
|
ieee802_11_mgmt_cb(hapd, buf, len, stype, ok);
|
|
|
|
|
}
|
2009-04-03 20:04:25 +02:00
|
|
|
|
2009-12-13 22:05:39 +01:00
|
|
|
#endif /* NEED_AP_MLME */
|
2009-04-16 15:22:40 +02:00
|
|
|
|
|
|
|
|
|
2010-01-03 16:44:40 +01:00
|
|
|
static int hostapd_event_new_sta(struct hostapd_data *hapd, const u8 *addr)
|
|
|
|
|
{
|
|
|
|
|
struct sta_info *sta = ap_get_sta(hapd, addr);
|
2015-07-22 18:56:04 +02:00
|
|
|
|
2010-01-03 16:44:40 +01:00
|
|
|
if (sta)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
wpa_printf(MSG_DEBUG, "Data frame from unknown STA " MACSTR
|
|
|
|
|
" - adding a new STA", MAC2STR(addr));
|
|
|
|
|
sta = ap_sta_add(hapd, addr);
|
|
|
|
|
if (sta) {
|
|
|
|
|
hostapd_new_assoc_sta(hapd, sta, 0);
|
|
|
|
|
} else {
|
|
|
|
|
wpa_printf(MSG_DEBUG, "Failed to add STA entry for " MACSTR,
|
|
|
|
|
MAC2STR(addr));
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void hostapd_event_eapol_rx(struct hostapd_data *hapd, const u8 *src,
|
|
|
|
|
const u8 *data, size_t data_len)
|
|
|
|
|
{
|
|
|
|
|
struct hostapd_iface *iface = hapd->iface;
|
2012-10-25 08:20:15 +02:00
|
|
|
struct sta_info *sta;
|
2010-01-03 16:44:40 +01:00
|
|
|
size_t j;
|
|
|
|
|
|
|
|
|
|
for (j = 0; j < iface->num_bss; j++) {
|
2015-07-22 18:56:04 +02:00
|
|
|
sta = ap_get_sta(iface->bss[j], src);
|
|
|
|
|
if (sta && sta->flags & WLAN_STA_ASSOC) {
|
|
|
|
|
hapd = iface->bss[j];
|
|
|
|
|
break;
|
2010-01-03 16:44:40 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ieee802_1x_receive(hapd, src, data, data_len);
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-27 12:40:36 +01:00
|
|
|
#endif /* HOSTAPD */
|
|
|
|
|
|
2010-01-03 16:44:40 +01:00
|
|
|
|
2013-07-24 08:59:13 +02:00
|
|
|
static struct hostapd_channel_data * hostapd_get_mode_channel(
|
|
|
|
|
struct hostapd_iface *iface, unsigned int freq)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
struct hostapd_channel_data *chan;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < iface->current_mode->num_channels; i++) {
|
|
|
|
|
chan = &iface->current_mode->channels[i];
|
|
|
|
|
if ((unsigned int) chan->freq == freq)
|
|
|
|
|
return chan;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void hostapd_update_nf(struct hostapd_iface *iface,
|
|
|
|
|
struct hostapd_channel_data *chan,
|
|
|
|
|
struct freq_survey *survey)
|
|
|
|
|
{
|
|
|
|
|
if (!iface->chans_surveyed) {
|
|
|
|
|
chan->min_nf = survey->nf;
|
|
|
|
|
iface->lowest_nf = survey->nf;
|
|
|
|
|
} else {
|
|
|
|
|
if (dl_list_empty(&chan->survey_list))
|
|
|
|
|
chan->min_nf = survey->nf;
|
|
|
|
|
else if (survey->nf < chan->min_nf)
|
|
|
|
|
chan->min_nf = survey->nf;
|
|
|
|
|
if (survey->nf < iface->lowest_nf)
|
|
|
|
|
iface->lowest_nf = survey->nf;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2014-10-16 01:36:04 +02:00
|
|
|
static void hostapd_single_channel_get_survey(struct hostapd_iface *iface,
|
|
|
|
|
struct survey_results *survey_res)
|
|
|
|
|
{
|
|
|
|
|
struct hostapd_channel_data *chan;
|
|
|
|
|
struct freq_survey *survey;
|
|
|
|
|
u64 divisor, dividend;
|
|
|
|
|
|
|
|
|
|
survey = dl_list_first(&survey_res->survey_list, struct freq_survey,
|
|
|
|
|
list);
|
|
|
|
|
if (!survey || !survey->freq)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
chan = hostapd_get_mode_channel(iface, survey->freq);
|
|
|
|
|
if (!chan || chan->flag & HOSTAPD_CHAN_DISABLED)
|
|
|
|
|
return;
|
|
|
|
|
|
2015-07-22 18:56:04 +02:00
|
|
|
wpa_printf(MSG_DEBUG,
|
|
|
|
|
"Single Channel Survey: (freq=%d channel_time=%ld channel_time_busy=%ld)",
|
2014-10-16 01:36:04 +02:00
|
|
|
survey->freq,
|
|
|
|
|
(unsigned long int) survey->channel_time,
|
|
|
|
|
(unsigned long int) survey->channel_time_busy);
|
|
|
|
|
|
|
|
|
|
if (survey->channel_time > iface->last_channel_time &&
|
|
|
|
|
survey->channel_time > survey->channel_time_busy) {
|
|
|
|
|
dividend = survey->channel_time_busy -
|
|
|
|
|
iface->last_channel_time_busy;
|
|
|
|
|
divisor = survey->channel_time - iface->last_channel_time;
|
|
|
|
|
|
|
|
|
|
iface->channel_utilization = dividend * 255 / divisor;
|
|
|
|
|
wpa_printf(MSG_DEBUG, "Channel Utilization: %d",
|
|
|
|
|
iface->channel_utilization);
|
|
|
|
|
}
|
|
|
|
|
iface->last_channel_time = survey->channel_time;
|
|
|
|
|
iface->last_channel_time_busy = survey->channel_time_busy;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-11-27 12:40:36 +01:00
|
|
|
void hostapd_event_get_survey(struct hostapd_iface *iface,
|
|
|
|
|
struct survey_results *survey_results)
|
2013-07-24 08:59:13 +02:00
|
|
|
{
|
|
|
|
|
struct freq_survey *survey, *tmp;
|
|
|
|
|
struct hostapd_channel_data *chan;
|
|
|
|
|
|
|
|
|
|
if (dl_list_empty(&survey_results->survey_list)) {
|
|
|
|
|
wpa_printf(MSG_DEBUG, "No survey data received");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-16 01:36:04 +02:00
|
|
|
if (survey_results->freq_filter) {
|
|
|
|
|
hostapd_single_channel_get_survey(iface, survey_results);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2013-07-24 08:59:13 +02:00
|
|
|
dl_list_for_each_safe(survey, tmp, &survey_results->survey_list,
|
|
|
|
|
struct freq_survey, list) {
|
|
|
|
|
chan = hostapd_get_mode_channel(iface, survey->freq);
|
|
|
|
|
if (!chan)
|
|
|
|
|
continue;
|
|
|
|
|
if (chan->flag & HOSTAPD_CHAN_DISABLED)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
dl_list_del(&survey->list);
|
|
|
|
|
dl_list_add_tail(&chan->survey_list, &survey->list);
|
|
|
|
|
|
|
|
|
|
hostapd_update_nf(iface, chan, survey);
|
|
|
|
|
|
|
|
|
|
iface->chans_surveyed++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2015-11-27 12:40:36 +01:00
|
|
|
#ifdef HOSTAPD
|
2013-10-15 19:27:25 +02:00
|
|
|
#ifdef NEED_AP_MLME
|
|
|
|
|
|
2014-06-27 14:19:30 +02:00
|
|
|
static void hostapd_event_iface_unavailable(struct hostapd_data *hapd)
|
|
|
|
|
{
|
|
|
|
|
wpa_printf(MSG_DEBUG, "Interface %s is unavailable -- stopped",
|
|
|
|
|
hapd->conf->iface);
|
|
|
|
|
|
|
|
|
|
if (hapd->csa_in_progress) {
|
|
|
|
|
wpa_printf(MSG_INFO, "CSA failed (%s was stopped)",
|
|
|
|
|
hapd->conf->iface);
|
|
|
|
|
hostapd_switch_channel_fallback(hapd->iface,
|
|
|
|
|
&hapd->cs_freq_params);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2013-10-15 19:27:25 +02:00
|
|
|
static void hostapd_event_dfs_radar_detected(struct hostapd_data *hapd,
|
|
|
|
|
struct dfs_event *radar)
|
|
|
|
|
{
|
|
|
|
|
wpa_printf(MSG_DEBUG, "DFS radar detected on %d MHz", radar->freq);
|
2013-11-03 17:48:03 +01:00
|
|
|
hostapd_dfs_radar_detected(hapd->iface, radar->freq, radar->ht_enabled,
|
2013-10-16 11:18:52 +02:00
|
|
|
radar->chan_offset, radar->chan_width,
|
|
|
|
|
radar->cf1, radar->cf2);
|
2013-10-15 19:27:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void hostapd_event_dfs_cac_finished(struct hostapd_data *hapd,
|
|
|
|
|
struct dfs_event *radar)
|
|
|
|
|
{
|
|
|
|
|
wpa_printf(MSG_DEBUG, "DFS CAC finished on %d MHz", radar->freq);
|
2013-11-03 17:48:03 +01:00
|
|
|
hostapd_dfs_complete_cac(hapd->iface, 1, radar->freq, radar->ht_enabled,
|
2013-10-16 11:18:52 +02:00
|
|
|
radar->chan_offset, radar->chan_width,
|
|
|
|
|
radar->cf1, radar->cf2);
|
2013-10-15 19:27:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void hostapd_event_dfs_cac_aborted(struct hostapd_data *hapd,
|
|
|
|
|
struct dfs_event *radar)
|
|
|
|
|
{
|
|
|
|
|
wpa_printf(MSG_DEBUG, "DFS CAC aborted on %d MHz", radar->freq);
|
2013-11-03 17:48:03 +01:00
|
|
|
hostapd_dfs_complete_cac(hapd->iface, 0, radar->freq, radar->ht_enabled,
|
2013-10-16 11:18:52 +02:00
|
|
|
radar->chan_offset, radar->chan_width,
|
|
|
|
|
radar->cf1, radar->cf2);
|
2013-10-15 19:27:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void hostapd_event_dfs_nop_finished(struct hostapd_data *hapd,
|
|
|
|
|
struct dfs_event *radar)
|
|
|
|
|
{
|
|
|
|
|
wpa_printf(MSG_DEBUG, "DFS NOP finished on %d MHz", radar->freq);
|
2013-11-03 17:48:03 +01:00
|
|
|
hostapd_dfs_nop_finished(hapd->iface, radar->freq, radar->ht_enabled,
|
2013-10-16 11:18:52 +02:00
|
|
|
radar->chan_offset, radar->chan_width,
|
|
|
|
|
radar->cf1, radar->cf2);
|
2013-10-15 19:27:25 +02:00
|
|
|
}
|
|
|
|
|
|
2015-03-05 02:24:36 +01:00
|
|
|
|
|
|
|
|
static void hostapd_event_dfs_cac_started(struct hostapd_data *hapd,
|
|
|
|
|
struct dfs_event *radar)
|
|
|
|
|
{
|
|
|
|
|
wpa_printf(MSG_DEBUG, "DFS offload CAC started on %d MHz", radar->freq);
|
|
|
|
|
hostapd_dfs_start_cac(hapd->iface, radar->freq, radar->ht_enabled,
|
|
|
|
|
radar->chan_offset, radar->chan_width,
|
|
|
|
|
radar->cf1, radar->cf2);
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-15 19:27:25 +02:00
|
|
|
#endif /* NEED_AP_MLME */
|
|
|
|
|
|
|
|
|
|
|
2010-01-03 12:10:12 +01:00
|
|
|
void wpa_supplicant_event(void *ctx, enum wpa_event_type event,
|
2009-04-16 15:22:40 +02:00
|
|
|
union wpa_event_data *data)
|
|
|
|
|
{
|
|
|
|
|
struct hostapd_data *hapd = ctx;
|
2011-12-18 20:48:25 +01:00
|
|
|
#ifndef CONFIG_NO_STDOUT_DEBUG
|
|
|
|
|
int level = MSG_DEBUG;
|
2009-04-16 15:22:40 +02:00
|
|
|
|
2012-08-19 17:38:27 +02:00
|
|
|
if (event == EVENT_RX_MGMT && data->rx_mgmt.frame &&
|
2011-12-18 20:48:25 +01:00
|
|
|
data->rx_mgmt.frame_len >= 24) {
|
|
|
|
|
const struct ieee80211_hdr *hdr;
|
|
|
|
|
u16 fc;
|
2015-07-22 18:56:04 +02:00
|
|
|
|
2011-12-18 20:48:25 +01:00
|
|
|
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;
|
2013-04-24 00:01:21 +02:00
|
|
|
if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT &&
|
|
|
|
|
WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_PROBE_REQ)
|
|
|
|
|
level = MSG_EXCESSIVE;
|
2011-12-18 20:48:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
wpa_dbg(hapd->msg_ctx, level, "Event %s (%d) received",
|
2011-12-03 10:46:47 +01:00
|
|
|
event_to_string(event), event);
|
2011-12-18 20:48:25 +01:00
|
|
|
#endif /* CONFIG_NO_STDOUT_DEBUG */
|
2011-12-03 10:46:47 +01:00
|
|
|
|
2009-04-16 15:22:40 +02:00
|
|
|
switch (event) {
|
|
|
|
|
case EVENT_MICHAEL_MIC_FAILURE:
|
|
|
|
|
michael_mic_failure(hapd, data->michael_mic_failure.src, 1);
|
|
|
|
|
break;
|
|
|
|
|
case EVENT_SCAN_RESULTS:
|
|
|
|
|
if (hapd->iface->scan_cb)
|
|
|
|
|
hapd->iface->scan_cb(hapd->iface);
|
|
|
|
|
break;
|
2009-12-13 20:21:10 +01:00
|
|
|
case EVENT_WPS_BUTTON_PUSHED:
|
2011-02-07 17:28:36 +01:00
|
|
|
hostapd_wps_button_pushed(hapd, NULL);
|
2009-12-13 20:21:10 +01:00
|
|
|
break;
|
2009-12-13 22:05:39 +01:00
|
|
|
#ifdef NEED_AP_MLME
|
|
|
|
|
case EVENT_TX_STATUS:
|
|
|
|
|
switch (data->tx_status.type) {
|
|
|
|
|
case WLAN_FC_TYPE_MGMT:
|
|
|
|
|
hostapd_mgmt_tx_cb(hapd, data->tx_status.data,
|
|
|
|
|
data->tx_status.data_len,
|
|
|
|
|
data->tx_status.stype,
|
|
|
|
|
data->tx_status.ack);
|
|
|
|
|
break;
|
|
|
|
|
case WLAN_FC_TYPE_DATA:
|
|
|
|
|
hostapd_tx_status(hapd, data->tx_status.dst,
|
|
|
|
|
data->tx_status.data,
|
|
|
|
|
data->tx_status.data_len,
|
|
|
|
|
data->tx_status.ack);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
break;
|
2011-11-19 12:00:30 +01:00
|
|
|
case EVENT_EAPOL_TX_STATUS:
|
|
|
|
|
hostapd_eapol_tx_status(hapd, 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:
|
|
|
|
|
hostapd_client_poll_ok(hapd, data->client_poll.addr);
|
|
|
|
|
break;
|
2009-12-13 22:05:39 +01:00
|
|
|
case EVENT_RX_FROM_UNKNOWN:
|
2011-10-20 20:51:32 +02:00
|
|
|
hostapd_rx_from_unknown_sta(hapd, data->rx_from_unknown.bssid,
|
|
|
|
|
data->rx_from_unknown.addr,
|
|
|
|
|
data->rx_from_unknown.wds);
|
2009-12-13 22:05:39 +01:00
|
|
|
break;
|
2013-12-29 10:22:23 +01:00
|
|
|
#endif /* NEED_AP_MLME */
|
2009-12-13 22:05:39 +01:00
|
|
|
case EVENT_RX_MGMT:
|
2014-04-26 11:09:28 +02:00
|
|
|
if (!data->rx_mgmt.frame)
|
|
|
|
|
break;
|
2013-12-29 10:22:23 +01:00
|
|
|
#ifdef NEED_AP_MLME
|
|
|
|
|
if (hostapd_mgmt_rx(hapd, &data->rx_mgmt) > 0)
|
|
|
|
|
break;
|
2009-12-13 22:05:39 +01:00
|
|
|
#endif /* NEED_AP_MLME */
|
2013-12-29 10:22:23 +01:00
|
|
|
hostapd_action_rx(hapd, &data->rx_mgmt);
|
|
|
|
|
break;
|
2010-01-03 11:11:44 +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;
|
2010-01-03 11:11:44 +01:00
|
|
|
hostapd_probe_req_rx(hapd, data->rx_probe_req.sa,
|
2011-07-15 19:25:53 +02:00
|
|
|
data->rx_probe_req.da,
|
|
|
|
|
data->rx_probe_req.bssid,
|
2010-01-03 11:11:44 +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);
|
2010-01-03 11:11:44 +01:00
|
|
|
break;
|
2010-01-03 15:46:18 +01:00
|
|
|
case EVENT_NEW_STA:
|
2010-01-03 16:44:40 +01:00
|
|
|
hostapd_event_new_sta(hapd, data->new_sta.addr);
|
|
|
|
|
break;
|
|
|
|
|
case EVENT_EAPOL_RX:
|
|
|
|
|
hostapd_event_eapol_rx(hapd, data->eapol_rx.src,
|
|
|
|
|
data->eapol_rx.data,
|
|
|
|
|
data->eapol_rx.data_len);
|
|
|
|
|
break;
|
2010-01-03 17:22:22 +01:00
|
|
|
case EVENT_ASSOC:
|
2014-08-26 16:23:02 +02:00
|
|
|
if (!data)
|
|
|
|
|
return;
|
2010-01-03 17:22:22 +01:00
|
|
|
hostapd_notif_assoc(hapd, 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
|
|
|
break;
|
|
|
|
|
case EVENT_DISASSOC:
|
|
|
|
|
if (data)
|
|
|
|
|
hostapd_notif_disassoc(hapd, data->disassoc_info.addr);
|
|
|
|
|
break;
|
|
|
|
|
case EVENT_DEAUTH:
|
|
|
|
|
if (data)
|
|
|
|
|
hostapd_notif_disassoc(hapd, data->deauth_info.addr);
|
|
|
|
|
break;
|
2010-12-28 16:15:01 +01:00
|
|
|
case EVENT_STATION_LOW_ACK:
|
|
|
|
|
if (!data)
|
|
|
|
|
break;
|
|
|
|
|
hostapd_event_sta_low_ack(hapd, data->low_ack.addr);
|
|
|
|
|
break;
|
2010-10-25 13:30:04 +02:00
|
|
|
case EVENT_AUTH:
|
|
|
|
|
hostapd_notif_auth(hapd, &data->auth);
|
|
|
|
|
break;
|
2012-06-25 13:45:14 +02:00
|
|
|
case EVENT_CH_SWITCH:
|
|
|
|
|
if (!data)
|
|
|
|
|
break;
|
|
|
|
|
hostapd_event_ch_switch(hapd, data->ch_switch.freq,
|
|
|
|
|
data->ch_switch.ht_enabled,
|
2013-11-25 20:16:12 +01:00
|
|
|
data->ch_switch.ch_offset,
|
|
|
|
|
data->ch_switch.ch_width,
|
|
|
|
|
data->ch_switch.cf1,
|
|
|
|
|
data->ch_switch.cf2);
|
2012-06-25 13:45:14 +02:00
|
|
|
break;
|
2013-02-07 14:24:53 +01:00
|
|
|
case EVENT_CONNECT_FAILED_REASON:
|
|
|
|
|
if (!data)
|
|
|
|
|
break;
|
|
|
|
|
hostapd_event_connect_failed_reason(
|
|
|
|
|
hapd, data->connect_failed_reason.addr,
|
|
|
|
|
data->connect_failed_reason.code);
|
|
|
|
|
break;
|
2013-07-24 08:59:13 +02:00
|
|
|
case EVENT_SURVEY:
|
2015-11-27 12:40:36 +01:00
|
|
|
hostapd_event_get_survey(hapd->iface, &data->survey_results);
|
2013-07-24 08:59:13 +02:00
|
|
|
break;
|
2013-10-15 19:27:25 +02:00
|
|
|
#ifdef NEED_AP_MLME
|
2014-06-27 14:19:30 +02:00
|
|
|
case EVENT_INTERFACE_UNAVAILABLE:
|
|
|
|
|
hostapd_event_iface_unavailable(hapd);
|
|
|
|
|
break;
|
2013-10-15 19:27:25 +02:00
|
|
|
case EVENT_DFS_RADAR_DETECTED:
|
|
|
|
|
if (!data)
|
|
|
|
|
break;
|
|
|
|
|
hostapd_event_dfs_radar_detected(hapd, &data->dfs_event);
|
|
|
|
|
break;
|
|
|
|
|
case EVENT_DFS_CAC_FINISHED:
|
|
|
|
|
if (!data)
|
|
|
|
|
break;
|
|
|
|
|
hostapd_event_dfs_cac_finished(hapd, &data->dfs_event);
|
|
|
|
|
break;
|
|
|
|
|
case EVENT_DFS_CAC_ABORTED:
|
|
|
|
|
if (!data)
|
|
|
|
|
break;
|
|
|
|
|
hostapd_event_dfs_cac_aborted(hapd, &data->dfs_event);
|
|
|
|
|
break;
|
|
|
|
|
case EVENT_DFS_NOP_FINISHED:
|
|
|
|
|
if (!data)
|
|
|
|
|
break;
|
|
|
|
|
hostapd_event_dfs_nop_finished(hapd, &data->dfs_event);
|
|
|
|
|
break;
|
|
|
|
|
case EVENT_CHANNEL_LIST_CHANGED:
|
|
|
|
|
/* channel list changed (regulatory?), update channel list */
|
|
|
|
|
/* TODO: check this. hostapd_get_hw_features() initializes
|
|
|
|
|
* too much stuff. */
|
|
|
|
|
/* hostapd_get_hw_features(hapd->iface); */
|
2013-11-13 13:00:27 +01:00
|
|
|
hostapd_channel_list_updated(
|
|
|
|
|
hapd->iface, data->channel_list_changed.initiator);
|
2013-10-15 19:27:25 +02:00
|
|
|
break;
|
2015-03-05 02:24:36 +01:00
|
|
|
case EVENT_DFS_CAC_STARTED:
|
|
|
|
|
if (!data)
|
|
|
|
|
break;
|
|
|
|
|
hostapd_event_dfs_cac_started(hapd, &data->dfs_event);
|
|
|
|
|
break;
|
2013-10-15 19:27:25 +02:00
|
|
|
#endif /* NEED_AP_MLME */
|
2014-10-26 09:52:54 +01:00
|
|
|
case EVENT_INTERFACE_ENABLED:
|
|
|
|
|
wpa_msg(hapd->msg_ctx, MSG_INFO, INTERFACE_ENABLED);
|
2015-02-10 17:13:04 +01:00
|
|
|
if (hapd->disabled && hapd->started) {
|
|
|
|
|
hapd->disabled = 0;
|
|
|
|
|
/*
|
|
|
|
|
* Try to re-enable interface if the driver stopped it
|
|
|
|
|
* when the interface got disabled.
|
|
|
|
|
*/
|
2015-02-10 17:19:51 +01:00
|
|
|
wpa_auth_reconfig_group_keys(hapd->wpa_auth);
|
2015-02-10 17:13:04 +01:00
|
|
|
hapd->reenable_beacon = 1;
|
|
|
|
|
ieee802_11_set_beacon(hapd);
|
|
|
|
|
}
|
2014-10-26 09:52:54 +01:00
|
|
|
break;
|
|
|
|
|
case EVENT_INTERFACE_DISABLED:
|
2015-02-10 21:20:07 +01:00
|
|
|
hostapd_free_stas(hapd);
|
2014-10-26 09:52:54 +01:00
|
|
|
wpa_msg(hapd->msg_ctx, MSG_INFO, INTERFACE_DISABLED);
|
2015-02-10 17:13:04 +01:00
|
|
|
hapd->disabled = 1;
|
2014-10-26 09:52:54 +01:00
|
|
|
break;
|
2014-11-18 19:11:09 +01:00
|
|
|
#ifdef CONFIG_ACS
|
|
|
|
|
case EVENT_ACS_CHANNEL_SELECTED:
|
2015-03-11 21:03:58 +01:00
|
|
|
hostapd_acs_channel_selected(hapd,
|
|
|
|
|
&data->acs_selected_channels);
|
2014-11-18 19:11:09 +01:00
|
|
|
break;
|
|
|
|
|
#endif /* CONFIG_ACS */
|
2009-04-16 15:22:40 +02:00
|
|
|
default:
|
|
|
|
|
wpa_printf(MSG_DEBUG, "Unknown event %d", event);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-12-13 22:05:39 +01:00
|
|
|
|
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 hapd_interfaces *interfaces = ctx;
|
|
|
|
|
struct hostapd_data *hapd;
|
|
|
|
|
|
|
|
|
|
if (event != EVENT_INTERFACE_STATUS)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
hapd = hostapd_get_iface(interfaces, data->interface_status.ifname);
|
|
|
|
|
if (hapd && hapd->driver && hapd->driver->get_ifindex &&
|
|
|
|
|
hapd->drv_priv) {
|
|
|
|
|
unsigned int ifindex;
|
|
|
|
|
|
|
|
|
|
ifindex = hapd->driver->get_ifindex(hapd->drv_priv);
|
|
|
|
|
if (ifindex != data->interface_status.ifindex) {
|
|
|
|
|
wpa_dbg(hapd->msg_ctx, MSG_DEBUG,
|
|
|
|
|
"interface status ifindex %d mismatch (%d)",
|
|
|
|
|
ifindex, data->interface_status.ifindex);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (hapd)
|
|
|
|
|
wpa_supplicant_event(hapd, event, data);
|
|
|
|
|
}
|
|
|
|
|
|
2009-12-13 22:05:39 +01:00
|
|
|
#endif /* HOSTAPD */
|