1 |
/* |
2 |
* hostapd / Callback functions for driver wrappers |
3 |
* Copyright (c) 2002-2009, Jouni Malinen <j@w1.fi> |
4 |
* |
5 |
* This software may be distributed under the terms of the BSD license. |
6 |
* See README for more details. |
7 |
*/ |
8 |
|
9 |
#include "utils/includes.h" |
10 |
|
11 |
#include "utils/common.h" |
12 |
#include "radius/radius.h" |
13 |
#include "drivers/driver.h" |
14 |
#include "common/ieee802_11_defs.h" |
15 |
#include "common/ieee802_11_common.h" |
16 |
#include "crypto/random.h" |
17 |
#include "p2p/p2p.h" |
18 |
#include "wps/wps.h" |
19 |
#include "wnm_ap.h" |
20 |
#include "hostapd.h" |
21 |
#include "ieee802_11.h" |
22 |
#include "sta_info.h" |
23 |
#include "accounting.h" |
24 |
#include "tkip_countermeasures.h" |
25 |
#include "ieee802_1x.h" |
26 |
#include "wpa_auth.h" |
27 |
#include "wps_hostapd.h" |
28 |
#include "ap_drv_ops.h" |
29 |
#include "ap_config.h" |
30 |
#include "hw_features.h" |
31 |
|
32 |
|
33 |
int hostapd_notif_assoc(struct hostapd_data *hapd, const u8 *addr, |
34 |
const u8 *req_ies, size_t req_ies_len, int reassoc) |
35 |
{ |
36 |
struct sta_info *sta; |
37 |
int new_assoc, res; |
38 |
struct ieee802_11_elems elems; |
39 |
const u8 *ie; |
40 |
size_t ielen; |
41 |
#ifdef CONFIG_IEEE80211R |
42 |
u8 buf[sizeof(struct ieee80211_mgmt) + 1024]; |
43 |
u8 *p = buf; |
44 |
#endif /* CONFIG_IEEE80211R */ |
45 |
u16 reason = WLAN_REASON_UNSPECIFIED; |
46 |
u16 status = WLAN_STATUS_SUCCESS; |
47 |
|
48 |
if (addr == NULL) { |
49 |
/* |
50 |
* This could potentially happen with unexpected event from the |
51 |
* driver wrapper. This was seen at least in one case where the |
52 |
* driver ended up being set to station mode while hostapd was |
53 |
* running, so better make sure we stop processing such an |
54 |
* event here. |
55 |
*/ |
56 |
wpa_printf(MSG_DEBUG, "hostapd_notif_assoc: Skip event with " |
57 |
"no address"); |
58 |
return -1; |
59 |
} |
60 |
random_add_randomness(addr, ETH_ALEN); |
61 |
|
62 |
hostapd_logger(hapd, addr, HOSTAPD_MODULE_IEEE80211, |
63 |
HOSTAPD_LEVEL_INFO, "associated"); |
64 |
|
65 |
ieee802_11_parse_elems(req_ies, req_ies_len, &elems, 0); |
66 |
if (elems.wps_ie) { |
67 |
ie = elems.wps_ie - 2; |
68 |
ielen = elems.wps_ie_len + 2; |
69 |
wpa_printf(MSG_DEBUG, "STA included WPS IE in (Re)AssocReq"); |
70 |
} else if (elems.rsn_ie) { |
71 |
ie = elems.rsn_ie - 2; |
72 |
ielen = elems.rsn_ie_len + 2; |
73 |
wpa_printf(MSG_DEBUG, "STA included RSN IE in (Re)AssocReq"); |
74 |
} else if (elems.wpa_ie) { |
75 |
ie = elems.wpa_ie - 2; |
76 |
ielen = elems.wpa_ie_len + 2; |
77 |
wpa_printf(MSG_DEBUG, "STA included WPA IE in (Re)AssocReq"); |
78 |
} else { |
79 |
ie = NULL; |
80 |
ielen = 0; |
81 |
wpa_printf(MSG_DEBUG, "STA did not include WPS/RSN/WPA IE in " |
82 |
"(Re)AssocReq"); |
83 |
} |
84 |
|
85 |
sta = ap_get_sta(hapd, addr); |
86 |
if (sta) { |
87 |
accounting_sta_stop(hapd, sta); |
88 |
|
89 |
/* |
90 |
* Make sure that the previously registered inactivity timer |
91 |
* will not remove the STA immediately. |
92 |
*/ |
93 |
sta->timeout_next = STA_NULLFUNC; |
94 |
} else { |
95 |
sta = ap_sta_add(hapd, addr); |
96 |
if (sta == NULL) { |
97 |
hostapd_drv_sta_disassoc(hapd, addr, |
98 |
WLAN_REASON_DISASSOC_AP_BUSY); |
99 |
return -1; |
100 |
} |
101 |
} |
102 |
sta->flags &= ~(WLAN_STA_WPS | WLAN_STA_MAYBE_WPS | WLAN_STA_WPS2); |
103 |
|
104 |
#ifdef CONFIG_P2P |
105 |
if (elems.p2p) { |
106 |
wpabuf_free(sta->p2p_ie); |
107 |
sta->p2p_ie = ieee802_11_vendor_ie_concat(req_ies, req_ies_len, |
108 |
P2P_IE_VENDOR_TYPE); |
109 |
} |
110 |
#endif /* CONFIG_P2P */ |
111 |
|
112 |
#ifdef CONFIG_HS20 |
113 |
wpabuf_free(sta->hs20_ie); |
114 |
if (elems.hs20 && elems.hs20_len > 4) { |
115 |
sta->hs20_ie = wpabuf_alloc_copy(elems.hs20 + 4, |
116 |
elems.hs20_len - 4); |
117 |
} else |
118 |
sta->hs20_ie = NULL; |
119 |
#endif /* CONFIG_HS20 */ |
120 |
|
121 |
if (hapd->conf->wpa) { |
122 |
if (ie == NULL || ielen == 0) { |
123 |
#ifdef CONFIG_WPS |
124 |
if (hapd->conf->wps_state) { |
125 |
wpa_printf(MSG_DEBUG, "STA did not include " |
126 |
"WPA/RSN IE in (Re)Association " |
127 |
"Request - possible WPS use"); |
128 |
sta->flags |= WLAN_STA_MAYBE_WPS; |
129 |
goto skip_wpa_check; |
130 |
} |
131 |
#endif /* CONFIG_WPS */ |
132 |
|
133 |
wpa_printf(MSG_DEBUG, "No WPA/RSN IE from STA"); |
134 |
return -1; |
135 |
} |
136 |
#ifdef CONFIG_WPS |
137 |
if (hapd->conf->wps_state && ie[0] == 0xdd && ie[1] >= 4 && |
138 |
os_memcmp(ie + 2, "\x00\x50\xf2\x04", 4) == 0) { |
139 |
struct wpabuf *wps; |
140 |
sta->flags |= WLAN_STA_WPS; |
141 |
wps = ieee802_11_vendor_ie_concat(ie, ielen, |
142 |
WPS_IE_VENDOR_TYPE); |
143 |
if (wps) { |
144 |
if (wps_is_20(wps)) { |
145 |
wpa_printf(MSG_DEBUG, "WPS: STA " |
146 |
"supports WPS 2.0"); |
147 |
sta->flags |= WLAN_STA_WPS2; |
148 |
} |
149 |
wpabuf_free(wps); |
150 |
} |
151 |
goto skip_wpa_check; |
152 |
} |
153 |
#endif /* CONFIG_WPS */ |
154 |
|
155 |
if (sta->wpa_sm == NULL) |
156 |
sta->wpa_sm = wpa_auth_sta_init(hapd->wpa_auth, |
157 |
sta->addr); |
158 |
if (sta->wpa_sm == NULL) { |
159 |
wpa_printf(MSG_ERROR, "Failed to initialize WPA state " |
160 |
"machine"); |
161 |
return -1; |
162 |
} |
163 |
res = wpa_validate_wpa_ie(hapd->wpa_auth, sta->wpa_sm, |
164 |
ie, ielen, |
165 |
elems.mdie, elems.mdie_len); |
166 |
if (res != WPA_IE_OK) { |
167 |
wpa_printf(MSG_DEBUG, "WPA/RSN information element " |
168 |
"rejected? (res %u)", res); |
169 |
wpa_hexdump(MSG_DEBUG, "IE", ie, ielen); |
170 |
if (res == WPA_INVALID_GROUP) { |
171 |
reason = WLAN_REASON_GROUP_CIPHER_NOT_VALID; |
172 |
status = WLAN_STATUS_GROUP_CIPHER_NOT_VALID; |
173 |
} else if (res == WPA_INVALID_PAIRWISE) { |
174 |
reason = WLAN_REASON_PAIRWISE_CIPHER_NOT_VALID; |
175 |
status = WLAN_STATUS_PAIRWISE_CIPHER_NOT_VALID; |
176 |
} else if (res == WPA_INVALID_AKMP) { |
177 |
reason = WLAN_REASON_AKMP_NOT_VALID; |
178 |
status = WLAN_STATUS_AKMP_NOT_VALID; |
179 |
} |
180 |
#ifdef CONFIG_IEEE80211W |
181 |
else if (res == WPA_MGMT_FRAME_PROTECTION_VIOLATION) { |
182 |
reason = WLAN_REASON_INVALID_IE; |
183 |
status = WLAN_STATUS_INVALID_IE; |
184 |
} else if (res == WPA_INVALID_MGMT_GROUP_CIPHER) { |
185 |
reason = WLAN_REASON_GROUP_CIPHER_NOT_VALID; |
186 |
status = WLAN_STATUS_GROUP_CIPHER_NOT_VALID; |
187 |
} |
188 |
#endif /* CONFIG_IEEE80211W */ |
189 |
else { |
190 |
reason = WLAN_REASON_INVALID_IE; |
191 |
status = WLAN_STATUS_INVALID_IE; |
192 |
} |
193 |
goto fail; |
194 |
} |
195 |
#ifdef CONFIG_IEEE80211W |
196 |
if ((sta->flags & WLAN_STA_MFP) && !sta->sa_query_timed_out && |
197 |
sta->sa_query_count > 0) |
198 |
ap_check_sa_query_timeout(hapd, sta); |
199 |
if ((sta->flags & WLAN_STA_MFP) && !sta->sa_query_timed_out && |
200 |
(sta->auth_alg != WLAN_AUTH_FT)) { |
201 |
/* |
202 |
* STA has already been associated with MFP and SA |
203 |
* Query timeout has not been reached. Reject the |
204 |
* association attempt temporarily and start SA Query, |
205 |
* if one is not pending. |
206 |
*/ |
207 |
|
208 |
if (sta->sa_query_count == 0) |
209 |
ap_sta_start_sa_query(hapd, sta); |
210 |
|
211 |
#ifdef CONFIG_IEEE80211R |
212 |
status = WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY; |
213 |
|
214 |
p = hostapd_eid_assoc_comeback_time(hapd, sta, p); |
215 |
|
216 |
hostapd_sta_assoc(hapd, addr, reassoc, status, buf, |
217 |
p - buf); |
218 |
#endif /* CONFIG_IEEE80211R */ |
219 |
return 0; |
220 |
} |
221 |
|
222 |
if (wpa_auth_uses_mfp(sta->wpa_sm)) |
223 |
sta->flags |= WLAN_STA_MFP; |
224 |
else |
225 |
sta->flags &= ~WLAN_STA_MFP; |
226 |
#endif /* CONFIG_IEEE80211W */ |
227 |
|
228 |
#ifdef CONFIG_IEEE80211R |
229 |
if (sta->auth_alg == WLAN_AUTH_FT) { |
230 |
status = wpa_ft_validate_reassoc(sta->wpa_sm, req_ies, |
231 |
req_ies_len); |
232 |
if (status != WLAN_STATUS_SUCCESS) { |
233 |
if (status == WLAN_STATUS_INVALID_PMKID) |
234 |
reason = WLAN_REASON_INVALID_IE; |
235 |
if (status == WLAN_STATUS_INVALID_MDIE) |
236 |
reason = WLAN_REASON_INVALID_IE; |
237 |
if (status == WLAN_STATUS_INVALID_FTIE) |
238 |
reason = WLAN_REASON_INVALID_IE; |
239 |
goto fail; |
240 |
} |
241 |
} |
242 |
#endif /* CONFIG_IEEE80211R */ |
243 |
} else if (hapd->conf->wps_state) { |
244 |
#ifdef CONFIG_WPS |
245 |
struct wpabuf *wps; |
246 |
if (req_ies) |
247 |
wps = ieee802_11_vendor_ie_concat(req_ies, req_ies_len, |
248 |
WPS_IE_VENDOR_TYPE); |
249 |
else |
250 |
wps = NULL; |
251 |
#ifdef CONFIG_WPS_STRICT |
252 |
if (wps && wps_validate_assoc_req(wps) < 0) { |
253 |
reason = WLAN_REASON_INVALID_IE; |
254 |
status = WLAN_STATUS_INVALID_IE; |
255 |
wpabuf_free(wps); |
256 |
goto fail; |
257 |
} |
258 |
#endif /* CONFIG_WPS_STRICT */ |
259 |
if (wps) { |
260 |
sta->flags |= WLAN_STA_WPS; |
261 |
if (wps_is_20(wps)) { |
262 |
wpa_printf(MSG_DEBUG, "WPS: STA supports " |
263 |
"WPS 2.0"); |
264 |
sta->flags |= WLAN_STA_WPS2; |
265 |
} |
266 |
} else |
267 |
sta->flags |= WLAN_STA_MAYBE_WPS; |
268 |
wpabuf_free(wps); |
269 |
#endif /* CONFIG_WPS */ |
270 |
} |
271 |
#ifdef CONFIG_WPS |
272 |
skip_wpa_check: |
273 |
#endif /* CONFIG_WPS */ |
274 |
|
275 |
#ifdef CONFIG_IEEE80211R |
276 |
p = wpa_sm_write_assoc_resp_ies(sta->wpa_sm, buf, sizeof(buf), |
277 |
sta->auth_alg, req_ies, req_ies_len); |
278 |
|
279 |
hostapd_sta_assoc(hapd, addr, reassoc, status, buf, p - buf); |
280 |
#else /* CONFIG_IEEE80211R */ |
281 |
/* Keep compiler silent about unused variables */ |
282 |
if (status) { |
283 |
} |
284 |
#endif /* CONFIG_IEEE80211R */ |
285 |
|
286 |
new_assoc = (sta->flags & WLAN_STA_ASSOC) == 0; |
287 |
sta->flags |= WLAN_STA_AUTH | WLAN_STA_ASSOC; |
288 |
|
289 |
if (reassoc && (sta->auth_alg == WLAN_AUTH_FT)) |
290 |
wpa_auth_sm_event(sta->wpa_sm, WPA_ASSOC_FT); |
291 |
else |
292 |
wpa_auth_sm_event(sta->wpa_sm, WPA_ASSOC); |
293 |
|
294 |
hostapd_new_assoc_sta(hapd, sta, !new_assoc); |
295 |
|
296 |
ieee802_1x_notify_port_enabled(sta->eapol_sm, 1); |
297 |
|
298 |
#ifdef CONFIG_P2P |
299 |
if (req_ies) { |
300 |
p2p_group_notif_assoc(hapd->p2p_group, sta->addr, |
301 |
req_ies, req_ies_len); |
302 |
} |
303 |
#endif /* CONFIG_P2P */ |
304 |
|
305 |
return 0; |
306 |
|
307 |
fail: |
308 |
#ifdef CONFIG_IEEE80211R |
309 |
hostapd_sta_assoc(hapd, addr, reassoc, status, buf, p - buf); |
310 |
#endif /* CONFIG_IEEE80211R */ |
311 |
hostapd_drv_sta_disassoc(hapd, sta->addr, reason); |
312 |
ap_free_sta(hapd, sta); |
313 |
return -1; |
314 |
} |
315 |
|
316 |
|
317 |
void hostapd_notif_disassoc(struct hostapd_data *hapd, const u8 *addr) |
318 |
{ |
319 |
struct sta_info *sta; |
320 |
|
321 |
if (addr == NULL) { |
322 |
/* |
323 |
* This could potentially happen with unexpected event from the |
324 |
* driver wrapper. This was seen at least in one case where the |
325 |
* driver ended up reporting a station mode event while hostapd |
326 |
* was running, so better make sure we stop processing such an |
327 |
* event here. |
328 |
*/ |
329 |
wpa_printf(MSG_DEBUG, "hostapd_notif_disassoc: Skip event " |
330 |
"with no address"); |
331 |
return; |
332 |
} |
333 |
|
334 |
hostapd_logger(hapd, addr, HOSTAPD_MODULE_IEEE80211, |
335 |
HOSTAPD_LEVEL_INFO, "disassociated"); |
336 |
|
337 |
sta = ap_get_sta(hapd, addr); |
338 |
if (sta == NULL) { |
339 |
wpa_printf(MSG_DEBUG, "Disassociation notification for " |
340 |
"unknown STA " MACSTR, MAC2STR(addr)); |
341 |
return; |
342 |
} |
343 |
|
344 |
ap_sta_set_authorized(hapd, sta, 0); |
345 |
sta->flags &= ~(WLAN_STA_AUTH | WLAN_STA_ASSOC); |
346 |
wpa_auth_sm_event(sta->wpa_sm, WPA_DISASSOC); |
347 |
sta->acct_terminate_cause = RADIUS_ACCT_TERMINATE_CAUSE_USER_REQUEST; |
348 |
ieee802_1x_notify_port_enabled(sta->eapol_sm, 0); |
349 |
ap_free_sta(hapd, sta); |
350 |
} |
351 |
|
352 |
|
353 |
void hostapd_event_sta_low_ack(struct hostapd_data *hapd, const u8 *addr) |
354 |
{ |
355 |
struct sta_info *sta = ap_get_sta(hapd, addr); |
356 |
|
357 |
if (!sta || !hapd->conf->disassoc_low_ack) |
358 |
return; |
359 |
|
360 |
hostapd_logger(hapd, addr, HOSTAPD_MODULE_IEEE80211, |
361 |
HOSTAPD_LEVEL_INFO, "disconnected due to excessive " |
362 |
"missing ACKs"); |
363 |
hostapd_drv_sta_disassoc(hapd, addr, WLAN_REASON_DISASSOC_LOW_ACK); |
364 |
if (sta) |
365 |
ap_sta_disassociate(hapd, sta, WLAN_REASON_DISASSOC_LOW_ACK); |
366 |
} |
367 |
|
368 |
|
369 |
void hostapd_event_ch_switch(struct hostapd_data *hapd, int freq, int ht, |
370 |
int offset) |
371 |
{ |
372 |
#ifdef NEED_AP_MLME |
373 |
int channel; |
374 |
|
375 |
hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211, |
376 |
HOSTAPD_LEVEL_INFO, "driver had channel switch: " |
377 |
"freq=%d, ht=%d, offset=%d", freq, ht, offset); |
378 |
|
379 |
hapd->iface->freq = freq; |
380 |
|
381 |
channel = hostapd_hw_get_channel(hapd, freq); |
382 |
if (!channel) { |
383 |
hostapd_logger(hapd, NULL, HOSTAPD_MODULE_IEEE80211, |
384 |
HOSTAPD_LEVEL_WARNING, "driver switched to " |
385 |
"bad channel!"); |
386 |
return; |
387 |
} |
388 |
|
389 |
hapd->iconf->channel = channel; |
390 |
hapd->iconf->ieee80211n = ht; |
391 |
hapd->iconf->secondary_channel = offset; |
392 |
#endif /* NEED_AP_MLME */ |
393 |
} |
394 |
|
395 |
|
396 |
int hostapd_probe_req_rx(struct hostapd_data *hapd, const u8 *sa, const u8 *da, |
397 |
const u8 *bssid, const u8 *ie, size_t ie_len, |
398 |
int ssi_signal) |
399 |
{ |
400 |
size_t i; |
401 |
int ret = 0; |
402 |
|
403 |
if (sa == NULL || ie == NULL) |
404 |
return -1; |
405 |
|
406 |
random_add_randomness(sa, ETH_ALEN); |
407 |
for (i = 0; hapd->probereq_cb && i < hapd->num_probereq_cb; i++) { |
408 |
if (hapd->probereq_cb[i].cb(hapd->probereq_cb[i].ctx, |
409 |
sa, da, bssid, ie, ie_len, |
410 |
ssi_signal) > 0) { |
411 |
ret = 1; |
412 |
break; |
413 |
} |
414 |
} |
415 |
return ret; |
416 |
} |
417 |
|
418 |
|
419 |
#ifdef HOSTAPD |
420 |
|
421 |
#ifdef CONFIG_IEEE80211R |
422 |
static void hostapd_notify_auth_ft_finish(void *ctx, const u8 *dst, |
423 |
const u8 *bssid, |
424 |
u16 auth_transaction, u16 status, |
425 |
const u8 *ies, size_t ies_len) |
426 |
{ |
427 |
struct hostapd_data *hapd = ctx; |
428 |
struct sta_info *sta; |
429 |
|
430 |
sta = ap_get_sta(hapd, dst); |
431 |
if (sta == NULL) |
432 |
return; |
433 |
|
434 |
hostapd_logger(hapd, dst, HOSTAPD_MODULE_IEEE80211, |
435 |
HOSTAPD_LEVEL_DEBUG, "authentication OK (FT)"); |
436 |
sta->flags |= WLAN_STA_AUTH; |
437 |
|
438 |
hostapd_sta_auth(hapd, dst, auth_transaction, status, ies, ies_len); |
439 |
} |
440 |
#endif /* CONFIG_IEEE80211R */ |
441 |
|
442 |
|
443 |
static void hostapd_notif_auth(struct hostapd_data *hapd, |
444 |
struct auth_info *rx_auth) |
445 |
{ |
446 |
struct sta_info *sta; |
447 |
u16 status = WLAN_STATUS_SUCCESS; |
448 |
u8 resp_ies[2 + WLAN_AUTH_CHALLENGE_LEN]; |
449 |
size_t resp_ies_len = 0; |
450 |
|
451 |
sta = ap_get_sta(hapd, rx_auth->peer); |
452 |
if (!sta) { |
453 |
sta = ap_sta_add(hapd, rx_auth->peer); |
454 |
if (sta == NULL) { |
455 |
status = WLAN_STATUS_UNSPECIFIED_FAILURE; |
456 |
goto fail; |
457 |
} |
458 |
} |
459 |
sta->flags &= ~WLAN_STA_PREAUTH; |
460 |
ieee802_1x_notify_pre_auth(sta->eapol_sm, 0); |
461 |
#ifdef CONFIG_IEEE80211R |
462 |
if (rx_auth->auth_type == WLAN_AUTH_FT && hapd->wpa_auth) { |
463 |
sta->auth_alg = WLAN_AUTH_FT; |
464 |
if (sta->wpa_sm == NULL) |
465 |
sta->wpa_sm = wpa_auth_sta_init(hapd->wpa_auth, |
466 |
sta->addr); |
467 |
if (sta->wpa_sm == NULL) { |
468 |
wpa_printf(MSG_DEBUG, "FT: Failed to initialize WPA " |
469 |
"state machine"); |
470 |
status = WLAN_STATUS_UNSPECIFIED_FAILURE; |
471 |
goto fail; |
472 |
} |
473 |
wpa_ft_process_auth(sta->wpa_sm, rx_auth->bssid, |
474 |
rx_auth->auth_transaction, rx_auth->ies, |
475 |
rx_auth->ies_len, |
476 |
hostapd_notify_auth_ft_finish, hapd); |
477 |
return; |
478 |
} |
479 |
#endif /* CONFIG_IEEE80211R */ |
480 |
fail: |
481 |
hostapd_sta_auth(hapd, rx_auth->peer, rx_auth->auth_transaction + 1, |
482 |
status, resp_ies, resp_ies_len); |
483 |
} |
484 |
|
485 |
|
486 |
static void hostapd_action_rx(struct hostapd_data *hapd, |
487 |
struct rx_action *action) |
488 |
{ |
489 |
struct sta_info *sta; |
490 |
|
491 |
wpa_printf(MSG_DEBUG, "RX_ACTION cat %d action plen %d", |
492 |
action->category, (int) action->len); |
493 |
|
494 |
sta = ap_get_sta(hapd, action->sa); |
495 |
if (sta == NULL) { |
496 |
wpa_printf(MSG_DEBUG, "%s: station not found", __func__); |
497 |
return; |
498 |
} |
499 |
#ifdef CONFIG_IEEE80211R |
500 |
if (action->category == WLAN_ACTION_FT) { |
501 |
wpa_printf(MSG_DEBUG, "%s: FT_ACTION length %d", |
502 |
__func__, (int) action->len); |
503 |
wpa_ft_action_rx(sta->wpa_sm, action->data, action->len); |
504 |
} |
505 |
#endif /* CONFIG_IEEE80211R */ |
506 |
#ifdef CONFIG_IEEE80211W |
507 |
if (action->category == WLAN_ACTION_SA_QUERY && action->len >= 4) { |
508 |
wpa_printf(MSG_DEBUG, "%s: SA_QUERY_ACTION length %d", |
509 |
__func__, (int) action->len); |
510 |
ieee802_11_sa_query_action(hapd, action->sa, |
511 |
*(action->data + 1), |
512 |
action->data + 2); |
513 |
} |
514 |
#endif /* CONFIG_IEEE80211W */ |
515 |
#ifdef CONFIG_WNM |
516 |
if (action->category == WLAN_ACTION_WNM) { |
517 |
wpa_printf(MSG_DEBUG, "%s: WNM_ACTION length %d", |
518 |
__func__, (int) action->len); |
519 |
ieee802_11_rx_wnm_action_ap(hapd, action); |
520 |
} |
521 |
#endif /* CONFIG_WNM */ |
522 |
} |
523 |
|
524 |
|
525 |
#ifdef NEED_AP_MLME |
526 |
|
527 |
#define HAPD_BROADCAST ((struct hostapd_data *) -1) |
528 |
|
529 |
static struct hostapd_data * get_hapd_bssid(struct hostapd_iface *iface, |
530 |
const u8 *bssid) |
531 |
{ |
532 |
size_t i; |
533 |
|
534 |
if (bssid == NULL) |
535 |
return NULL; |
536 |
if (bssid[0] == 0xff && bssid[1] == 0xff && bssid[2] == 0xff && |
537 |
bssid[3] == 0xff && bssid[4] == 0xff && bssid[5] == 0xff) |
538 |
return HAPD_BROADCAST; |
539 |
|
540 |
for (i = 0; i < iface->num_bss; i++) { |
541 |
if (os_memcmp(bssid, iface->bss[i]->own_addr, ETH_ALEN) == 0) |
542 |
return iface->bss[i]; |
543 |
} |
544 |
|
545 |
return NULL; |
546 |
} |
547 |
|
548 |
|
549 |
static void hostapd_rx_from_unknown_sta(struct hostapd_data *hapd, |
550 |
const u8 *bssid, const u8 *addr, |
551 |
int wds) |
552 |
{ |
553 |
hapd = get_hapd_bssid(hapd->iface, bssid); |
554 |
if (hapd == NULL || hapd == HAPD_BROADCAST) |
555 |
return; |
556 |
|
557 |
ieee802_11_rx_from_unknown(hapd, addr, wds); |
558 |
} |
559 |
|
560 |
|
561 |
static void hostapd_mgmt_rx(struct hostapd_data *hapd, struct rx_mgmt *rx_mgmt) |
562 |
{ |
563 |
struct hostapd_iface *iface = hapd->iface; |
564 |
const struct ieee80211_hdr *hdr; |
565 |
const u8 *bssid; |
566 |
struct hostapd_frame_info fi; |
567 |
|
568 |
hdr = (const struct ieee80211_hdr *) rx_mgmt->frame; |
569 |
bssid = get_hdr_bssid(hdr, rx_mgmt->frame_len); |
570 |
if (bssid == NULL) |
571 |
return; |
572 |
|
573 |
hapd = get_hapd_bssid(iface, bssid); |
574 |
if (hapd == NULL) { |
575 |
u16 fc; |
576 |
fc = le_to_host16(hdr->frame_control); |
577 |
|
578 |
/* |
579 |
* Drop frames to unknown BSSIDs except for Beacon frames which |
580 |
* could be used to update neighbor information. |
581 |
*/ |
582 |
if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT && |
583 |
WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_BEACON) |
584 |
hapd = iface->bss[0]; |
585 |
else |
586 |
return; |
587 |
} |
588 |
|
589 |
os_memset(&fi, 0, sizeof(fi)); |
590 |
fi.datarate = rx_mgmt->datarate; |
591 |
fi.ssi_signal = rx_mgmt->ssi_signal; |
592 |
|
593 |
if (hapd == HAPD_BROADCAST) { |
594 |
size_t i; |
595 |
for (i = 0; i < iface->num_bss; i++) |
596 |
ieee802_11_mgmt(iface->bss[i], rx_mgmt->frame, |
597 |
rx_mgmt->frame_len, &fi); |
598 |
} else |
599 |
ieee802_11_mgmt(hapd, rx_mgmt->frame, rx_mgmt->frame_len, &fi); |
600 |
|
601 |
random_add_randomness(&fi, sizeof(fi)); |
602 |
} |
603 |
|
604 |
|
605 |
static void hostapd_rx_action(struct hostapd_data *hapd, |
606 |
struct rx_action *rx_action) |
607 |
{ |
608 |
struct rx_mgmt rx_mgmt; |
609 |
u8 *buf; |
610 |
struct ieee80211_hdr *hdr; |
611 |
|
612 |
wpa_printf(MSG_DEBUG, "EVENT_RX_ACTION DA=" MACSTR " SA=" MACSTR |
613 |
" BSSID=" MACSTR " category=%u", |
614 |
MAC2STR(rx_action->da), MAC2STR(rx_action->sa), |
615 |
MAC2STR(rx_action->bssid), rx_action->category); |
616 |
wpa_hexdump(MSG_MSGDUMP, "Received action frame contents", |
617 |
rx_action->data, rx_action->len); |
618 |
|
619 |
buf = os_zalloc(24 + 1 + rx_action->len); |
620 |
if (buf == NULL) |
621 |
return; |
622 |
hdr = (struct ieee80211_hdr *) buf; |
623 |
hdr->frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT, |
624 |
WLAN_FC_STYPE_ACTION); |
625 |
if (rx_action->category == WLAN_ACTION_SA_QUERY) { |
626 |
/* |
627 |
* Assume frame was protected; it would have been dropped if |
628 |
* not. |
629 |
*/ |
630 |
hdr->frame_control |= host_to_le16(WLAN_FC_ISWEP); |
631 |
} |
632 |
os_memcpy(hdr->addr1, rx_action->da, ETH_ALEN); |
633 |
os_memcpy(hdr->addr2, rx_action->sa, ETH_ALEN); |
634 |
os_memcpy(hdr->addr3, rx_action->bssid, ETH_ALEN); |
635 |
buf[24] = rx_action->category; |
636 |
os_memcpy(buf + 24 + 1, rx_action->data, rx_action->len); |
637 |
os_memset(&rx_mgmt, 0, sizeof(rx_mgmt)); |
638 |
rx_mgmt.frame = buf; |
639 |
rx_mgmt.frame_len = 24 + 1 + rx_action->len; |
640 |
hostapd_mgmt_rx(hapd, &rx_mgmt); |
641 |
os_free(buf); |
642 |
} |
643 |
|
644 |
|
645 |
static void hostapd_mgmt_tx_cb(struct hostapd_data *hapd, const u8 *buf, |
646 |
size_t len, u16 stype, int ok) |
647 |
{ |
648 |
struct ieee80211_hdr *hdr; |
649 |
hdr = (struct ieee80211_hdr *) buf; |
650 |
hapd = get_hapd_bssid(hapd->iface, get_hdr_bssid(hdr, len)); |
651 |
if (hapd == NULL || hapd == HAPD_BROADCAST) |
652 |
return; |
653 |
ieee802_11_mgmt_cb(hapd, buf, len, stype, ok); |
654 |
} |
655 |
|
656 |
#endif /* NEED_AP_MLME */ |
657 |
|
658 |
|
659 |
static int hostapd_event_new_sta(struct hostapd_data *hapd, const u8 *addr) |
660 |
{ |
661 |
struct sta_info *sta = ap_get_sta(hapd, addr); |
662 |
if (sta) |
663 |
return 0; |
664 |
|
665 |
wpa_printf(MSG_DEBUG, "Data frame from unknown STA " MACSTR |
666 |
" - adding a new STA", MAC2STR(addr)); |
667 |
sta = ap_sta_add(hapd, addr); |
668 |
if (sta) { |
669 |
hostapd_new_assoc_sta(hapd, sta, 0); |
670 |
} else { |
671 |
wpa_printf(MSG_DEBUG, "Failed to add STA entry for " MACSTR, |
672 |
MAC2STR(addr)); |
673 |
return -1; |
674 |
} |
675 |
|
676 |
return 0; |
677 |
} |
678 |
|
679 |
|
680 |
static void hostapd_event_eapol_rx(struct hostapd_data *hapd, const u8 *src, |
681 |
const u8 *data, size_t data_len) |
682 |
{ |
683 |
struct hostapd_iface *iface = hapd->iface; |
684 |
struct sta_info *sta; |
685 |
size_t j; |
686 |
|
687 |
for (j = 0; j < iface->num_bss; j++) { |
688 |
if ((sta = ap_get_sta(iface->bss[j], src))) { |
689 |
if (sta->flags & WLAN_STA_ASSOC) { |
690 |
hapd = iface->bss[j]; |
691 |
break; |
692 |
} |
693 |
} |
694 |
} |
695 |
|
696 |
ieee802_1x_receive(hapd, src, data, data_len); |
697 |
} |
698 |
|
699 |
|
700 |
void wpa_supplicant_event(void *ctx, enum wpa_event_type event, |
701 |
union wpa_event_data *data) |
702 |
{ |
703 |
struct hostapd_data *hapd = ctx; |
704 |
#ifndef CONFIG_NO_STDOUT_DEBUG |
705 |
int level = MSG_DEBUG; |
706 |
|
707 |
if (event == EVENT_RX_MGMT && data->rx_mgmt.frame && |
708 |
data->rx_mgmt.frame_len >= 24) { |
709 |
const struct ieee80211_hdr *hdr; |
710 |
u16 fc; |
711 |
hdr = (const struct ieee80211_hdr *) data->rx_mgmt.frame; |
712 |
fc = le_to_host16(hdr->frame_control); |
713 |
if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT && |
714 |
WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_BEACON) |
715 |
level = MSG_EXCESSIVE; |
716 |
} |
717 |
|
718 |
wpa_dbg(hapd->msg_ctx, level, "Event %s (%d) received", |
719 |
event_to_string(event), event); |
720 |
#endif /* CONFIG_NO_STDOUT_DEBUG */ |
721 |
|
722 |
switch (event) { |
723 |
case EVENT_MICHAEL_MIC_FAILURE: |
724 |
michael_mic_failure(hapd, data->michael_mic_failure.src, 1); |
725 |
break; |
726 |
case EVENT_SCAN_RESULTS: |
727 |
if (hapd->iface->scan_cb) |
728 |
hapd->iface->scan_cb(hapd->iface); |
729 |
break; |
730 |
#ifdef CONFIG_IEEE80211R |
731 |
case EVENT_FT_RRB_RX: |
732 |
wpa_ft_rrb_rx(hapd->wpa_auth, data->ft_rrb_rx.src, |
733 |
data->ft_rrb_rx.data, data->ft_rrb_rx.data_len); |
734 |
break; |
735 |
#endif /* CONFIG_IEEE80211R */ |
736 |
case EVENT_WPS_BUTTON_PUSHED: |
737 |
hostapd_wps_button_pushed(hapd, NULL); |
738 |
break; |
739 |
#ifdef NEED_AP_MLME |
740 |
case EVENT_TX_STATUS: |
741 |
switch (data->tx_status.type) { |
742 |
case WLAN_FC_TYPE_MGMT: |
743 |
hostapd_mgmt_tx_cb(hapd, data->tx_status.data, |
744 |
data->tx_status.data_len, |
745 |
data->tx_status.stype, |
746 |
data->tx_status.ack); |
747 |
break; |
748 |
case WLAN_FC_TYPE_DATA: |
749 |
hostapd_tx_status(hapd, data->tx_status.dst, |
750 |
data->tx_status.data, |
751 |
data->tx_status.data_len, |
752 |
data->tx_status.ack); |
753 |
break; |
754 |
} |
755 |
break; |
756 |
case EVENT_EAPOL_TX_STATUS: |
757 |
hostapd_eapol_tx_status(hapd, data->eapol_tx_status.dst, |
758 |
data->eapol_tx_status.data, |
759 |
data->eapol_tx_status.data_len, |
760 |
data->eapol_tx_status.ack); |
761 |
break; |
762 |
case EVENT_DRIVER_CLIENT_POLL_OK: |
763 |
hostapd_client_poll_ok(hapd, data->client_poll.addr); |
764 |
break; |
765 |
case EVENT_RX_FROM_UNKNOWN: |
766 |
hostapd_rx_from_unknown_sta(hapd, data->rx_from_unknown.bssid, |
767 |
data->rx_from_unknown.addr, |
768 |
data->rx_from_unknown.wds); |
769 |
break; |
770 |
case EVENT_RX_MGMT: |
771 |
hostapd_mgmt_rx(hapd, &data->rx_mgmt); |
772 |
break; |
773 |
#endif /* NEED_AP_MLME */ |
774 |
case EVENT_RX_PROBE_REQ: |
775 |
if (data->rx_probe_req.sa == NULL || |
776 |
data->rx_probe_req.ie == NULL) |
777 |
break; |
778 |
hostapd_probe_req_rx(hapd, data->rx_probe_req.sa, |
779 |
data->rx_probe_req.da, |
780 |
data->rx_probe_req.bssid, |
781 |
data->rx_probe_req.ie, |
782 |
data->rx_probe_req.ie_len, |
783 |
data->rx_probe_req.ssi_signal); |
784 |
break; |
785 |
case EVENT_NEW_STA: |
786 |
hostapd_event_new_sta(hapd, data->new_sta.addr); |
787 |
break; |
788 |
case EVENT_EAPOL_RX: |
789 |
hostapd_event_eapol_rx(hapd, data->eapol_rx.src, |
790 |
data->eapol_rx.data, |
791 |
data->eapol_rx.data_len); |
792 |
break; |
793 |
case EVENT_ASSOC: |
794 |
hostapd_notif_assoc(hapd, data->assoc_info.addr, |
795 |
data->assoc_info.req_ies, |
796 |
data->assoc_info.req_ies_len, |
797 |
data->assoc_info.reassoc); |
798 |
break; |
799 |
case EVENT_DISASSOC: |
800 |
if (data) |
801 |
hostapd_notif_disassoc(hapd, data->disassoc_info.addr); |
802 |
break; |
803 |
case EVENT_DEAUTH: |
804 |
if (data) |
805 |
hostapd_notif_disassoc(hapd, data->deauth_info.addr); |
806 |
break; |
807 |
case EVENT_STATION_LOW_ACK: |
808 |
if (!data) |
809 |
break; |
810 |
hostapd_event_sta_low_ack(hapd, data->low_ack.addr); |
811 |
break; |
812 |
case EVENT_RX_ACTION: |
813 |
if (data->rx_action.da == NULL || data->rx_action.sa == NULL || |
814 |
data->rx_action.bssid == NULL) |
815 |
break; |
816 |
#ifdef NEED_AP_MLME |
817 |
hostapd_rx_action(hapd, &data->rx_action); |
818 |
#endif /* NEED_AP_MLME */ |
819 |
hostapd_action_rx(hapd, &data->rx_action); |
820 |
break; |
821 |
case EVENT_AUTH: |
822 |
hostapd_notif_auth(hapd, &data->auth); |
823 |
break; |
824 |
case EVENT_CH_SWITCH: |
825 |
if (!data) |
826 |
break; |
827 |
hostapd_event_ch_switch(hapd, data->ch_switch.freq, |
828 |
data->ch_switch.ht_enabled, |
829 |
data->ch_switch.ch_offset); |
830 |
break; |
831 |
default: |
832 |
wpa_printf(MSG_DEBUG, "Unknown event %d", event); |
833 |
break; |
834 |
} |
835 |
} |
836 |
|
837 |
#endif /* HOSTAPD */ |